@openclaw/codex 2026.6.11 → 2026.7.1-1

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

@@ -1,19 +1,21 @@
-import { n as isJsonObject } from "./protocol-dh-ETiNd.js";
-import { d as resolveCodexAppServerRuntimeOptions, o as isCodexFastServiceTier } from "./config-CszD0vP3.js";
-import { n as listCodexAppServerModels, t as listAllCodexAppServerModels } from "./models-CAmfBWRl.js";
-import { l as summarizeCodexAccountUsage } from "./provider-B-OHpbD3.js";
-import { l as writeCodexAppServerBinding, n as clearCodexAppServerBinding, o as readCodexAppServerBinding } from "./session-binding-HOuPt-E0.js";
-import { i as describeControlFailure, r as CODEX_CONTROL_METHODS } from "./plugin-app-cache-key-C9ILt7bl.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-BPTiVNsW.js";
-import { n as resolveCodexNativeExecutionBlock, r as resolveCodexNativeSandboxBlock } from "./sandbox-guard-3tnjhjFb.js";
-import { _ as steerCodexConversationTurn, b as readCodexConversationBindingData, d as parseCodexFastModeArg, f as parseCodexPermissionsModeArg, g as setCodexConversationPermissions, h as setCodexConversationModel, m as setCodexConversationFastMode, o as formatCodexCliSessions, p as readCodexConversationActiveTurn, r as startCodexConversationThread, u as formatPermissionsMode, v as stopCodexConversationTurn, x as resolveCodexDefaultWorkspaceDir, y as createCodexCliNodeConversationBindingData } from "./conversation-binding-t0XMLz-j.js";
-import { t as requestCodexAppServerJson } from "./request-Dcd452Nk.js";
-import { n as installCodexComputerUse, r as readCodexComputerUseStatus } from "./computer-use-ClrJwoFp.js";
-import { n as rememberCodexRateLimits } from "./rate-limit-cache-C7qmZ0Jh.js";
+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-zjPfx5Fs.js";
+import { y as resolveCodexAppServerAuthProfileIdForAgent } from "./shared-client-4ICy3U6d.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-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-Bmaz333N.js";
 import { parseStrictPositiveInteger } from "openclaw/plugin-sdk/number-runtime";
-import { normalizeOptionalString, normalizeUniqueStringEntries } from "openclaw/plugin-sdk/string-coerce-runtime";
 import crypto from "node:crypto";
 import { ensureAuthProfileStore, findNormalizedProviderValue, resolveAgentDir, resolveAuthProfileEligibility, resolveAuthProfileOrder, resolveDefaultAgentDir, resolveProfileUnusableUntilForDisplay, resolveSessionAgentIds } from "openclaw/plugin-sdk/agent-runtime";
+import { parseAgentSessionKey } from "openclaw/plugin-sdk/routing";
+import { normalizeOptionalString, normalizeUniqueStringEntries } from "openclaw/plugin-sdk/string-coerce-runtime";
 //#region extensions/codex/src/command-account.ts
 const OPENAI_PROVIDER_ID = "openai";
 const OPENAI_CODEX_PROVIDER_ID = OPENAI_PROVIDER_ID;
@@ -163,7 +165,6 @@ async function readSubscriptionUsage(params) {
 		isolated: true
 	});
 	if (!limits.ok) return;
-	rememberCodexRateLimits(limits.value);
 	return summarizeCodexAccountUsage(limits.value, params.now);
 }
 function buildProfileRow(params) {
@@ -349,7 +350,7 @@ async function handleCodexPluginsSubcommand(ctx, rest, io) {
 	if (normalized === "enable" || normalized === "disable") {
 		if (args.length === 0) return buildPluginNamePickerReply(normalized, await io.readConfig());
 		if (!target || args.length > 1) return { text: `Usage: /codex plugins ${normalized} <name>` };
-		if (!canMutateCodexPlugins(ctx)) return { text: `Only an owner or operator.admin gateway client can run /codex plugins ${normalized}.` };
+		if (!canMutateCodexHost(ctx)) return { text: `Only an owner or operator.admin gateway client can run /codex plugins ${normalized}.` };
 		const wantEnabled = normalized === "enable";
 		if (!((await io.readConfig()).plugins ?? {})[target]) return { text: `Codex sub-plugin '${formatCodexDisplayText(target)}' is not configured. Run '/codex plugins list' to see configured plugins.` };
 		await io.mutate((block) => {
@@ -440,10 +441,6 @@ function buildPluginNamePickerReply(verb, current) {
 		presentation: buildCodexCommandPickerPresentation("Codex sub-plugins", `Pick a Codex sub-plugin to ${verb}:`, buttons)
 	};
 }
-function canMutateCodexPlugins(ctx) {
-	if (ctx.senderIsOwner === true) return true;
-	return ctx.gatewayClientScopes?.includes("operator.admin") === true;
-}
 function buildPluginsHelp() {
 	return [
 		"Codex sub-plugin management (writes only to ~/.openclaw/openclaw.json, never to ~/.codex/config.toml):",
@@ -479,81 +476,16 @@ function formatPluginList(plugins, options = {}) {
 	].join("\n");
 }
 //#endregion
-//#region extensions/codex/src/command-rpc.ts
-function requestOptions(pluginConfig, limit, config) {
-	const runtime = resolveCodexAppServerRuntimeOptions({ pluginConfig });
-	return {
-		limit,
-		timeoutMs: runtime.requestTimeoutMs,
-		startOptions: runtime.start,
-		config
-	};
-}
-async function codexControlRequest(pluginConfig, method, requestParams, options = {}) {
-	const runtime = resolveCodexAppServerRuntimeOptions({ pluginConfig });
-	return await requestCodexAppServerJson({
-		method,
-		requestParams,
-		timeoutMs: runtime.requestTimeoutMs,
-		startOptions: runtime.start,
-		config: options.config,
-		sessionKey: options.sessionKey,
-		sessionId: options.sessionId,
-		authProfileId: options.authProfileId,
-		agentDir: options.agentDir,
-		isolated: options.isolated
-	});
-}
-async function safeCodexControlRequest(pluginConfig, method, requestParams, options = {}) {
-	return await safeValue(async () => await codexControlRequest(pluginConfig, method, requestParams, options));
-}
-async function safeCodexModelList(pluginConfig, limit, config) {
-	return await safeValue(async () => await listCodexAppServerModels(requestOptions(pluginConfig, limit, config)));
-}
-async function readCodexStatusProbes(pluginConfig, config) {
-	const [models, account, limits, mcps, skills] = await Promise.all([
-		safeCodexModelList(pluginConfig, 20, config),
-		safeCodexControlRequest(pluginConfig, CODEX_CONTROL_METHODS.account, { refreshToken: false }, { config }),
-		safeCodexControlRequest(pluginConfig, CODEX_CONTROL_METHODS.rateLimits, void 0, { config }),
-		safeCodexControlRequest(pluginConfig, CODEX_CONTROL_METHODS.listMcpServers, { limit: 100 }, { config }),
-		safeCodexControlRequest(pluginConfig, CODEX_CONTROL_METHODS.listSkills, {}, { config })
-	]);
-	return {
-		models,
-		account,
-		limits,
-		mcps,
-		skills
-	};
-}
-async function safeValue(read) {
-	try {
-		return {
-			ok: true,
-			value: await read()
-		};
-	} catch (error) {
-		return {
-			ok: false,
-			error: describeControlFailure(error)
-		};
-	}
-}
-//#endregion
 //#region extensions/codex/src/command-handlers.ts
 const defaultCodexCommandDeps = {
 	codexControlRequest,
 	listCodexAppServerModels: listAllCodexAppServerModels,
 	readCodexStatusProbes,
-	readCodexAppServerBinding,
 	requestOptions,
 	safeCodexControlRequest,
-	writeCodexAppServerBinding,
-	clearCodexAppServerBinding,
 	readCodexComputerUseStatus,
 	installCodexComputerUse,
 	resolveCodexDefaultWorkspaceDir,
-	startCodexConversationThread,
 	readCodexConversationActiveTurn,
 	setCodexConversationFastMode,
 	setCodexConversationModel,
@@ -578,7 +510,7 @@ const CODEX_DIAGNOSTICS_CONFIRMATION_MAX_REQUESTS_PER_SCOPE = 100;
 const CODEX_DIAGNOSTICS_CONFIRMATION_MAX_SCOPES = 100;
 const CODEX_DIAGNOSTICS_SCOPE_FIELD_MAX_CHARS = 128;
 const CODEX_RESUME_SAFE_THREAD_ID_PATTERN = /^[A-Za-z0-9._:-]+$/;
-const CODEX_NATIVE_EXECUTION_SUBCOMMANDS = new Set([
+const CODEX_NATIVE_EXECUTION_SUBCOMMANDS = /* @__PURE__ */ new Set([
 	"bind",
 	"resume",
 	"steer",
@@ -588,6 +520,12 @@ const CODEX_NATIVE_EXECUTION_SUBCOMMANDS = new Set([
 	"compact",
 	"review"
 ]);
+const CODEX_NATIVE_CONTROL_SUBCOMMANDS = /* @__PURE__ */ new Set([
+	...CODEX_NATIVE_EXECUTION_SUBCOMMANDS,
+	"detach",
+	"unbind",
+	"stop"
+]);
 const lastCodexDiagnosticsUploadByThread = /* @__PURE__ */ new Map();
 const lastCodexDiagnosticsUploadByScope = /* @__PURE__ */ new Map();
 const pendingCodexDiagnosticsConfirmations = /* @__PURE__ */ new Map();
@@ -725,6 +663,7 @@ async function handleCodexSubcommand(ctx, options) {
 	const [subcommand = "status", ...rest] = args;
 	const normalized = subcommand.toLowerCase();
 	if (normalized === "help") return { text: buildHelp() };
+	if (CODEX_NATIVE_CONTROL_SUBCOMMANDS.has(normalized) && !returnsBeforeNativeCodexExecution(normalized, rest) && !canMutateCodexHost(ctx)) return { text: CODEX_NATIVE_EXECUTION_AUTH_ERROR };
 	const sandboxBlock = resolveCodexNativeCommandSandboxBlock(ctx, normalized, rest);
 	if (sandboxBlock) return { text: sandboxBlock };
 	if (normalized === "plugins") {
@@ -739,7 +678,7 @@ async function handleCodexSubcommand(ctx, options) {
 		if (rest.length > 0) return { text: "Usage: /codex models" };
 		return { text: formatModels(await deps.listCodexAppServerModels(deps.requestOptions(options.pluginConfig, 100, ctx.config))) };
 	}
-	if (normalized === "threads") return { text: await buildThreads(deps, options.pluginConfig, rest.join(" ")) };
+	if (normalized === "threads") return { text: await buildThreads(deps, ctx, options.pluginConfig, rest.join(" ")) };
 	if (normalized === "sessions") return { text: await buildCodexCliSessions(deps, rest) };
 	if (normalized === "resume") return { text: await resumeThread(deps, ctx, options.pluginConfig, rest) };
 	if (normalized === "bind") return await bindConversation(deps, ctx, options.pluginConfig, rest);
@@ -759,31 +698,43 @@ async function handleCodexSubcommand(ctx, options) {
 	if (normalized === "model") return { text: await setConversationModel(deps, ctx, options.pluginConfig, rest) };
 	if (normalized === "fast") {
 		if (isMenuVerb(rest)) return buildCodexFastMenuReply();
-		return { text: await setConversationFastMode(deps, ctx, options.pluginConfig, rest) };
+		return { text: await setConversationFastMode(deps, ctx, rest) };
 	}
 	if (normalized === "permissions") {
 		if (isMenuVerb(rest)) return buildCodexPermissionsMenuReply();
-		return { text: await setConversationPermissions(deps, ctx, options.pluginConfig, rest) };
+		return { text: await setConversationPermissions(deps, ctx, rest) };
 	}
-	if (normalized === "compact") return { text: await startThreadAction(deps, ctx, options.pluginConfig, CODEX_CONTROL_METHODS.compact, "compaction", rest) };
-	if (normalized === "review") return { text: await startThreadAction(deps, ctx, options.pluginConfig, CODEX_CONTROL_METHODS.review, "review", rest) };
+	if (normalized === "compact") return { text: await startThreadAction(deps, ctx, options.pluginConfig, "compact", rest) };
+	if (normalized === "review") return { text: await startThreadAction(deps, ctx, options.pluginConfig, "review", rest) };
 	if (normalized === "diagnostics") return await handleCodexDiagnosticsFeedback(deps, ctx, options.pluginConfig, rest.join(" "), "/codex diagnostics");
 	if (normalized === "computer-use" || normalized === "computeruse") {
 		if (isMenuVerb(rest)) return buildCodexComputerUseMenuReply();
-		return { text: await handleComputerUseCommand(deps, options.pluginConfig, rest) };
+		return { text: await handleComputerUseCommand(deps, ctx, options.pluginConfig, rest) };
 	}
 	if (normalized === "mcp") {
 		if (rest.length > 0) return { text: "Usage: /codex mcp" };
-		return { text: formatList(await deps.codexControlRequest(options.pluginConfig, CODEX_CONTROL_METHODS.listMcpServers, { limit: 100 }), "MCP servers") };
+		const scope = await resolveCommandAppServerScope(deps, ctx);
+		return { text: formatList(await deps.codexControlRequest(options.pluginConfig, CODEX_CONTROL_METHODS.listMcpServers, { limit: 100 }, {
+			config: ctx.config,
+			...scope
+		}), "MCP servers") };
 	}
 	if (normalized === "skills") {
 		if (rest.length > 0) return { text: "Usage: /codex skills" };
-		return { text: formatSkills(await deps.codexControlRequest(options.pluginConfig, CODEX_CONTROL_METHODS.listSkills, {})) };
+		const scope = await resolveCommandAppServerScope(deps, ctx);
+		return { text: formatSkills(await deps.codexControlRequest(options.pluginConfig, CODEX_CONTROL_METHODS.listSkills, {}, {
+			config: ctx.config,
+			...scope
+		})) };
 	}
 	if (normalized === "account") {
 		if (rest.length > 0) return { text: "Usage: /codex account" };
-		const [account, limits] = await Promise.all([deps.safeCodexControlRequest(options.pluginConfig, CODEX_CONTROL_METHODS.account, { refreshToken: false }), deps.safeCodexControlRequest(options.pluginConfig, CODEX_CONTROL_METHODS.rateLimits, void 0)]);
-		if (limits.ok) rememberCodexRateLimits(limits.value);
+		const scope = await resolveCommandAppServerScope(deps, ctx);
+		const requestScope = {
+			config: ctx.config,
+			...scope
+		};
+		const [account, limits] = await Promise.all([deps.safeCodexControlRequest(options.pluginConfig, CODEX_CONTROL_METHODS.account, { refreshToken: false }, requestScope), deps.safeCodexControlRequest(options.pluginConfig, CODEX_CONTROL_METHODS.rateLimits, void 0, requestScope)]);
 		return { text: formatAccount(account, limits, await readCodexAccountAuthOverview({
 			ctx,
 			pluginConfig: options.pluginConfig,
@@ -805,6 +756,7 @@ function resolveCodexNativeCommandSandboxBlock(ctx, subcommand, args) {
 	});
 	return resolveCodexNativeExecutionBlock({
 		config: ctx.config,
+		agentId: ctx.agentId,
 		sessionKey: ctx.sessionKey,
 		sessionId: ctx.sessionId,
 		surface: `/${["codex", subcommand].join(" ")}`
@@ -820,6 +772,8 @@ function returnsBeforeNativeCodexExecution(subcommand, args) {
 		case "permissions": return args.length === 0 || args.length > 1 || parseCodexPermissionsModeArg(args[0]) === void 0;
 		case "compact":
 		case "review":
+		case "detach":
+		case "unbind":
 		case "stop": return args.length > 0;
 		default: return false;
 	}
@@ -836,9 +790,10 @@ function returnsBeforeNativeCodexResume(args) {
 	if (parsed.host) return !normalizedThreadId || parsed.bindHere !== true;
 	return !normalizedThreadId || args.length !== 1;
 }
-async function handleComputerUseCommand(deps, pluginConfig, args) {
+async function handleComputerUseCommand(deps, ctx, pluginConfig, args) {
 	const parsed = parseComputerUseArgs(args);
 	if (parsed.help) return ["Usage: /codex computer-use [status|install] [--source <marketplace-source>] [--marketplace-path <path>] [--marketplace <name>]", "Checks or installs the configured Codex Computer Use plugin through app-server."].join("\n");
+	if (parsed.action === "install" && !canMutateCodexHost(ctx)) return "Only an owner or operator.admin gateway client can configure Codex Computer Use.";
 	const params = {
 		pluginConfig,
 		forceEnable: parsed.action === "install" || parsed.hasOverrides,
@@ -850,53 +805,54 @@ async function handleComputerUseCommand(deps, pluginConfig, args) {
 async function bindConversation(deps, ctx, pluginConfig, args) {
 	const parsed = parseBindArgs(args);
 	if (parsed.help) return { text: "Usage: /codex bind [thread-id] [--cwd <path>] [--model <model>] [--provider <provider>]" };
-	if (!ctx.sessionFile) return { text: "Cannot bind Codex because this command did not include an OpenClaw session file." };
 	const scope = resolveCodexConversationControlScope(ctx);
 	const workspaceDir = parsed.cwd ?? deps.resolveCodexDefaultWorkspaceDir(pluginConfig);
-	const authProfileId = (await deps.readCodexAppServerBinding(ctx.sessionFile, {
-		agentDir: scope.agentDir,
+	const currentConversation = await ctx.getCurrentConversationBinding();
+	const currentConversationData = readCodexConversationBindingData(currentConversation);
+	const bindingId = currentConversationData?.kind === "codex-app-server-session" ? currentConversationData.bindingId : currentConversation ? `conversation-${currentConversation.bindingId}` : void 0;
+	const sessionOwner = ctx.sessionId ? sessionBindingIdentity({
+		sessionId: ctx.sessionId,
+		sessionKey: ctx.sessionKey,
+		agentId: scope.agentId,
 		config: ctx.config
-	}))?.authProfileId;
-	const startParams = {
-		pluginConfig,
-		config: ctx.config,
-		sessionFile: ctx.sessionFile,
+	}) : void 0;
+	const currentOwner = currentConversationData?.kind === "codex-app-server-session" ? conversationBindingIdentity(currentConversationData.bindingId) : sessionOwner;
+	const existingBinding = currentOwner ? await deps.bindingStore.read(currentOwner) : void 0;
+	const sessionSource = sessionOwner && existingBinding ? {
+		agentId: sessionOwner.agentId,
+		sessionId: sessionOwner.sessionId,
+		threadId: existingBinding.threadId,
+		...sessionOwner.sessionKey ? { sessionKey: sessionOwner.sessionKey } : {}
+	} : void 0;
+	const authProfileId = existingBinding?.authProfileId;
+	const data = createCodexConversationBindingData({
+		bindingId,
 		workspaceDir,
+		agentId: scope.agentId,
 		agentDir: scope.agentDir,
-		sessionKey: ctx.sessionKey,
-		agentId: scope.sessionAgentId,
-		threadId: parsed.threadId,
-		model: parsed.model,
-		modelProvider: parsed.provider
-	};
-	if (authProfileId) startParams.authProfileId = authProfileId;
-	const data = await deps.startCodexConversationThread(startParams);
-	const threadId = (await deps.readCodexAppServerBinding(ctx.sessionFile, {
-		agentDir: scope.agentDir,
-		config: ctx.config
-	}))?.threadId ?? parsed.threadId ?? "new thread";
-	const summary = `Codex app-server thread ${formatCodexDisplayText(threadId)} in ${formatCodexDisplayText(workspaceDir)}`;
-	let request;
-	try {
-		request = await ctx.requestConversationBinding({
-			summary,
-			detachHint: "/codex detach",
-			data
-		});
-	} catch (error) {
-		await deps.clearCodexAppServerBinding(ctx.sessionFile);
-		throw error;
-	}
-	if (request.status === "bound") return { text: `Bound this conversation to Codex thread ${formatCodexDisplayText(threadId)} in ${formatCodexDisplayText(workspaceDir)}.` };
+		source: currentConversationData?.kind === "codex-app-server-session" ? currentConversationData.source : sessionSource,
+		start: {
+			id: crypto.randomUUID(),
+			threadId: parsed.threadId,
+			model: parsed.model,
+			modelProvider: parsed.provider,
+			authProfileId
+		}
+	});
+	const threadLabel = parsed.threadId ?? "a new thread";
+	const request = await ctx.requestConversationBinding({
+		summary: `Codex app-server thread ${formatCodexDisplayText(threadLabel)} in ${formatCodexDisplayText(workspaceDir)}`,
+		detachHint: "/codex detach",
+		data
+	});
 	if (request.status === "pending") return request.reply;
-	await deps.clearCodexAppServerBinding(ctx.sessionFile);
-	return { text: formatCodexDisplayText(request.message) };
+	if (request.status === "error") return { text: formatCodexDisplayText(request.message) };
+	return { text: `Bound this conversation to ${formatCodexDisplayText(threadLabel)} in ${formatCodexDisplayText(workspaceDir)}. The next message will initialize it.` };
 }
 async function detachConversation(deps, ctx) {
 	const data = readCodexConversationBindingData(await ctx.getCurrentConversationBinding());
 	const detached = await ctx.detachConversationBinding();
-	if (data?.kind === "codex-app-server-session") await deps.clearCodexAppServerBinding(data.sessionFile);
-	else if (ctx.sessionFile) await deps.clearCodexAppServerBinding(ctx.sessionFile);
+	if (data?.kind === "codex-app-server-session") await deps.bindingStore.mutate(conversationBindingIdentity(data.bindingId), { kind: "clear" });
 	return detached.removed ? "Detached this conversation from Codex." : "No Codex conversation binding was attached.";
 }
 async function describeConversationBinding(deps, ctx) {
@@ -911,11 +867,9 @@ async function describeConversationBinding(deps, ctx) {
 		`- Workspace: ${formatCodexDisplayText(data.cwd ?? "unknown")}`,
 		"- Active run: not tracked"
 	].join("\n");
-	const threadBinding = await deps.readCodexAppServerBinding(data.sessionFile, {
-		agentDir: data.agentDir,
-		config: ctx.config
-	});
-	const active = deps.readCodexConversationActiveTurn(data.sessionFile);
+	const identity = conversationBindingIdentity(data.bindingId);
+	const threadBinding = await deps.bindingStore.read(identity);
+	const active = deps.readCodexConversationActiveTurn(identity);
 	return [
 		"Codex conversation binding:",
 		`- Thread: ${formatCodexDisplayText(threadBinding?.threadId ?? "unknown")}`,
@@ -924,13 +878,17 @@ async function describeConversationBinding(deps, ctx) {
 		`- Fast: ${isCodexFastServiceTier(threadBinding?.serviceTier) ? "on" : "off"}`,
 		`- Permissions: ${threadBinding ? formatPermissionsMode(threadBinding) : "default"}`,
 		`- Active run: ${formatCodexDisplayText(active ? active.turnId : "none")}`,
-		`- Session: ${formatCodexDisplayText(data.sessionFile)}`
+		`- Binding: ${formatCodexDisplayText(data.bindingId)}`
 	].join("\n");
 }
-async function buildThreads(deps, pluginConfig, filter) {
+async function buildThreads(deps, ctx, pluginConfig, filter) {
+	const scope = await resolveCommandAppServerScope(deps, ctx);
 	return formatThreads(await deps.codexControlRequest(pluginConfig, CODEX_CONTROL_METHODS.listThreads, {
 		limit: 10,
 		...filter.trim() ? { searchTerm: filter.trim() } : {}
+	}, {
+		config: ctx.config,
+		...scope
 	}));
 }
 async function buildCodexCliSessions(deps, args) {
@@ -948,20 +906,58 @@ async function resumeThread(deps, ctx, pluginConfig, args) {
 	if (parsed.help) return args.includes("--help") || args.includes("-h") || parsed.host ? "Usage: /codex resume <thread-id>\nUsage: /codex resume <session-id> --host <node> --bind here" : "Usage: /codex resume <thread-id>";
 	if (parsed.host) return await bindCodexCliNodeSession(deps, ctx, parsed);
 	if (!normalizedThreadId || args.length !== 1) return "Usage: /codex resume <thread-id>";
-	if (!ctx.sessionFile) return "Cannot attach a Codex thread because this command did not include an OpenClaw session file.";
-	const response = await deps.codexControlRequest(pluginConfig, CODEX_CONTROL_METHODS.resumeThread, {
-		threadId: normalizedThreadId,
-		persistExtendedHistory: true
+	if (!ctx.sessionId) return "Cannot attach a Codex thread because this command did not include an OpenClaw session id.";
+	const scope = resolveCodexConversationControlScope(ctx);
+	const identity = sessionBindingIdentity({
+		sessionId: ctx.sessionId,
+		sessionKey: ctx.sessionKey,
+		agentId: scope.agentId,
+		config: ctx.config
 	});
-	const thread = isJsonObject(response) && isJsonObject(response.thread) ? response.thread : {};
-	const effectiveThreadId = readString$1(thread, "id") ?? normalizedThreadId;
-	await deps.writeCodexAppServerBinding(ctx.sessionFile, {
-		threadId: effectiveThreadId,
-		cwd: readString$1(thread, "cwd") ?? "",
-		model: isJsonObject(response) ? readString$1(response, "model") : void 0,
-		modelProvider: isJsonObject(response) ? readString$1(response, "modelProvider") : void 0
+	return await deps.bindingStore.withLease(identity, async () => {
+		if (!await reclaimCurrentCodexSessionGeneration({
+			bindingStore: deps.bindingStore,
+			identity,
+			config: ctx.config
+		})) throw new Error(`Codex session generation is no longer current: ${identity.sessionId}`);
+		const authProfileId = resolveCodexAppServerAuthProfileIdForAgent({
+			authProfileId: (await deps.bindingStore.read(identity))?.authProfileId,
+			agentDir: scope.agentDir,
+			config: ctx.config
+		});
+		const response = assertCodexThreadResumeResponse(await deps.codexControlRequest(pluginConfig, CODEX_CONTROL_METHODS.resumeThread, {
+			threadId: normalizedThreadId,
+			excludeTurns: true
+		}, {
+			config: ctx.config,
+			agentDir: scope.agentDir,
+			authProfileId,
+			sessionKey: ctx.sessionKey,
+			sessionId: ctx.sessionId
+		}));
+		const effectiveThreadId = response.thread.id;
+		if (effectiveThreadId !== normalizedThreadId) throw new Error(`Codex thread/resume returned ${effectiveThreadId} for ${normalizedThreadId}`);
+		const resumedCwd = response.thread.cwd;
+		if (typeof resumedCwd !== "string") throw new Error(`Codex thread/resume returned no cwd for ${normalizedThreadId}`);
+		const modelProvider = normalizeCodexAppServerBindingModelProvider({
+			authProfileId,
+			modelProvider: response.modelProvider ?? void 0,
+			agentDir: scope.agentDir,
+			config: ctx.config
+		});
+		if (!await deps.bindingStore.mutate(identity, {
+			kind: "set",
+			binding: {
+				threadId: effectiveThreadId,
+				cwd: resumedCwd,
+				authProfileId,
+				model: response.model,
+				modelProvider,
+				historyCoveredThrough: (/* @__PURE__ */ new Date()).toISOString()
+			}
+		})) throw new Error("Codex thread binding changed while attaching the resumed thread.");
+		return `Attached this OpenClaw session to Codex thread ${formatCodexDisplayText(effectiveThreadId)}.`;
 	});
-	return `Attached this OpenClaw session to Codex thread ${formatCodexDisplayText(effectiveThreadId)}.`;
 }
 async function bindCodexCliNodeSession(deps, ctx, parsed) {
 	if (!parsed.threadId || !parsed.host || parsed.bindHere !== true) return "Usage: /codex resume <session-id> --host <node> --bind here";
@@ -972,9 +968,11 @@ async function bindCodexCliNodeSession(deps, ctx, parsed) {
 	if (!resolved.session) return `No Codex CLI session ${formatCodexDisplayText(parsed.threadId)} was found on ${formatCodexDisplayText(parsed.host)}.`;
 	const nodeId = resolved.node.nodeId;
 	if (!nodeId) return "Cannot bind Codex CLI session because the selected node did not include a node id.";
+	const scope = resolveCodexConversationControlScope(ctx);
 	const data = createCodexCliNodeConversationBindingData({
 		nodeId,
 		sessionId: parsed.threadId,
+		agentId: scope.agentId,
 		cwd: resolved.session?.cwd
 	});
 	const summary = `Codex CLI session ${formatCodexDisplayText(parsed.threadId)} on ${formatCodexDisplayText(nodeId)}`;
@@ -989,9 +987,10 @@ async function bindCodexCliNodeSession(deps, ctx, parsed) {
 }
 async function stopConversationTurn(deps, ctx, pluginConfig) {
 	const target = await resolveControlTarget(ctx);
-	if (!target) return "Cannot stop Codex because this command did not include an OpenClaw session file.";
+	if (!target) return "Cannot stop Codex because this command did not include a stable binding identity.";
 	return (await deps.stopCodexConversationTurn({
-		sessionFile: target.sessionFile,
+		identity: target.identity,
+		bindingStore: deps.bindingStore,
 		pluginConfig,
 		agentDir: target.agentDir,
 		config: ctx.config
@@ -999,11 +998,12 @@ async function stopConversationTurn(deps, ctx, pluginConfig) {
 }
 async function steerConversationTurn(deps, ctx, pluginConfig, message) {
 	const target = await resolveControlTarget(ctx);
-	if (!target) return "Cannot steer Codex because this command did not include an OpenClaw session file.";
+	if (!target) return "Cannot steer Codex because this command did not include a stable binding identity.";
 	return (await deps.steerCodexConversationTurn({
-		sessionFile: target.sessionFile,
-		pluginConfig,
+		identity: target.identity,
+		bindingStore: deps.bindingStore,
 		message,
+		pluginConfig,
 		agentDir: target.agentDir,
 		config: ctx.config
 	})).message;
@@ -1011,77 +1011,100 @@ async function steerConversationTurn(deps, ctx, pluginConfig, message) {
 async function setConversationModel(deps, ctx, pluginConfig, args) {
 	if (args.length > 1) return "Usage: /codex model <model>";
 	const target = await resolveControlTarget(ctx);
-	if (!target) return "Cannot set Codex model because this command did not include an OpenClaw session file.";
+	if (!target) return "Cannot set Codex model because this command did not include a stable binding identity.";
 	const [model = ""] = args;
 	const normalized = model.trim();
 	if (!normalized) {
-		const binding = await deps.readCodexAppServerBinding(target.sessionFile, {
-			agentDir: target.agentDir,
-			config: ctx.config
-		});
+		const binding = await deps.bindingStore.read(target.identity);
 		return binding?.model ? `Codex model: ${formatCodexDisplayText(binding.model)}` : "Usage: /codex model <model>";
 	}
 	return await deps.setCodexConversationModel({
-		sessionFile: target.sessionFile,
+		identity: target.identity,
+		bindingStore: deps.bindingStore,
 		pluginConfig,
 		model: normalized,
 		agentDir: target.agentDir,
 		config: ctx.config
 	});
 }
-async function setConversationFastMode(deps, ctx, pluginConfig, args) {
+async function setConversationFastMode(deps, ctx, args) {
 	if (args.length > 1) return "Usage: /codex fast [on|off|status]";
 	const target = await resolveControlTarget(ctx);
-	if (!target) return "Cannot set Codex fast mode because this command did not include an OpenClaw session file.";
+	if (!target) return "Cannot set Codex fast mode because this command did not include a stable binding identity.";
 	const value = args[0];
 	const parsed = parseCodexFastModeArg(value);
 	if (value && parsed == null && value.trim().toLowerCase() !== "status") return "Usage: /codex fast [on|off|status]";
 	return await deps.setCodexConversationFastMode({
-		sessionFile: target.sessionFile,
-		pluginConfig,
-		enabled: parsed,
-		agentDir: target.agentDir,
-		config: ctx.config
+		identity: target.identity,
+		bindingStore: deps.bindingStore,
+		enabled: parsed
 	});
 }
-async function setConversationPermissions(deps, ctx, pluginConfig, args) {
+async function setConversationPermissions(deps, ctx, args) {
 	if (args.length > 1) return "Usage: /codex permissions [default|yolo|status]";
 	const target = await resolveControlTarget(ctx);
-	if (!target) return "Cannot set Codex permissions because this command did not include an OpenClaw session file.";
+	if (!target) return "Cannot set Codex permissions because this command did not include a stable binding identity.";
 	const value = args[0];
 	const parsed = parseCodexPermissionsModeArg(value);
 	if (value && !parsed && value.trim().toLowerCase() !== "status") return "Usage: /codex permissions [default|yolo|status]";
 	return await deps.setCodexConversationPermissions({
-		sessionFile: target.sessionFile,
-		pluginConfig,
-		mode: parsed,
-		agentDir: target.agentDir,
-		config: ctx.config
+		identity: target.identity,
+		bindingStore: deps.bindingStore,
+		mode: parsed
 	});
 }
 async function resolveControlTarget(ctx) {
 	const data = readCodexConversationBindingData(await ctx.getCurrentConversationBinding());
 	const scope = resolveCodexConversationControlScope(ctx);
 	if (data?.kind === "codex-app-server-session") return {
-		sessionFile: data.sessionFile,
-		agentDir: data.agentDir ?? scope.agentDir
+		identity: conversationBindingIdentity(data.bindingId),
+		agentId: data.agentId ?? scope.agentId,
+		agentDir: data.agentDir ?? scope.agentDir,
+		requestedAuthProfileId: data.start?.authProfileId
 	};
-	return ctx.sessionFile ? {
-		sessionFile: ctx.sessionFile,
+	return ctx.sessionId ? {
+		identity: sessionBindingIdentity({
+			sessionId: ctx.sessionId,
+			sessionKey: ctx.sessionKey,
+			agentId: scope.agentId,
+			config: ctx.config
+		}),
+		agentId: scope.agentId,
 		agentDir: scope.agentDir
 	} : void 0;
 }
-async function resolveControlSessionFile(ctx) {
-	return (await resolveControlTarget(ctx))?.sessionFile;
+async function resolveCommandAppServerScope(deps, ctx) {
+	const target = await resolveControlTarget(ctx);
+	const fallback = resolveCodexConversationControlScope(ctx);
+	const agentDir = target?.agentDir ?? fallback.agentDir;
+	const authProfileId = resolveCodexAppServerAuthProfileIdForAgent({
+		authProfileId: (target ? await deps.bindingStore.read(target.identity) : void 0)?.authProfileId ?? target?.requestedAuthProfileId,
+		agentDir,
+		config: ctx.config
+	});
+	return {
+		agentId: target?.agentId ?? fallback.agentId,
+		agentDir,
+		...authProfileId ? { authProfileId } : {},
+		...ctx.sessionKey ? { sessionKey: ctx.sessionKey } : {},
+		...ctx.sessionId ? { sessionId: ctx.sessionId } : {}
+	};
+}
+function conversationBindingIdentity(bindingId) {
+	return {
+		kind: "conversation",
+		bindingId
+	};
 }
 function resolveCodexConversationControlScope(ctx) {
 	const { sessionAgentId } = resolveSessionAgentIds({
 		sessionKey: ctx.sessionKey,
+		agentId: ctx.agentId,
 		config: ctx.config
 	});
 	return {
-		agentDir: resolveAgentDir(ctx.config, sessionAgentId),
-		sessionAgentId
+		agentId: sessionAgentId,
+		agentDir: resolveAgentDir(ctx.config, sessionAgentId)
 	};
 }
 async function handleCodexDiagnosticsFeedback(deps, ctx, pluginConfig, args, commandPrefix) {
@@ -1095,7 +1118,7 @@ async function handleCodexDiagnosticsFeedback(deps, ctx, pluginConfig, args, com
 	return await requestCodexDiagnosticsFeedbackApproval(deps, ctx, parsed.note, commandPrefix);
 }
 async function requestCodexDiagnosticsFeedbackApproval(deps, ctx, note, commandPrefix) {
-	if (!await hasAnyCodexDiagnosticsSessionFile(ctx)) return { text: "Cannot send Codex diagnostics because this command did not include an OpenClaw session file." };
+	if (!await hasAnyCodexDiagnosticsIdentity(ctx)) return { text: "Cannot send Codex diagnostics because this command did not include a stable session identity." };
 	const targets = await resolveCodexDiagnosticsTargets(deps, ctx);
 	if (targets.length === 0) return { text: ["No Codex thread is attached to this OpenClaw session yet.", "Use /codex threads to find a thread, then /codex resume <thread-id> before sending diagnostics."].join("\n") };
 	const now = Date.now();
@@ -1151,7 +1174,7 @@ async function requestCodexDiagnosticsFeedbackApproval(deps, ctx, note, commandP
 	};
 }
 async function previewCodexDiagnosticsFeedbackApproval(deps, ctx, note) {
-	if (!await hasAnyCodexDiagnosticsSessionFile(ctx)) return "Cannot send Codex diagnostics because this command did not include an OpenClaw session file.";
+	if (!await hasAnyCodexDiagnosticsIdentity(ctx)) return "Cannot send Codex diagnostics because this command did not include a stable session identity.";
 	const targets = await resolveCodexDiagnosticsTargets(deps, ctx);
 	if (targets.length === 0) return ["No Codex thread is attached to this OpenClaw session yet.", "Use /codex threads to find a thread, then /codex resume <thread-id> before sending diagnostics."].join("\n");
 	const cooldownMessage = readCodexDiagnosticsTargetsCooldownMessage(targets, ctx, Date.now(), { includeThreadId: false });
@@ -1175,10 +1198,10 @@ async function confirmCodexDiagnosticsFeedback(deps, ctx, pluginConfig, token) {
 	const scopeMismatch = readCodexDiagnosticsScopeMismatch(pending, ctx);
 	if (scopeMismatch) return scopeMismatch.confirmMessage;
 	deletePendingCodexDiagnosticsConfirmation(token);
-	if (!pending.privateRouted && !await hasAnyCodexDiagnosticsSessionFile(ctx)) return "Cannot send Codex diagnostics because this command did not include an OpenClaw session file.";
-	const currentTargets = pending.privateRouted ? await resolvePendingCodexDiagnosticsTargets(deps, pending.targets) : await resolveCodexDiagnosticsTargets(deps, ctx);
+	if (!pending.privateRouted && !await hasAnyCodexDiagnosticsIdentity(ctx)) return "Cannot send Codex diagnostics because this command did not include a stable session identity.";
+	const currentTargets = pending.privateRouted ? await resolvePendingCodexDiagnosticsTargets(deps, pending.targets, ctx.config) : await resolveCodexDiagnosticsTargets(deps, ctx);
 	if (!codexDiagnosticsTargetsMatch(pending.targets, currentTargets)) return "The Codex diagnostics sessions changed before confirmation. Run /diagnostics again for the current threads.";
-	return await sendCodexDiagnosticsFeedbackForTargets(deps, ctx, pluginConfig, pending.note ?? "", pending.targets);
+	return await sendCodexDiagnosticsFeedbackForTargets(deps, ctx, pluginConfig, pending.note ?? "", currentTargets, { cooldownScope: pending.scopeKey });
 }
 function cancelCodexDiagnosticsFeedback(ctx, token) {
 	const pending = readPendingCodexDiagnosticsConfirmation(token, Date.now());
@@ -1196,15 +1219,15 @@ function cancelCodexDiagnosticsFeedback(ctx, token) {
 	].join("\n");
 }
 async function sendCodexDiagnosticsFeedbackForContext(deps, ctx, pluginConfig, note) {
-	if (!await hasAnyCodexDiagnosticsSessionFile(ctx)) return "Cannot send Codex diagnostics because this command did not include an OpenClaw session file.";
+	if (!await hasAnyCodexDiagnosticsIdentity(ctx)) return "Cannot send Codex diagnostics because this command did not include a stable session identity.";
 	const targets = await resolveCodexDiagnosticsTargets(deps, ctx);
 	if (targets.length === 0) return ["No Codex thread is attached to this OpenClaw session yet.", "Use /codex threads to find a thread, then /codex resume <thread-id> before sending diagnostics."].join("\n");
 	return await sendCodexDiagnosticsFeedbackForTargets(deps, ctx, pluginConfig, note, targets);
 }
-async function sendCodexDiagnosticsFeedbackForTargets(deps, ctx, pluginConfig, note, targets) {
+async function sendCodexDiagnosticsFeedbackForTargets(deps, ctx, pluginConfig, note, targets, options = {}) {
 	if (targets.length === 0) return ["No Codex thread is attached to this OpenClaw session yet.", "Use /codex threads to find a thread, then /codex resume <thread-id> before sending diagnostics."].join("\n");
 	const now = Date.now();
-	const cooldownMessage = readCodexDiagnosticsTargetsCooldownMessage(targets, ctx, now);
+	const cooldownMessage = readCodexDiagnosticsTargetsCooldownMessage(targets, ctx, now, { cooldownScope: options.cooldownScope });
 	if (cooldownMessage) return cooldownMessage;
 	const reason = normalizeDiagnosticsReason(note);
 	const sent = [];
@@ -1216,6 +1239,12 @@ async function sendCodexDiagnosticsFeedbackForTargets(deps, ctx, pluginConfig, n
 			includeLogs: true,
 			tags: buildDiagnosticsTags(ctx),
 			...reason ? { reason } : {}
+		}, {
+			config: ctx.config,
+			agentDir: target.agentDir,
+			...target.authProfileId ? { authProfileId: target.authProfileId } : {},
+			...target.sessionId ? { sessionId: target.sessionId } : {},
+			...target.sessionKey ? { sessionKey: target.sessionKey } : {}
 		});
 		if (!response.ok) {
 			failed.push({
@@ -1229,20 +1258,20 @@ async function sendCodexDiagnosticsFeedbackForTargets(deps, ctx, pluginConfig, n
 			...target,
 			threadId: responseThreadId ?? target.threadId
 		});
-		recordCodexDiagnosticsUpload(target.threadId, ctx, now);
+		recordCodexDiagnosticsUpload(target.threadId, ctx, now, options.cooldownScope);
 	}
 	return formatCodexDiagnosticsUploadResult(sent, failed);
 }
-async function hasAnyCodexDiagnosticsSessionFile(ctx) {
-	if (await resolveControlSessionFile(ctx)) return true;
-	return (ctx.diagnosticsSessions ?? []).some((session) => Boolean(session.sessionFile));
+async function hasAnyCodexDiagnosticsIdentity(ctx) {
+	if (await resolveControlTarget(ctx)) return true;
+	return (ctx.diagnosticsSessions ?? []).some((session) => Boolean(session.sessionId));
 }
 async function resolveCodexDiagnosticsTargets(deps, ctx) {
-	const activeSessionFile = await resolveControlSessionFile(ctx);
+	const activeTarget = await resolveControlTarget(ctx);
 	const candidates = [];
-	if (activeSessionFile) candidates.push({
-		threadId: "",
-		sessionFile: activeSessionFile,
+	if (activeTarget) candidates.push({
+		identity: activeTarget.identity,
+		agentDir: activeTarget.agentDir,
 		sessionKey: ctx.sessionKey,
 		sessionId: ctx.sessionId,
 		channel: ctx.channel,
@@ -1252,10 +1281,17 @@ async function resolveCodexDiagnosticsTargets(deps, ctx) {
 		threadParentId: ctx.threadParentId
 	});
 	for (const session of ctx.diagnosticsSessions ?? []) {
-		if (!session.sessionFile) continue;
+		if (!session.sessionId) continue;
+		const inventoryAgentId = session.sessionKey ? parseAgentSessionKey(session.sessionKey)?.agentId : void 0;
+		const identity = sessionBindingIdentity({
+			sessionId: session.sessionId,
+			sessionKey: session.sessionKey,
+			agentId: inventoryAgentId ?? ctx.agentId,
+			config: ctx.config
+		});
 		candidates.push({
-			threadId: "",
-			sessionFile: session.sessionFile,
+			identity,
+			agentDir: resolveAgentDir(ctx.config, identity.agentId),
 			sessionKey: session.sessionKey,
 			sessionId: session.sessionId,
 			channel: session.channel,
@@ -1265,38 +1301,50 @@ async function resolveCodexDiagnosticsTargets(deps, ctx) {
 			threadParentId: session.threadParentId
 		});
 	}
-	const seenSessionFiles = /* @__PURE__ */ new Set();
+	const seenBindingKeys = /* @__PURE__ */ new Set();
 	const seenThreadIds = /* @__PURE__ */ new Set();
 	const targets = [];
 	for (const candidate of candidates) {
-		if (seenSessionFiles.has(candidate.sessionFile)) continue;
-		seenSessionFiles.add(candidate.sessionFile);
-		const binding = await deps.readCodexAppServerBinding(candidate.sessionFile);
+		const key = bindingStoreKey(candidate.identity);
+		if (seenBindingKeys.has(key)) continue;
+		seenBindingKeys.add(key);
+		const binding = await deps.bindingStore.read(candidate.identity);
 		if (!binding?.threadId || seenThreadIds.has(binding.threadId)) continue;
 		seenThreadIds.add(binding.threadId);
-		targets.push({
-			...candidate,
-			threadId: binding.threadId
-		});
+		targets.push(resolveCodexDiagnosticsTarget(candidate, binding, ctx.config));
 	}
 	return targets;
 }
-async function resolvePendingCodexDiagnosticsTargets(deps, targets) {
+async function resolvePendingCodexDiagnosticsTargets(deps, targets, config) {
 	const resolved = [];
 	for (const target of targets) {
-		const binding = await deps.readCodexAppServerBinding(target.sessionFile);
+		const binding = await deps.bindingStore.read(target.identity);
 		if (!binding?.threadId) continue;
-		resolved.push({
-			...target,
-			threadId: binding.threadId
-		});
+		resolved.push(resolveCodexDiagnosticsTarget(target, binding, config));
 	}
 	return resolved;
 }
+function resolveCodexDiagnosticsTarget(target, binding, config) {
+	const authProfileId = resolveCodexAppServerAuthProfileIdForAgent({
+		authProfileId: binding.authProfileId,
+		agentDir: target.agentDir,
+		config
+	});
+	return {
+		...target,
+		threadId: binding.threadId,
+		authProfileId
+	};
+}
 function codexDiagnosticsTargetsMatch(expected, actual) {
-	const expectedThreadIds = expected.map((target) => target.threadId).toSorted();
-	const actualThreadIds = actual.map((target) => target.threadId).toSorted();
-	return expectedThreadIds.length === actualThreadIds.length && expectedThreadIds.every((threadId, index) => threadId === actualThreadIds[index]);
+	const fingerprint = (target) => JSON.stringify([
+		bindingStoreKey(target.identity),
+		target.threadId,
+		target.authProfileId ?? null
+	]);
+	const expectedTargets = expected.map(fingerprint).toSorted();
+	const actualTargets = actual.map(fingerprint).toSorted();
+	return expectedTargets.length === actualTargets.length && expectedTargets.every((target, index) => target === actualTargets[index]);
 }
 function formatCodexDiagnosticsUploadResult(sent, failed) {
 	const lines = [];
@@ -1498,7 +1546,7 @@ function readCodexDiagnosticsTargetsCooldownMessage(targets, ctx, now, options =
 			return `Codex diagnostics were already sent for thread ${formatCodexThreadIdForDisplay(target.threadId)} recently. Try again in ${Math.ceil(cooldownMs / 1e3)}s.`;
 		}
 	}
-	const scopeCooldownMs = readCodexDiagnosticsScopeCooldownMs(readCodexDiagnosticsCooldownScope(ctx), now);
+	const scopeCooldownMs = readCodexDiagnosticsScopeCooldownMs(options.cooldownScope ?? readCodexDiagnosticsCooldownScope(ctx), now);
 	if (scopeCooldownMs > 0) return `Codex diagnostics were already sent for this account or channel recently. Try again in ${Math.ceil(scopeCooldownMs / 1e3)}s.`;
 }
 function readCodexDiagnosticsScopeCooldownMs(scope, now) {
@@ -1508,9 +1556,9 @@ function readCodexDiagnosticsScopeCooldownMs(scope, now) {
 	if (remainingMs === 0) lastCodexDiagnosticsUploadByScope.delete(scope);
 	return remainingMs;
 }
-function recordCodexDiagnosticsUpload(threadId, ctx, now) {
+function recordCodexDiagnosticsUpload(threadId, ctx, now, cooldownScope) {
 	pruneCodexDiagnosticsCooldowns(now);
-	recordBoundedCodexDiagnosticsCooldown(lastCodexDiagnosticsUploadByScope, readCodexDiagnosticsCooldownScope(ctx), CODEX_DIAGNOSTICS_COOLDOWN_MAX_SCOPES, now);
+	recordBoundedCodexDiagnosticsCooldown(lastCodexDiagnosticsUploadByScope, cooldownScope ?? readCodexDiagnosticsCooldownScope(ctx), CODEX_DIAGNOSTICS_COOLDOWN_MAX_SCOPES, now);
 	recordBoundedCodexDiagnosticsCooldown(lastCodexDiagnosticsUploadByThread, threadId, CODEX_DIAGNOSTICS_COOLDOWN_MAX_THREADS, now);
 }
 function recordBoundedCodexDiagnosticsCooldown(map, key, maxSize, now) {
@@ -1558,24 +1606,17 @@ function normalizeCodexDiagnosticsScopeField(value) {
 	if (normalized.length <= CODEX_DIAGNOSTICS_SCOPE_FIELD_MAX_CHARS) return normalized;
 	return `sha256:${crypto.createHash("sha256").update(normalized).digest("hex")}`;
 }
-async function startThreadAction(deps, ctx, pluginConfig, method, label, args) {
+async function startThreadAction(deps, ctx, pluginConfig, kind, args) {
+	const label = kind === "compact" ? "compaction" : "review";
 	if (args.length > 0) return `Usage: /codex ${label === "compaction" ? "compact" : label}`;
 	const target = await resolveControlTarget(ctx);
-	if (!target) return `Cannot start Codex ${label} because this command did not include an OpenClaw session file.`;
-	const binding = await deps.readCodexAppServerBinding(target.sessionFile, {
-		agentDir: target.agentDir,
-		config: ctx.config
-	});
+	if (!target) return `Cannot start Codex ${label} because this command did not include a stable binding identity.`;
+	const binding = await deps.bindingStore.read(target.identity);
 	if (!binding?.threadId) return `No Codex thread is attached to this OpenClaw session yet.`;
-	if (method === CODEX_CONTROL_METHODS.review) await deps.codexControlRequest(pluginConfig, method, {
+	await deps.codexControlRequest(pluginConfig, kind === "compact" ? CODEX_CONTROL_METHODS.compact : CODEX_CONTROL_METHODS.review, kind === "review" ? {
 		threadId: binding.threadId,
 		target: { type: "uncommittedChanges" }
-	}, {
-		agentDir: target.agentDir,
-		authProfileId: binding.authProfileId,
-		config: ctx.config
-	});
-	else await deps.codexControlRequest(pluginConfig, method, { threadId: binding.threadId }, {
+	} : { threadId: binding.threadId }, {
 		agentDir: target.agentDir,
 		authProfileId: binding.authProfileId,
 		config: ctx.config