@openclaw/codex 2026.9.3 → 2026.9.5

package/dist/{command-handlers-BfIsJEuA.js → .setup/command-handlers-BtAJEW1X.mjs}

@@ -1,43 +1,47 @@
-import { m as CODEX_PLUGINS_MARKETPLACE_NAME, n as isCodexFastServiceTier } from "./config-utils-C57JiJrU.js";
-import { l as sessionBindingIdentity, n as assertCodexBindingMayBeReplaced, r as bindingStoreKey } from "./session-binding-record-CaZjYwNS.js";
-import { o as isJsonObject } from "./protocol-CAAcVIKF.js";
-import { _ as assertCodexThreadAcceptsDirectInput, y as assertCodexThreadResumeResponse } from "./client-BEKu4yDx.js";
-import { s as resolveCodexAppServerFallbackApiKeyCacheKey } from "./auth-cache-key-Kq6oerr6.js";
-import { r as withCodexConversationThreadActivity, t as isIncognitoSessionKey } from "./incognito-session-uhrBF6wJ.js";
-import { a as CODEX_NATIVE_EXECUTION_AUTH_ERROR, i as CODEX_HOST_INSPECTION_AUTH_ERROR, n as parseCodexPluginMarketplaceId, o as canMutateCodexHost, r as CODEX_FULL_PERMISSIONS_AUTH_ERROR, s as hasCodexAdminScope, t as discoverCodexMarketplacePlugins } from "./plugin-marketplace-discovery-3akBizzF.js";
-import { s as summarizeCodexAccountUsage } from "./rate-limits-Bqnx1N4z.js";
-import { a as formatCodexDisplayText, c as formatComputerUseStatus, d as formatSkills, f as formatThreads, i as formatAccount, l as formatList, n as buildHelp, o as formatCodexStatus, r as escapeCodexChatText, s as formatCodexTextForDisplay, t as CODEX_RESUME_SAFE_THREAD_ID_PATTERN, u as formatModels } from "./command-formatters-DeTfrapr.js";
-import { i as readCodexConversationBindingData, n as createCodexCliNodeConversationBindingData, o as resolveCodexDefaultWorkspaceDir, r as createCodexConversationBindingData } from "./conversation-binding-data-BiodpIzq.js";
-import { t as CODEX_CONTROL_METHODS } from "./capabilities-BeqLPbtM.js";
-import { i as formatCodexCliSessions } from "./node-cli-sessions-rj0ysJwM.js";
-import { r as buildCodexPluginAppCacheKey, s as defaultCodexAppInventoryCache } from "./plugin-app-cache-key-CdSQzWyX.js";
-import "./config-JDfTI4VI.js";
-import { n as resolveCodexAppServerRuntimeOptions } from "./config-runtime-BWf6JLWG.js";
-import { i as resolveCodexBindingAppServerConnection } from "./binding-connection-QqgcPCgk.js";
-import { i as resolveCodexAppServerAuthProfileIdForAgent, n as normalizeCodexAppServerBindingModelProvider } from "./auth-profile-CwzO4_RG.js";
-import { L as hasCodexAppServerLiveThread, P as consumeCodexAppServerLiveThread, X as resolveCodexAppServerAuthAccountCacheKey, c as getLeasedSharedCodexAppServerClient, h as releaseLeasedSharedCodexAppServerClient } from "./shared-client-CVhez2Uo.js";
-import { a as closeCodexStartupClientBestEffort } from "./attempt-client-cleanup-D6cR54TV.js";
-import { t as listAllCodexAppServerModels } from "./models-P9k2qAof.js";
-import { r as isOpenAiCuratedMarketplaceName } from "./plugin-inventory-CoRCzWW4.js";
-import { n as refreshCodexPluginRuntimeState } from "./plugin-activation-BQK-f5sV.js";
-import { n as createCodexSessionGenerationSupersededError, o as resolveCodexSessionBinding } from "./session-binding-CKSepwIC.js";
-import { r as assertCodexSupervisionThreadLineage } from "./thread-policy-D8kI7yAO.js";
-import { a as rollbackCodexAppServerBindingSubscription, i as retireCodexConversationThreadBinding, n as releaseCodexAppServerBindingSubscription, r as retainCodexAppServerBindingSubscription, s as withExclusiveCodexAppServerThread, t as isSameCodexAppServerThreadOwner } from "./thread-ownership-D6oASVRu.js";
-import { n as resolveCodexNativeSandboxBlock, t as resolveCodexNativeExecutionBlock } from "./sandbox-guard-BcT66fWy.js";
-import { i as readCodexComputerUseStatus, r as installCodexComputerUse, t as defaultCodexPluginMetadataCache } from "./plugin-metadata-cache-DgNfRAGA.js";
-import { a as safeCodexControlRequest, i as requestOptions, r as readCodexStatusProbes, t as codexControlRequest } from "./command-rpc-BMqRQOFX.js";
-import { a as setCodexConversationFastMode, c as steerCodexConversationTurn, i as readCodexConversationActiveTurn, l as stopCodexConversationTurn, n as parseCodexFastModeArg, o as setCodexConversationModel, r as parseCodexPermissionsModeArg, s as setCodexConversationPermissions, t as formatPermissionsMode } from "./conversation-control-CUCrSIQI.js";
+import { n as isCodexFastServiceTier } from "./config-utils-DujwEnhg.mjs";
+import { c as CODEX_PLUGINS_MARKETPLACE_NAME, i as pluginReadParams, r as isOpenAiCuratedMarketplaceName, t as findCodexMarketplacePluginSummary } from "./plugin-inventory-DUle8DLz.mjs";
+import { n as assertCodexBindingMayBeReplaced, p as sessionBindingIdentity, r as bindingStoreKey } from "./session-binding-record-TH3xA0zj.mjs";
+import { m as isJsonObject } from "./config-security-BRQ2mgW9.mjs";
+import { _ as assertCodexThreadAcceptsDirectInput, s as isCodexAppServerIndeterminateRequestCancellationError, u as isCodexAppServerPrewriteRequestCancellationError, y as assertCodexThreadResumeResponse } from "./client-vXs2929Q.mjs";
+import { c as resolveCodexAppServerPreparedApiKeyCacheKey, s as resolveCodexAppServerFallbackApiKeyCacheKey } from "./auth-cache-key-QirmgiCo.mjs";
+import { r as withCodexConversationThreadActivity, t as isIncognitoSessionKey } from "./incognito-session-uhrBF6wJ.mjs";
+import { a as CODEX_HOST_INSPECTION_AUTH_ERROR, c as hasCodexAdminScope, i as CODEX_FULL_PERMISSIONS_AUTH_ERROR, n as filterCodexMarketplacePlugins, o as CODEX_NATIVE_EXECUTION_AUTH_ERROR, r as parseCodexPluginMarketplaceId, s as canMutateCodexHost, t as discoverCodexMarketplacePlugins } from "./plugin-marketplace-discovery-P-Vndfqq.mjs";
+import { s as summarizeCodexAccountUsage } from "./rate-limits-DOEGYRNs.mjs";
+import { a as formatCodexAccountLine, c as formatCodexTextForDisplay, d as formatModels, f as formatSkills, i as formatAccount, l as formatComputerUseStatus, n as buildHelp, o as formatCodexDisplayText, p as formatThreads, r as escapeCodexChatText, s as formatCodexStatus, t as CODEX_RESUME_SAFE_THREAD_ID_PATTERN, u as formatList } from "./command-formatters-CGEkdawF.mjs";
+import { i as readCodexConversationBindingData, n as createCodexCliNodeConversationBindingData, o as resolveCodexDefaultWorkspaceDir, r as createCodexConversationBindingData } from "./conversation-binding-data-CrcyZk6O.mjs";
+import { i as CodexAppServerRpcError } from "./timeout-DZF05XrR.mjs";
+import { t as CODEX_CONTROL_METHODS } from "./capabilities-_vXcZGSx.mjs";
+import { i as formatCodexCliSessions } from "./node-cli-sessions-Cl8b2ZF3.mjs";
+import { a as defaultCodexAppInventoryCache, r as buildCodexPluginAppCacheKey } from "./plugin-app-cache-key-BOxKP7db.mjs";
+import { i as resolveCodexBindingAppServerConnection } from "./binding-connection-Bm38niE8.mjs";
+import { o as withCodexAppServerJsonClient } from "./request-BioXJLYa.mjs";
+import "./config-CedDWjM-.mjs";
+import { n as resolveCodexAppServerRuntimeOptions } from "./config-runtime-CeAhl_h4.mjs";
+import { a as resolveCodexAppServerAuthProfileStore, i as resolveCodexAppServerAuthProfileIdForAgent, n as normalizeCodexAppServerBindingModelProvider } from "./auth-profile-WqZtZfXN.mjs";
+import { n as fingerprintCodexAppServerAuthBinding } from "./auth-binding-DhLWa_7K.mjs";
+import { I as hasCodexAppServerLiveThread, N as consumeCodexAppServerLiveThread, X as resolveCodexAppServerAuthAccountCacheKey, c as getLeasedSharedCodexAppServerClient, h as releaseLeasedSharedCodexAppServerClient } from "./shared-client-BpTtuLQ5.mjs";
+import { a as closeCodexStartupClientBestEffort } from "./attempt-client-cleanup-BpYKdTA0.mjs";
+import { t as listAllCodexAppServerModels } from "./models-BDFgm_G-.mjs";
+import { n as refreshCodexAppRuntimeState, r as refreshCodexPluginRuntimeState } from "./plugin-activation-r8nq5Jzp.mjs";
+import { n as createCodexSessionGenerationSupersededError, o as resolveCodexSessionBinding } from "./session-binding-_0W_fHRr.mjs";
+import { r as assertCodexSupervisionThreadLineage } from "./thread-policy-Cjs4B8xf.mjs";
+import { a as rollbackCodexAppServerBindingSubscription, i as retireCodexConversationThreadBinding, n as releaseCodexAppServerBindingSubscription, r as retainCodexAppServerBindingSubscription, s as withExclusiveCodexAppServerThread, t as isSameCodexAppServerThreadOwner } from "./thread-ownership-skomxnIt.mjs";
+import { n as resolveCodexNativeSandboxBlock, t as resolveCodexNativeExecutionBlock } from "./sandbox-guard-BBP-RbTf.mjs";
+import { i as readCodexComputerUseStatus, r as installCodexComputerUse, t as defaultCodexPluginMetadataCache } from "./plugin-metadata-cache-DsS5buNa.mjs";
+import { a as requestOptions, i as readCodexStatusProbes, o as safeCodexControlRequest, r as prepareCodexControlSessionAuth, t as codexControlRequest } from "./command-rpc-DHFpn4le.mjs";
+import { a as setCodexConversationFastMode, c as steerCodexConversationTurn, i as readCodexConversationActiveTurn, l as stopCodexConversationTurn, n as parseCodexFastModeArg, o as setCodexConversationModel, r as parseCodexPermissionsModeArg, s as setCodexConversationPermissions, t as formatPermissionsMode } from "./conversation-control-DN53ns41.mjs";
 import { normalizeOptionalString, normalizeUniqueStringEntries } from "openclaw/plugin-sdk/string-coerce-runtime";
 import crypto from "node:crypto";
+import { isDeepStrictEqual } from "node:util";
 import { resolveSessionAgentIdsStrict } from "openclaw/plugin-sdk/agent-scope-runtime";
 import { parseStrictPositiveInteger } from "openclaw/plugin-sdk/number-runtime";
 import { expectDefined } from "openclaw/plugin-sdk/expect-runtime";
 import { truncateUtf16Safe } from "openclaw/plugin-sdk/text-utility-runtime";
-import { isDeepStrictEqual } from "node:util";
-import { ensureAuthProfileStore, resolveAgentDir as resolveAgentDir$1, resolveAuthProfileEligibility, resolveProfileUnusableUntilForDisplay } from "openclaw/plugin-sdk/agent-runtime";
-import { parseAgentSessionKey } from "openclaw/plugin-sdk/routing";
+import { ensureAuthProfileStore, resolveAgentDir as resolveAgentDir$1, resolveAgentWorkspaceDir, resolveAuthProfileEligibility, resolveProfileUnusableUntilForDisplay } from "openclaw/plugin-sdk/agent-runtime";
 import { getSessionEntry, resolveStorePath } from "openclaw/plugin-sdk/session-store-runtime";
 import { findNormalizedProviderValue, resolveAuthProfileOrder } from "openclaw/plugin-sdk/provider-auth";
+import { parseAgentSessionKey } from "openclaw/plugin-sdk/routing";
+import { renderMessagePresentationFallbackText } from "openclaw/plugin-sdk/interactive-runtime";
 import { MODEL_SELECTION_LOCKED_MESSAGE, isModelSelectionLocked, resolvePersistedSessionRuntimeId } from "openclaw/plugin-sdk/model-session-runtime";
 //#region extensions/codex/src/command-account.ts
 const OPENAI_PROVIDER_ID = "openai";
@@ -336,6 +340,453 @@ function formatRelativeReset(untilMs, nowMs) {
 	const days = Math.ceil(durationMs / dayMs);
 	return `in ${days} ${days === 1 ? "day" : "days"}`;
 }
+function buildCodexPluginAppLinks(apps, options = {}) {
+	const blocks = apps.slice(0, 5).map((app) => {
+		const name = formatCodexDisplayText((app.name.trim() || app.id).slice(0, 80));
+		const url = safeCodexAppLink(app.installUrl);
+		return url ? {
+			type: "buttons",
+			buttons: [{
+				label: `Open ${name} in ChatGPT`,
+				action: {
+					type: "url",
+					url
+				}
+			}]
+		} : {
+			type: "text",
+			text: `${name}: ChatGPT setup/manage link unavailable. In Codex CLI, run /apps and select this app to continue.`
+		};
+	});
+	const remaining = apps.length - 5;
+	if (remaining > 0) blocks.push({
+		type: "text",
+		text: `${remaining} more apps are not shown. ${options.continuationCommand ? "Choose More apps to continue." : "In Codex CLI, run /apps to review the remaining apps."}`
+	});
+	if (options.continuationCommand) blocks.push({
+		type: "buttons",
+		buttons: [{
+			label: "More apps",
+			action: {
+				type: "command",
+				command: options.continuationCommand
+			}
+		}]
+	});
+	if (apps.length > 0) blocks.push({
+		type: "context",
+		text: "Use the same ChatGPT account and workspace as Codex in your browser. Opening an app page does not confirm that it is connected or callable in this conversation. If the app is not shown, in Codex CLI run /apps and select it."
+	});
+	return blocks;
+}
+function safeCodexAppLink(value) {
+	if (!value || value.length > 2048 || /[\s\p{Cc}\p{Cf}<>]/u.test(value)) return;
+	try {
+		const url = new URL(value);
+		const host = url.hostname;
+		const hosted = host === "chatgpt.com" || host === "chatgpt-staging.com" || host.endsWith(".chatgpt.com") || host.endsWith(".chatgpt-staging.com");
+		return url.protocol === "https:" && !url.username && !url.password && hosted ? value : void 0;
+	} catch {
+		return;
+	}
+}
+//#endregion
+//#region extensions/codex/src/command-plugin-config.ts
+/** Merge historical curated wire aliases only when they identify the same install source. */
+function resolveCuratedMarketplaceAliases(plugins, requestedMarketplaceName) {
+	if (!isOpenAiCuratedMarketplaceName(requestedMarketplaceName)) return;
+	const sourceIdentities = new Set(plugins.map((plugin) => plugin.marketplacePath ? `local:${plugin.marketplacePath}` : plugin.remotePluginId ? `remote:${plugin.remotePluginId}` : void 0));
+	if (sourceIdentities.size !== 1 || sourceIdentities.has(void 0)) return;
+	const selected = plugins.find((plugin) => plugin.marketplaceName === requestedMarketplaceName) ?? plugins[0];
+	if (!selected) return;
+	return {
+		...selected,
+		installed: plugins.some((plugin) => plugin.installed),
+		enabled: plugins.some((plugin) => plugin.installed && plugin.enabled),
+		available: plugins.every((plugin) => plugin.available),
+		...selected.remotePluginId ? { mustShowInstallationInterstitial: plugins.some((plugin) => plugin.mustShowInstallationInterstitial === true) ? true : plugins.every((plugin) => plugin.mustShowInstallationInterstitial === false) ? false : null } : {},
+		...plugins.some((plugin) => plugin.installPolicy === "NOT_AVAILABLE") ? { installPolicy: "NOT_AVAILABLE" } : {}
+	};
+}
+function persistedPluginName(plugin) {
+	return !plugin.marketplacePath && plugin.summaryId.endsWith(`@${plugin.marketplaceName}`) ? plugin.summaryId : plugin.pluginName;
+}
+function resolveConfiguredPluginKey(plugins, target) {
+	const requested = parseCodexPluginMarketplaceId(target);
+	const direct = plugins[target];
+	if (!requested) {
+		if (!direct) return { status: "missing" };
+		const qualifiedName = direct.pluginName ? parseCodexPluginMarketplaceId(direct.pluginName) : void 0;
+		if (qualifiedName && direct.marketplaceName && !marketplaceNamesRepresentSameCatalog(qualifiedName.marketplaceName, direct.marketplaceName)) return { status: "mismatched" };
+		const identity = resolveConfiguredPluginIdentity(direct);
+		if (!identity) return {
+			status: "matched",
+			configKey: target
+		};
+		const marketplaceName = isOpenAiCuratedMarketplaceName(identity.marketplaceName) ? CODEX_PLUGINS_MARKETPLACE_NAME : identity.marketplaceName;
+		const canonicalId = `${identity.pluginName}@${marketplaceName}`;
+		const canonical = plugins[canonicalId];
+		if (canonical && !matchesConfiguredPluginIdentity(canonical, identity, canonicalId)) return { status: "mismatched" };
+		return Object.values(plugins).filter((entry) => matchesConfiguredPluginIdentity(entry, identity, canonicalId)).length > 1 ? { status: "ambiguous" } : {
+			status: "matched",
+			configKey: target
+		};
+	}
+	if (direct && !matchesConfiguredPluginIdentity(direct, requested, target)) return { status: "mismatched" };
+	const matching = Object.entries(plugins).filter(([, entry]) => matchesConfiguredPluginIdentity(entry, requested, target));
+	if (matching.length > 1) return { status: "ambiguous" };
+	const configKey = matching[0]?.[0];
+	return configKey ? {
+		status: "matched",
+		configKey
+	} : { status: "missing" };
+}
+function resolveInstalledPluginKey(plugins, plugin) {
+	const discovered = resolveConfiguredPluginKey(plugins, plugin.id);
+	if (discovered.status === "ambiguous" || discovered.status === "mismatched") return discovered;
+	if (!isOpenAiCuratedMarketplaceName(plugin.marketplaceName)) return discovered;
+	const canonical = resolveConfiguredPluginKey(plugins, `${plugin.pluginName}@${CODEX_PLUGINS_MARKETPLACE_NAME}`);
+	if (canonical.status === "ambiguous" || canonical.status === "mismatched") return canonical;
+	if (discovered.status === "matched" && canonical.status === "matched" && discovered.configKey !== canonical.configKey) return { status: "ambiguous" };
+	return canonical.status === "matched" ? canonical : discovered;
+}
+function resolveConfiguredPluginIdentity(entry) {
+	if (!entry.pluginName || !entry.marketplaceName) return;
+	const qualified = parseCodexPluginMarketplaceId(entry.pluginName);
+	if (qualified) return marketplaceNamesRepresentSameCatalog(qualified.marketplaceName, entry.marketplaceName) ? {
+		pluginName: qualified.pluginName,
+		marketplaceName: entry.marketplaceName
+	} : void 0;
+	return parseCodexPluginMarketplaceId(`${entry.pluginName}@${entry.marketplaceName}`);
+}
+function matchesConfiguredPluginIdentity(entry, requested, target) {
+	const configuredName = entry.pluginName ? parseCodexPluginMarketplaceId(entry.pluginName) : void 0;
+	return typeof entry.marketplaceName === "string" && marketplaceNamesRepresentSameCatalog(entry.marketplaceName, requested.marketplaceName) && (entry.pluginName === requested.pluginName || entry.pluginName === target || configuredName?.pluginName === requested.pluginName && marketplaceNamesRepresentSameCatalog(configuredName.marketplaceName, requested.marketplaceName));
+}
+function marketplaceNamesRepresentSameCatalog(left, right) {
+	return left === right || isOpenAiCuratedMarketplaceName(left) && isOpenAiCuratedMarketplaceName(right);
+}
+function describeConfiguredPluginIdentityConflict(target, status) {
+	const identity = formatCodexDisplayText(target);
+	return status === "ambiguous" ? `Multiple configured Codex plugins match '${identity}'; resolve duplicate plugin policies first.` : `Configured Codex plugin key '${identity}' points to a different plugin identity; resolve the configuration conflict first.`;
+}
+//#endregion
+//#region extensions/codex/src/command-plugins-readiness.ts
+/** Runtime support is not account-wide permission to browse, connect or invoke apps. */
+async function readCodexHostedAppsSupport(context, account) {
+	if (account.status !== "known") return "unknown";
+	if (!isJsonObject(account.value.account) || account.value.account.type !== "chatgpt") return "sign_in_required";
+	const features = await readEvidence(async () => {
+		let cursor;
+		const visited = /* @__PURE__ */ new Set();
+		do {
+			const response = await context.request("experimentalFeature/list", {
+				...context.threadId ? { threadId: context.threadId } : {},
+				...cursor ? { cursor } : {},
+				limit: 100
+			});
+			const apps = response.data.find((feature) => feature.name === "apps");
+			if (apps) return apps.enabled;
+			cursor = response.nextCursor ?? void 0;
+			if (cursor && visited.has(cursor)) return;
+			if (cursor) visited.add(cursor);
+		} while (cursor);
+	});
+	if (features.status !== "known") return features.reason === "unsupported" ? "unsupported" : "unknown";
+	return features.value === void 0 ? "unknown" : features.value ? "supported" : "disabled";
+}
+function describeCodexHostedAppsSupport(support) {
+	switch (support) {
+		case "supported": return "Hosted apps: supported by this runtime; account connections and action permissions are checked separately.";
+		case "sign_in_required": return "Hosted apps require ChatGPT sign-in. Check /codex account; local Codex plugins remain available.";
+		case "disabled": return "Hosted apps are disabled in this Codex runtime. Check its effective apps feature configuration.";
+		case "unsupported": return "Hosted app support is unknown: this Codex version cannot report the required feature state. Update to OpenClaw's supported Codex version.";
+		default: return "Hosted app support is unknown. Check /codex account and retry this command.";
+	}
+}
+function pluginCatalogState(summary) {
+	if (!summary) return "unknown";
+	if (summary.availability === "DISABLED_BY_ADMIN" || summary.installPolicy === "NOT_AVAILABLE") return "blocked";
+	return summary.availability === "AVAILABLE" && (summary.installPolicy === "AVAILABLE" || summary.installPolicy === "INSTALLED_BY_DEFAULT") ? "available" : "unknown";
+}
+function codexPluginAppPageLinks(readiness) {
+	if (readiness.hostedSupport !== "supported" || pluginCatalogState(readiness.summary) !== "available" || readiness.metadata.status !== "known") return [];
+	const metadata = new Map(readiness.metadata.value.apps.map((app) => [app.id, app]));
+	return (readiness.detail?.apps ?? []).flatMap((app) => {
+		const authorized = metadata.get(app.id);
+		return authorized ? [{
+			...app,
+			name: authorized.name,
+			installUrl: authorized.installUrl
+		}] : [];
+	});
+}
+/** Reads existing snapshots only. Neither metadata nor installation proves a live connection. */
+async function readCodexPluginReadiness(params) {
+	const { context, current, configKey } = params;
+	const entry = current.plugins?.[configKey];
+	const identity = entry ? resolveConfiguredPluginIdentity(entry) : void 0;
+	if (!entry?.marketplaceName || !entry.pluginName || !identity) throw new Error("This configured plugin has no marketplace identity. Check /codex plugins list.");
+	const result = {
+		configKey,
+		commandId: `${identity.pluginName}@${identity.marketplaceName}`,
+		openClawEnabled: current.enabled === true && entry.enabled !== false,
+		agentId: context.agentId,
+		profileId: context.profileId,
+		workspaceDir: context.workspaceDir,
+		threadId: context.threadId,
+		runtime: {
+			status: "unavailable",
+			reason: "request_failed"
+		},
+		metadata: {
+			status: "unavailable",
+			reason: "request_failed"
+		},
+		account: await readEvidence(() => context.request("account/read", { refreshToken: false })),
+		hostedSupport: "unknown"
+	};
+	const installed = await readEvidence(() => context.request("plugin/installed", { cwds: [context.workspaceDir] }));
+	let selected = installed.status === "known" ? findCodexMarketplacePluginSummary(installed.value, entry.marketplaceName, entry.pluginName) : void 0;
+	if (!selected) {
+		const responses = [];
+		const catalog = await readEvidence(() => discoverCodexMarketplacePlugins({
+			workspaceDir: context.workspaceDir,
+			request: async (requestParams) => {
+				const response = await context.request("plugin/list", requestParams);
+				responses.push(response);
+				return response;
+			}
+		}));
+		if (catalog.status === "known") {
+			const matches = catalog.value.plugins.filter((plugin) => {
+				const configured = resolveInstalledPluginKey(current.plugins ?? {}, plugin);
+				return configured.status === "matched" && configured.configKey === configKey;
+			});
+			const candidate = matches.length === 1 ? matches[0] : resolveCuratedMarketplaceAliases(matches, entry.marketplaceName);
+			if (candidate) for (const response of responses) {
+				selected = findCodexMarketplacePluginSummary(response, candidate.marketplaceName, candidate.summaryId);
+				if (selected) {
+					selected.summary = {
+						...selected.summary,
+						installed: candidate.installed,
+						enabled: candidate.enabled,
+						...candidate.available ? {} : { availability: "DISABLED_BY_ADMIN" }
+					};
+					break;
+				}
+			}
+		} else result.diagnostic = describeUnavailableEvidence(catalog.reason);
+	}
+	if (!selected) {
+		await context.validateCurrent();
+		return result;
+	}
+	result.summary = selected.summary;
+	const selectedPlugin = selected;
+	const pluginName = selected.marketplace.remoteMarketplaceName ? selected.summary.remotePluginId : entry.pluginName;
+	if (!pluginName) return result;
+	const detail = await readEvidence(() => context.request("plugin/read", pluginReadParams(selectedPlugin.marketplace, pluginName)));
+	if (detail.status !== "known" || detail.value.plugin.summary.id !== selected.summary.id) {
+		if (detail.status === "unavailable") result.diagnostic = describeUnavailableEvidence(detail.reason);
+		await context.validateCurrent();
+		return result;
+	}
+	result.detail = detail.value.plugin;
+	result.summary = detail.value.plugin.summary;
+	const appIds = Array.from(new Set(result.detail.apps.map((app) => app.id))).toSorted();
+	if (appIds.length > 0) {
+		result.hostedSupport = await readCodexHostedAppsSupport(context, result.account);
+		const [runtime, metadata] = await Promise.all([readEvidence(() => context.request("app/installed", {
+			...context.threadId ? { threadId: context.threadId } : {},
+			forceRefresh: false
+		})), readEvidence(async () => {
+			const responses = [];
+			for (let offset = 0; offset < appIds.length; offset += 100) responses.push(await context.request("app/read", {
+				appIds: appIds.slice(offset, offset + 100),
+				...context.threadId ? { threadId: context.threadId } : {}
+			}));
+			return {
+				apps: responses.flatMap((response) => response.apps),
+				missingAppIds: responses.flatMap((response) => response.missingAppIds)
+			};
+		})]);
+		result.runtime = runtime;
+		result.metadata = metadata;
+	}
+	await context.validateCurrent();
+	return result;
+}
+function formatCodexPluginReadiness(readiness, page = 1) {
+	const summary = readiness.summary;
+	const catalog = pluginCatalogState(summary);
+	const hasApps = Boolean(readiness.detail?.apps.length);
+	const canRefreshHostedApps = readiness.hostedSupport === "supported";
+	const lines = [
+		`Plugin: ${display(readiness.commandId)}`,
+		`Agent: ${display(readiness.agentId)} · Profile: ${display(readiness.profileId ?? "native Codex account (profile unknown)")}`,
+		`Conversation workspace: ${display(readiness.workspaceDir)}`,
+		formatBoundAccount(readiness.account),
+		`Catalog: ${catalog === "blocked" ? "blocked by marketplace policy" : catalog}`,
+		`Bundle: ${summary ? summary.installed ? "installed" : "not installed" : "unknown"}`,
+		`Codex plugin: ${summary ? summary.enabled ? "enabled" : "disabled" : "unknown"}`,
+		`OpenClaw app access: ${readiness.openClawEnabled ? "enabled" : "disabled"} (shared Codex plugin configuration; takes effect on your next message).`,
+		...hasApps ? [describeCodexHostedAppsSupport(readiness.hostedSupport)] : []
+	];
+	if (catalog === "blocked") lines.push(summary?.disabledReason === "plan_not_eligible" ? "Next: this ChatGPT plan is not eligible for the plugin. Check its plan requirements." : summary?.disabledReason === "required_app_unavailable" ? "Next: a required hosted app is unavailable. Check access with the app or workspace owner." : summary?.disabledReason === "disabled_by_admin" || summary?.availability === "DISABLED_BY_ADMIN" ? "Next: ask the marketplace administrator to restore access." : "Next: check the plugin's marketplace requirements; its policy does not permit installation.");
+	else if (!readiness.openClawEnabled) lines.push(`Next: /codex plugins enable ${readiness.commandId}. Takes effect on your next message.`);
+	else if (summary && (!summary.installed || !summary.enabled)) lines.push(`Next: /codex plugins install ${readiness.commandId}. Takes effect on your next message.`);
+	const blocks = [{
+		type: "text",
+		text: lines.join("\n")
+	}];
+	if (readiness.diagnostic) blocks.push({
+		type: "text",
+		text: readiness.diagnostic
+	});
+	if (!readiness.detail) blocks.push({
+		type: "text",
+		text: "App details unavailable. Check the plugin in Codex, then run this status command again."
+	});
+	else {
+		const apps = readiness.detail.apps.toSorted((left, right) => left.id.localeCompare(right.id));
+		const pageCount = Math.max(1, Math.ceil(apps.length / 5));
+		if (page > pageCount) return { text: `No app page ${page}. Use /codex plugins status ${readiness.commandId} ${pageCount}.` };
+		const start = (page - 1) * 5;
+		const visible = apps.slice(start, start + 5);
+		const runtimeById = new Map(readiness.runtime.status === "known" ? readiness.runtime.value.apps.map((app) => [app.id, app]) : []);
+		if (visible.length > 0 && readiness.runtime.status === "unavailable") blocks.push({
+			type: "text",
+			text: describeUnavailableEvidence(readiness.runtime.reason)
+		});
+		blocks.push({
+			type: "text",
+			text: visible.length === 0 ? "No hosted apps declared. Skills and other plugin capabilities are not assessed here." : [
+				`Apps (page ${page}/${pageCount}):`,
+				`Runtime scope: ${readiness.threadId ? "current Codex thread" : "account (no bound Codex thread)"}.`,
+				...visible.map((app) => {
+					const runtime = runtimeById.get(app.id);
+					const state = runtime ? `enabled: ${runtime.enabled}; callable: ${runtime.callable}` : readiness.runtime.status === "known" ? "not reported by app/installed" : "runtime flags unavailable";
+					return `- ${display(app.name)}: ${state}.`;
+				})
+			].join("\n")
+		});
+		if (visible.length > 0) {
+			const authorized = new Map(codexPluginAppPageLinks(readiness).map((app) => [app.id, app]));
+			const links = visible.flatMap((app) => {
+				const link = authorized.get(app.id);
+				return link ? [link] : [];
+			});
+			blocks.push(...buildCodexPluginAppLinks(links, page < pageCount ? { continuationCommand: `/codex plugins status ${readiness.commandId} ${page + 1}` } : {}));
+			if (links.length < visible.length) blocks.push({
+				type: "text",
+				text: "Some app-page permissions are unknown or unavailable. A declared app or setup URL does not establish access. Retry this status command after checking the reported restriction."
+			});
+			blocks.push({
+				type: "text",
+				text: "Flags reflect Codex's runtime snapshot; status does not refresh hosted tools. After connecting, /codex plugins refresh refreshes hosted inventory for the current Codex account/runtime, across all apps. Use Check status separately to inspect this plugin without refreshing. OpenClaw app-access changes take effect on your next message; use /new or /reset after connecting."
+			});
+			blocks.push({
+				type: "buttons",
+				buttons: [...canRefreshHostedApps ? [{
+					label: "Refresh hosted apps",
+					action: {
+						type: "command",
+						command: "/codex plugins refresh"
+					}
+				}] : [], {
+					label: "Check status",
+					action: {
+						type: "command",
+						command: `/codex plugins status ${readiness.commandId}`
+					}
+				}]
+			});
+		}
+	}
+	const presentation = {
+		title: "Codex plugin status",
+		blocks
+	};
+	return {
+		text: renderMessagePresentationFallbackText({ presentation }),
+		presentation,
+		presentationTextMode: "fallback"
+	};
+}
+async function readEvidence(read) {
+	try {
+		return {
+			status: "known",
+			value: await read()
+		};
+	} catch (error) {
+		return {
+			status: "unavailable",
+			reason: error instanceof CodexAppServerRpcError && error.code === -32601 ? "unsupported" : "request_failed"
+		};
+	}
+}
+function describeUnavailableEvidence(reason) {
+	return reason === "unsupported" ? "This Codex app-server does not support the required status method. Update to OpenClaw's supported Codex version." : "Codex status could not be read. Check Codex sign-in and connectivity, then run this command again.";
+}
+function display(value) {
+	return formatCodexDisplayText(value.slice(0, 120));
+}
+function formatBoundAccount(evidence) {
+	const account = evidence.status === "known" ? evidence.value.account : void 0;
+	if (isJsonObject(account) && account.type === "chatgpt") {
+		const email = typeof account.email === "string" ? account.email : "email unknown";
+		const plan = typeof account.planType === "string" ? account.planType : "plan unknown";
+		return `ChatGPT account: ${formatCodexAccountLine(email.slice(0, 120))} (${display(plan)}).`;
+	}
+	if (isJsonObject(account) && typeof account.type === "string") return `Account type: ${display(account.type)}; ChatGPT account identity is not available.`;
+	return "Codex account: unknown. Check /codex account.";
+}
+//#endregion
+//#region extensions/codex/src/command-apps-refresh.ts
+/** Refreshes hosted app inventory for the current account/runtime. */
+async function refreshCodexHostedApps(context) {
+	let account;
+	try {
+		account = await context.request("account/read", { refreshToken: false });
+		const support = await readCodexHostedAppsSupport({ request: context.request }, {
+			status: "known",
+			value: account
+		});
+		if (support !== "supported") return { text: `Hosted app inventory was not refreshed. ${describeCodexHostedAppsSupport(support)}` };
+		await refreshCodexAppRuntimeState({
+			request: context.request,
+			appCache: defaultCodexAppInventoryCache,
+			appCacheKey: context.appCacheKey
+		});
+	} catch (error) {
+		await context.validateCurrent();
+		return { text: `${error instanceof CodexAppServerRpcError && error.code === -32601 ? "This Codex app-server does not support the required app inventory methods. Update the Codex plugin and retry." : (isCodexAppServerIndeterminateRequestCancellationError(error) || isCodexAppServerPrewriteRequestCancellationError(error)) && "reason" in error && error.reason === "aborted" ? "The hosted app refresh was cancelled." : "Hosted app tools could not be refreshed. Check the Codex connection and try again."} Run /codex plugins refresh to retry for the current Codex account/runtime. Previous inventory was not confirmed; no conversation policy was changed.` };
+	}
+	const presentation = {
+		title: "Hosted app refresh",
+		blocks: [{
+			type: "text",
+			text: [
+				`Agent: ${formatCodexDisplayText(context.agentId.slice(0, 120))} · Profile: ${formatCodexDisplayText((context.profileId ?? "native Codex account (profile unknown)").slice(0, 120))}`,
+				formatBoundAccount({
+					status: "known",
+					value: account
+				}),
+				"Hosted app refresh request completed for the current Codex account/runtime, across all hosted apps. Codex does not report whether it replaced its snapshot; this does not verify a live connection. No plugin enablement or conversation policy was changed. Use /new or /reset after connecting."
+			].join("\n")
+		}, {
+			type: "text",
+			text: "Use /codex plugins list to find configured plugins, then /codex plugins status <name>@<marketplace> to inspect one."
+		}]
+	};
+	return {
+		text: renderMessagePresentationFallbackText({ presentation }),
+		presentation,
+		presentationTextMode: "fallback"
+	};
+}
 //#endregion
 //#region extensions/codex/src/command-diagnostics-state.ts
 /** Runtime state for diagnostics upload throttling and confirmation handshakes. */
@@ -396,6 +847,10 @@ function buildCodexSubcommandPickerReply() {
 			label: "account",
 			command: "/codex account"
 		},
+		{
+			label: "refresh hosted apps",
+			command: "/codex plugins refresh"
+		},
 		{
 			label: "help",
 			command: "/codex help"
@@ -1121,7 +1576,7 @@ async function resolvePreparedCodexCommandAuthority(deps, ctx) {
 		assertCurrent
 	};
 }
-async function resolveCommandAppServerScope(deps, ctx, pluginConfig) {
+async function resolveCommandAppServerContext(deps, ctx, pluginConfig) {
 	const authority = await resolvePreparedCodexCommandAuthority(deps, ctx);
 	const { target, binding } = authority;
 	const fallback = resolveCodexConversationControlScope(ctx);
@@ -1131,22 +1586,32 @@ async function resolveCommandAppServerScope(deps, ctx, pluginConfig) {
 		agentDir,
 		config: ctx.config
 	});
-	const connection = resolveCodexBindingAppServerConnection({
+	const connection = await resolveCodexBindingAppServerConnection({
 		binding,
 		authProfileId,
-		pluginConfig
-	});
-	return {
-		agentId: target?.agentId ?? fallback.agentId,
+		pluginConfig,
 		agentDir,
-		...connection.clientAuthProfileId !== void 0 ? { authProfileId: connection.clientAuthProfileId } : {},
-		...connection.usesSupervisionConnection ? { startOptions: connection.appServer.start } : {},
-		...authority.sessionKey ? { sessionKey: authority.sessionKey } : {},
-		...authority.sessionId ? { sessionId: authority.sessionId } : {},
-		...authority.storePath ? { storePath: authority.storePath } : {},
+		config: ctx.config,
 		assertCurrent: authority.assertCurrent
+	});
+	return {
+		scope: {
+			agentId: target?.agentId ?? fallback.agentId,
+			agentDir,
+			...connection.clientAuthProfileId !== void 0 ? { authProfileId: connection.clientAuthProfileId } : {},
+			...connection.usesSupervisionConnection ? { startOptions: connection.appServer.start } : {},
+			...authority.sessionKey ? { sessionKey: authority.sessionKey } : {},
+			...authority.sessionId ? { sessionId: authority.sessionId } : {},
+			...authority.storePath ? { storePath: authority.storePath } : {},
+			assertCurrent: authority.assertCurrent
+		},
+		target,
+		binding
 	};
 }
+async function resolveCommandAppServerScope(deps, ctx, pluginConfig) {
+	return (await resolveCommandAppServerContext(deps, ctx, pluginConfig)).scope;
+}
 function conversationBindingIdentity(bindingId) {
 	return {
 		kind: "conversation",
@@ -1292,12 +1757,19 @@ async function sendCodexDiagnosticsFeedbackForTargets(deps, ctx, pluginConfig, n
 	const sent = [];
 	const failed = [];
 	for (const target of targets) {
+		const assertCurrent = () => {
+			const current = resolvePendingCodexDiagnosticsTargets(deps, [target], ctx.config);
+			if (!codexDiagnosticsTargetsMatch([target], current)) throw new Error("The Codex diagnostics session changed before upload; request it again.");
+		};
 		let connection;
 		try {
-			connection = resolveCodexBindingAppServerConnection({
+			connection = await resolveCodexBindingAppServerConnection({
 				binding: target,
 				authProfileId: target.authProfileId,
-				pluginConfig
+				pluginConfig,
+				agentDir: target.agentDir,
+				config: ctx.config,
+				assertCurrent
 			});
 		} catch (error) {
 			failed.push({
@@ -1315,6 +1787,7 @@ async function sendCodexDiagnosticsFeedbackForTargets(deps, ctx, pluginConfig, n
 		}, {
 			config: ctx.config,
 			agentDir: target.agentDir,
+			assertCurrent,
 			...connection.clientAuthProfileId !== void 0 ? { authProfileId: connection.clientAuthProfileId } : {},
 			...connection.usesSupervisionConnection ? { startOptions: connection.appServer.start } : {},
 			...target.sessionId ? { sessionId: target.sessionId } : {},
@@ -1828,10 +2301,13 @@ async function handleNativeGoal(deps, ctx, pluginConfig, args) {
 	const { target, binding } = authority;
 	if (!target) return "Cannot manage the Codex goal because this command has no stable binding identity.";
 	if (!binding?.threadId) return "No Codex thread is attached to this OpenClaw session yet.";
-	const connection = resolveCodexBindingAppServerConnection({
+	const connection = await resolveCodexBindingAppServerConnection({
 		binding,
 		authProfileId: binding.authProfileId,
-		pluginConfig
+		pluginConfig,
+		agentDir: target.agentDir,
+		config: ctx.config,
+		assertCurrent: authority.assertCurrent
 	});
 	const goalRequestOptions = {
 		agentDir: target.agentDir,
@@ -1999,10 +2475,13 @@ async function startThreadAction(deps, ctx, pluginConfig, kind, args) {
 		const result = await compactCurrent();
 		return result.compacted ? `Compacted Codex session (${result.tokensAfter ?? "unknown"} tokens after).` : `Codex compaction did not complete: ${formatCodexDisplayText(result.reason ?? "no reason returned")}.`;
 	}
-	const connection = resolveCodexBindingAppServerConnection({
+	const connection = await resolveCodexBindingAppServerConnection({
 		binding,
 		authProfileId: binding.authProfileId,
-		pluginConfig
+		pluginConfig,
+		agentDir: target.agentDir,
+		config: ctx.config,
+		assertCurrent: authority.assertCurrent
 	});
 	await deps.bindingStore.withLease(target.identity, () => deps.codexControlRequest(pluginConfig, CODEX_CONTROL_METHODS.review, {
 		threadId: binding.threadId,
@@ -2035,8 +2514,61 @@ function supervisedCommandGuard(deps, identity, binding) {
 	};
 }
 //#endregion
+//#region extensions/codex/src/command-plugins-available.ts
+const AVAILABLE_PAGE_SIZE = 10;
+function formatCodexAvailablePlugins(plugins, warnings, query, page) {
+	const filtered = filterCodexMarketplacePlugins(plugins, query);
+	const pageCount = Math.max(1, Math.ceil(filtered.length / AVAILABLE_PAGE_SIZE));
+	const start = (page - 1) * AVAILABLE_PAGE_SIZE;
+	const visible = filtered.slice(start, start + AVAILABLE_PAGE_SIZE);
+	const pageCommand = (target) => `/codex plugins available --page ${target}${query ? ` -- '${query.replaceAll("'", "'\\''")}'` : ""}`;
+	const buttons = [];
+	const lines = [];
+	if (filtered.length === 0) lines.push(query ? `No Codex plugins match "${formatCodexDisplayText(query)}" in the returned catalogs. Try a shorter search or browse all plugins.` : "No Codex plugins were discovered for the current workspace.");
+	else if (page > pageCount) {
+		lines.push(`No plugin page ${page}. There are ${filtered.length} results across ${pageCount} pages.`);
+		buttons.push({
+			label: "First page",
+			command: pageCommand(1)
+		});
+	} else {
+		lines.push(`Showing ${start + 1}–${start + visible.length} of ${filtered.length}${query ? ` matches for "${formatCodexDisplayText(query)}"` : " plugins"} (page ${page}/${pageCount}).`);
+		if (page > 1) buttons.push({
+			label: "Previous page",
+			command: pageCommand(page - 1)
+		});
+		if (page < pageCount) buttons.push({
+			label: "Next page",
+			command: pageCommand(page + 1)
+		});
+		lines.push(...visible.map((plugin) => {
+			const state = plugin.installed ? plugin.enabled ? "installed" : "installed, disabled" : plugin.available ? "available" : "unavailable";
+			const title = plugin.displayName ? `${formatCodexDisplayText(plugin.displayName)} — ` : "";
+			const publisher = plugin.developerName ? formatCodexDisplayText(plugin.developerName) : "Not provided";
+			const description = plugin.description ? formatCodexDisplayText(plugin.description) : "No description provided.";
+			return `- ${title}${plugin.id} (${state})\n  Publisher: ${publisher}. ${description}`;
+		}));
+	}
+	lines.push(...warnings.map((warning) => `Warning: ${formatCodexDisplayText(warning)}`), "Search names, titles, publishers, marketplaces, or descriptions: /codex plugins available <query>", "To authorize one plugin, an owner or operator.admin must send:", "/codex plugins install <plugin>@<marketplace>");
+	if (query) buttons.push({
+		label: "Browse all plugins",
+		command: "/codex plugins available"
+	});
+	buttons.push({
+		label: "Plugin controls",
+		command: "/codex plugins menu"
+	});
+	const presentation = buildCodexCommandPickerPresentation("Discoverable Codex plugins", lines.join("\n"), buttons);
+	return {
+		text: renderMessagePresentationFallbackText({ presentation }),
+		presentation,
+		presentationTextMode: "fallback"
+	};
+}
+//#endregion
 //#region extensions/codex/src/command-plugins-management.ts
 const POLICY_REFRESH_HINT = "Takes effect on your next message.";
+const AVAILABLE_USAGE = "Usage: /codex plugins available [query] [--page <positive integer>]. Search text must be at most 100 characters; use -- before literal query text that contains options.";
 async function handleCodexPluginsSubcommand(ctx, rest, io, runtime) {
 	const [verb = "list", ...args] = rest;
 	const normalized = verb.toLowerCase();
@@ -2054,19 +2586,51 @@ async function handleCodexPluginsSubcommand(ctx, rest, io, runtime) {
 		return { text: formatPluginList(current.plugins ?? {}, { globalEnabled: current.enabled === true }) };
 	}
 	if (normalized === "available") {
-		if (args.length > 0) return { text: "Usage: /codex plugins available" };
 		if (!canMutateCodexHost(ctx)) return { text: "Only an owner or operator.admin gateway client can list available Codex plugins." };
+		let page = 1;
+		const queryParts = [];
+		for (let index = 0; index < args.length; index += 1) {
+			const arg = expectDefined(args[index], "current Codex plugin search argument");
+			if (arg === "--") {
+				queryParts.push(...args.slice(index + 1));
+				break;
+			}
+			if (arg === "--page") {
+				const parsedPage = parseStrictPositiveInteger(args[++index]);
+				if (parsedPage === void 0) return { text: AVAILABLE_USAGE };
+				page = parsedPage;
+			} else queryParts.push(arg);
+		}
+		const query = queryParts.join(" ").trim();
+		if (query.length > 100) return { text: AVAILABLE_USAGE };
 		if (!runtime) return { text: "Codex plugin discovery is unavailable for this command." };
 		try {
 			const discovered = await discoverCodexMarketplacePlugins({
 				request: runtime.list,
 				workspaceDir: await runtime.workspaceDir()
 			});
-			return { text: formatAvailablePlugins(discovered.plugins, discovered.warnings) };
+			return formatCodexAvailablePlugins(discovered.plugins, discovered.warnings, query, page);
 		} catch (error) {
 			return { text: `Could not list Codex plugins: ${formatCodexDisplayText(errorMessage(error))}` };
 		}
 	}
+	if (normalized === "status") {
+		const requestedPlugin = args[0];
+		const page = args[1] === void 0 ? 1 : Number(args[1]);
+		if (!requestedPlugin || !parseCodexPluginMarketplaceId(requestedPlugin) || args.length > 2 || !Number.isSafeInteger(page) || page < 1) return { text: "Usage: /codex plugins status <name>@<marketplace> [page]. Use /codex plugins list to find a configured plugin." };
+		if (!canMutateCodexHost(ctx)) return { text: "Only an owner or operator.admin gateway client can run /codex plugins status." };
+		if (!runtime?.withContext) return { text: "Codex plugin status is unavailable. Check the configured Codex app-server, then run this command again." };
+		return await runtime.withContext(async (context) => {
+			const configured = resolveConfiguredPluginKey(context.current.plugins ?? {}, requestedPlugin);
+			if (configured.status === "ambiguous" || configured.status === "mismatched") return { text: describeConfiguredPluginIdentityConflict(requestedPlugin, configured.status) };
+			if (configured.status === "missing") return { text: "This plugin is not explicitly configured. Use /codex plugins list, or /codex plugins available to find an install command." };
+			return formatCodexPluginReadiness(await readCodexPluginReadiness({
+				context,
+				current: context.current,
+				configKey: configured.configKey
+			}), page);
+		});
+	}
 	if (normalized === "install") {
 		if (args.length !== 1 || !args[0]) return { text: "Usage: /codex plugins install <plugin>@<marketplace>" };
 		if (!canMutateCodexHost(ctx)) return { text: "Only an owner or operator.admin gateway client can run /codex plugins install." };
@@ -2108,9 +2672,11 @@ function buildPluginsMenuReply() {
 			"",
 			"  1. /codex plugins list",
 			"  2. /codex plugins available",
-			"  3. /codex plugins enable",
-			"  4. /codex plugins disable",
-			"  5. /codex plugins help",
+			"  3. /codex plugins status <name>@<marketplace>",
+			"  4. /codex plugins refresh — refresh hosted apps",
+			"  5. /codex plugins enable",
+			"  6. /codex plugins disable",
+			"  7. /codex plugins help",
 			"",
 			"Type '/codex' to go back to the main menu."
 		].join("\n"),
@@ -2123,6 +2689,10 @@ function buildPluginsMenuReply() {
 				label: "available",
 				command: "/codex plugins available"
 			},
+			{
+				label: "Refresh hosted apps",
+				command: "/codex plugins refresh"
+			},
 			{
 				label: "enable",
 				command: "/codex plugins enable"
@@ -2187,16 +2757,18 @@ function buildPluginsHelp() {
 		"Codex plugin discovery and owner-approved installation:",
 		"- /codex plugins                            (alias for list)",
 		"- /codex plugins list                       show explicitly configured plugins",
-		"- /codex plugins available                  list discoverable Codex marketplaces",
+		"- /codex plugins available [query] [--page <n>]  search or browse Codex plugins",
+		"- /codex plugins status <name>@<marketplace> [page]  inspect app readiness without refreshing",
+		"- /codex plugins refresh                   refresh all hosted apps for the current Codex account/runtime",
 		"- /codex plugins install <name>@<marketplace>  install and authorize one plugin",
 		"- /codex plugins enable <name>              enable a configured plugin",
 		"- /codex plugins disable <name>             disable a configured plugin",
-		"Only an owner or operator.admin can discover, install, enable, or disable plugins."
+		"Only an owner or operator.admin can discover, inspect, refresh hosted apps, install, enable, or disable plugins."
 	].join("\n");
 }
 async function installCodexPlugin(requestedId, io, runtime) {
 	const requested = parseCodexPluginMarketplaceId(requestedId);
-	if (!requested) return { text: "Invalid plugin identifier. Use /codex plugins install <plugin>@<marketplace> with ASCII letters, digits, underscores, or hyphens." };
+	if (!requested) return { text: "Invalid plugin identifier. Use /codex plugins install <plugin>@<marketplace>. Both names allow ASCII letters, digits, underscores, and hyphens. Plugin names may also contain dots between nonempty segments." };
 	let plugin;
 	let workspaceDir;
 	try {
@@ -2271,104 +2843,64 @@ async function installCodexPlugin(requestedId, io, runtime) {
 	}
 	const appsNeedingAuth = result?.appsNeedingAuth ?? [];
 	if (appsNeedingAuth.length > 0) {
-		const apps = appsNeedingAuth.map((app) => formatCodexDisplayText(app.name)).slice(0, 5).join(", ");
-		return { text: `${formatCodexDisplayText(requestedId)} was installed and authorized, but ${apps} still require connector authentication. Complete sign-in before using those apps.${refreshWarning} ${POLICY_REFRESH_HINT}` };
-	}
-	const status = alreadyInstalled ? "was already installed in Codex and is now authorized" : "was installed and authorized";
-	return { text: `${formatCodexDisplayText(requestedId)} ${status}.${refreshWarning} ${POLICY_REFRESH_HINT}` };
-}
-/** Merge historical curated wire aliases only when they identify the same install source. */
-function resolveCuratedMarketplaceAliases(plugins, requestedMarketplaceName) {
-	if (!isOpenAiCuratedMarketplaceName(requestedMarketplaceName)) return;
-	const sourceIdentities = new Set(plugins.map((plugin) => plugin.marketplacePath ? `local:${plugin.marketplacePath}` : plugin.remotePluginId ? `remote:${plugin.remotePluginId}` : void 0));
-	if (sourceIdentities.size !== 1 || sourceIdentities.has(void 0)) return;
-	const selected = plugins.find((plugin) => plugin.marketplaceName === requestedMarketplaceName) ?? plugins[0];
-	if (!selected) return;
-	return {
-		...selected,
-		installed: plugins.some((plugin) => plugin.installed),
-		enabled: plugins.some((plugin) => plugin.installed && plugin.enabled),
-		available: plugins.every((plugin) => plugin.available),
-		...selected.remotePluginId ? { mustShowInstallationInterstitial: plugins.some((plugin) => plugin.mustShowInstallationInterstitial === true) ? true : plugins.every((plugin) => plugin.mustShowInstallationInterstitial === false) ? false : null } : {},
-		...plugins.some((plugin) => plugin.installPolicy === "NOT_AVAILABLE") ? { installPolicy: "NOT_AVAILABLE" } : {}
-	};
-}
-function persistedPluginName(plugin) {
-	return !plugin.marketplacePath && plugin.summaryId.endsWith(`@${plugin.marketplaceName}`) ? plugin.summaryId : plugin.pluginName;
-}
-function resolveConfiguredPluginKey(plugins, target) {
-	const requested = parseCodexPluginMarketplaceId(target);
-	const direct = plugins[target];
-	if (!requested) {
-		if (!direct) return { status: "missing" };
-		const qualifiedName = direct.pluginName ? parseCodexPluginMarketplaceId(direct.pluginName) : void 0;
-		if (qualifiedName && direct.marketplaceName && !marketplaceNamesRepresentSameCatalog(qualifiedName.marketplaceName, direct.marketplaceName)) return { status: "mismatched" };
-		const identity = resolveConfiguredPluginIdentity(direct);
-		if (!identity) return {
-			status: "matched",
-			configKey: target
+		let appLinks = [];
+		if (runtime.withContext) try {
+			appLinks = await runtime.withContext(async (context) => {
+				const configured = resolveConfiguredPluginKey(context.current.plugins ?? {}, requestedId);
+				if (configured.status !== "matched") return [];
+				const readiness = await readCodexPluginReadiness({
+					context,
+					current: context.current,
+					configKey: configured.configKey
+				});
+				const pendingIds = new Set(appsNeedingAuth.map((app) => app.id));
+				return codexPluginAppPageLinks(readiness).filter((app) => pendingIds.has(app.id));
+			});
+		} catch {}
+		const authRequirement = appsNeedingAuth.length === 1 ? "1 app still requires" : `${appsNeedingAuth.length} apps still require`;
+		const presentation = {
+			title: "Codex plugin app setup",
+			tone: "warning",
+			blocks: [
+				{
+					type: "text",
+					text: `${formatCodexDisplayText(requestedId)} bundle was installed in Codex. OpenClaw app access is configured. ${authRequirement} connector authentication in ChatGPT. Installation does not confirm app connections or current-conversation readiness.`
+				},
+				...buildCodexPluginAppLinks(appLinks),
+				...appLinks.length < appsNeedingAuth.length ? [{
+					type: "text",
+					text: `Some app setup permissions could not be confirmed. Run /codex plugins status ${requestedId} to check the current account and restrictions.`
+				}] : [],
+				{
+					type: "buttons",
+					buttons: [...appLinks.length > 0 ? [{
+						label: "Refresh hosted apps",
+						action: {
+							type: "command",
+							command: "/codex plugins refresh"
+						}
+					}] : [], {
+						label: "Check status",
+						action: {
+							type: "command",
+							command: `/codex plugins status ${requestedId}`
+						}
+					}]
+				},
+				{
+					type: "context",
+					text: `${refreshWarning.trim()} ${POLICY_REFRESH_HINT}`.trim()
+				}
+			]
 		};
-		const marketplaceName = isOpenAiCuratedMarketplaceName(identity.marketplaceName) ? CODEX_PLUGINS_MARKETPLACE_NAME : identity.marketplaceName;
-		const canonicalId = `${identity.pluginName}@${marketplaceName}`;
-		const canonical = plugins[canonicalId];
-		if (canonical && !matchesConfiguredPluginIdentity(canonical, identity, canonicalId)) return { status: "mismatched" };
-		return Object.values(plugins).filter((entry) => matchesConfiguredPluginIdentity(entry, identity, canonicalId)).length > 1 ? { status: "ambiguous" } : {
-			status: "matched",
-			configKey: target
+		return {
+			text: renderMessagePresentationFallbackText({ presentation }),
+			presentation,
+			presentationTextMode: "fallback"
 		};
 	}
-	if (direct && !matchesConfiguredPluginIdentity(direct, requested, target)) return { status: "mismatched" };
-	const matching = Object.entries(plugins).filter(([, entry]) => matchesConfiguredPluginIdentity(entry, requested, target));
-	if (matching.length > 1) return { status: "ambiguous" };
-	const configKey = matching[0]?.[0];
-	return configKey ? {
-		status: "matched",
-		configKey
-	} : { status: "missing" };
-}
-function resolveInstalledPluginKey(plugins, plugin) {
-	const discovered = resolveConfiguredPluginKey(plugins, plugin.id);
-	if (discovered.status === "ambiguous" || discovered.status === "mismatched") return discovered;
-	if (!isOpenAiCuratedMarketplaceName(plugin.marketplaceName)) return discovered;
-	const canonical = resolveConfiguredPluginKey(plugins, `${plugin.pluginName}@${CODEX_PLUGINS_MARKETPLACE_NAME}`);
-	if (canonical.status === "ambiguous" || canonical.status === "mismatched") return canonical;
-	if (discovered.status === "matched" && canonical.status === "matched" && discovered.configKey !== canonical.configKey) return { status: "ambiguous" };
-	return canonical.status === "matched" ? canonical : discovered;
-}
-function resolveConfiguredPluginIdentity(entry) {
-	if (!entry.pluginName || !entry.marketplaceName) return;
-	const qualified = parseCodexPluginMarketplaceId(entry.pluginName);
-	if (qualified) return marketplaceNamesRepresentSameCatalog(qualified.marketplaceName, entry.marketplaceName) ? {
-		pluginName: qualified.pluginName,
-		marketplaceName: entry.marketplaceName
-	} : void 0;
-	return parseCodexPluginMarketplaceId(`${entry.pluginName}@${entry.marketplaceName}`);
-}
-function matchesConfiguredPluginIdentity(entry, requested, target) {
-	const configuredName = entry.pluginName ? parseCodexPluginMarketplaceId(entry.pluginName) : void 0;
-	return typeof entry.marketplaceName === "string" && marketplaceNamesRepresentSameCatalog(entry.marketplaceName, requested.marketplaceName) && (entry.pluginName === requested.pluginName || entry.pluginName === target || configuredName?.pluginName === requested.pluginName && marketplaceNamesRepresentSameCatalog(configuredName.marketplaceName, requested.marketplaceName));
-}
-function marketplaceNamesRepresentSameCatalog(left, right) {
-	return left === right || isOpenAiCuratedMarketplaceName(left) && isOpenAiCuratedMarketplaceName(right);
-}
-function describeConfiguredPluginIdentityConflict(target, status) {
-	const identity = formatCodexDisplayText(target);
-	return status === "ambiguous" ? `Multiple configured Codex plugins match '${identity}'; resolve duplicate plugin policies first.` : `Configured Codex plugin key '${identity}' points to a different plugin identity; resolve the configuration conflict first.`;
-}
-function formatAvailablePlugins(plugins, warnings) {
-	if (plugins.length === 0) return ["No Codex plugins were discovered for the current workspace.", ...warnings.map((warning) => `Warning: ${formatCodexDisplayText(warning)}`)].join("\n");
-	return [
-		"Discoverable Codex plugins:",
-		...plugins.slice(0, 30).map((plugin) => {
-			const state = plugin.installed ? plugin.enabled ? "installed" : "installed, disabled" : plugin.available ? "available" : "unavailable";
-			const description = plugin.description ? ` - ${formatCodexDisplayText(plugin.description)}` : "";
-			return `- ${plugin.id} (${state})${description}`;
-		}),
-		...plugins.length > 30 ? ["- Additional plugins omitted."] : [],
-		...warnings.map((warning) => `Warning: ${formatCodexDisplayText(warning)}`),
-		"To authorize one plugin, an owner or operator.admin must send:",
-		"/codex plugins install <plugin>@<marketplace>"
-	].join("\n");
+	const status = alreadyInstalled ? "bundle was already installed in Codex" : "bundle was installed in Codex";
+	return { text: `${formatCodexDisplayText(requestedId)} ${status}. OpenClaw app access is configured.${refreshWarning} ${POLICY_REFRESH_HINT}` };
 }
 function errorMessage(error) {
 	return error instanceof Error ? error.message : String(error);
@@ -2395,10 +2927,124 @@ function formatPluginList(plugins, options = {}) {
 		...rows.map((r) => `  ${r.state}  ${r.displayKey.padEnd(keyW)}  ${r.pluginName.padEnd(pluginW)}  [${r.marketplace}]`),
 		"",
 		...globalEnabled ? [] : ["Global codexPlugins.enabled is off; configured sub-plugins are inactive.", ""],
+		"Inspect one configured plugin: /codex plugins status <name>@<marketplace> [page].",
 		POLICY_REFRESH_HINT
 	].join("\n");
 }
 //#endregion
+//#region extensions/codex/src/command-plugins-runtime.ts
+const SCOPE_CHANGED_MESSAGE = "Codex account, conversation, or plugin policy changed. Run the command again.";
+async function withCodexPluginCommandContext(params, run) {
+	const { deps, ctx, pluginConfig } = params;
+	const current = await deps.codexPluginsManagementIo?.readConfig() ?? {};
+	const initialPolicy = JSON.stringify(current);
+	const { scope, target, binding } = await resolveCommandAppServerContext(deps, ctx, pluginConfig);
+	const conversation = readCodexConversationBindingData(await ctx.getCurrentConversationBinding());
+	const workspaceDir = binding?.cwd || (conversation?.kind === "codex-app-server-session" ? conversation.workspaceDir : void 0) || resolveAgentWorkspaceDir(ctx.config, scope.agentId);
+	const configuredRuntime = resolveCodexAppServerRuntimeOptions({ pluginConfig });
+	const appServer = scope.startOptions ? {
+		...configuredRuntime,
+		start: scope.startOptions
+	} : configuredRuntime;
+	const auth = await prepareCodexControlSessionAuth({
+		...scope,
+		config: ctx.config
+	}, appServer.start);
+	const preparedAuth = "preparedAuth" in auth.clientOptions ? auth.clientOptions.preparedAuth : void 0;
+	const usesNativeAuth = scope.authProfileId === null || appServer.start.homeScope === "user";
+	const profileId = usesNativeAuth ? void 0 : auth.authProfileId;
+	const readAuthBinding = () => profileId ? fingerprintCodexAppServerAuthBinding({
+		authProfileId: profileId,
+		authProfileStore: resolveCodexAppServerAuthProfileStore({
+			authProfileId: profileId,
+			agentDir: scope.agentDir,
+			config: ctx.config
+		}),
+		agentDir: scope.agentDir,
+		config: ctx.config
+	}) : Promise.resolve(void 0);
+	const authBinding = "authBindingFingerprint" in auth.clientOptions ? auth.clientOptions.authBindingFingerprint : await readAuthBinding();
+	const accountId = usesNativeAuth ? void 0 : preparedAuth?.kind === "api-key" ? resolveCodexAppServerPreparedApiKeyCacheKey(preparedAuth.apiKey) : preparedAuth?.kind === "profile" ? preparedAuth.snapshot.secretFreeCacheKey : await resolveCodexAppServerAuthAccountCacheKey({
+		authProfileId: profileId,
+		agentDir: scope.agentDir,
+		config: ctx.config
+	});
+	if (await readAuthBinding() !== authBinding) throw new Error(SCOPE_CHANGED_MESSAGE);
+	return await withCodexAppServerJsonClient({
+		startOptions: appServer.start,
+		pluginConfig,
+		agentDir: scope.agentDir,
+		config: ctx.config,
+		sessionId: ctx.sessionId,
+		sessionKey: ctx.sessionKey,
+		timeoutMs: appServer.requestTimeoutMs,
+		timeoutMessage: "Codex plugin request timed out. Check the Codex connection and retry.",
+		assertCurrent: scope.assertCurrent,
+		...auth.clientOptions
+	}, async (request, client, requestScope) => {
+		const assertCurrent = () => {
+			requestScope.assertCurrent();
+			if (client.getCloseError()) throw new Error(SCOPE_CHANGED_MESSAGE);
+		};
+		const validateCurrent = async () => {
+			assertCurrent();
+			const currentTarget = await resolveControlTarget(ctx);
+			const currentConversation = readCodexConversationBindingData(await ctx.getCurrentConversationBinding());
+			const currentPolicy = JSON.stringify(await deps.codexPluginsManagementIo?.readConfig() ?? {});
+			const currentAuthBinding = await readAuthBinding();
+			assertCurrent();
+			if (!isDeepStrictEqual(currentTarget, target) || !isDeepStrictEqual(currentConversation, conversation) || currentPolicy !== initialPolicy || currentAuthBinding !== authBinding) throw new Error(SCOPE_CHANGED_MESSAGE);
+		};
+		try {
+			await request({
+				method: "account/read",
+				requestParams: { refreshToken: false },
+				assertCurrent
+			});
+		} catch {
+			requestScope.assertCurrent();
+			throw new Error("Codex account startup could not be confirmed. Check /codex account and retry.");
+		}
+		const unsubscribe = client.addNotificationHandler((notification) => {
+			if (notification.method === "account/updated") requestScope.abort(/* @__PURE__ */ new Error(SCOPE_CHANGED_MESSAGE));
+		});
+		try {
+			await validateCurrent();
+			const result = await run({
+				request: async (method, requestParams) => {
+					await validateCurrent();
+					const response = await request({
+						method,
+						requestParams,
+						assertCurrent
+					});
+					await validateCurrent();
+					return response;
+				},
+				workspaceDir,
+				agentId: scope.agentId,
+				current,
+				...profileId ? { profileId } : {},
+				...binding?.clientId === client.getInstanceId() ? { threadId: binding.threadId } : {},
+				appCacheKey: buildCodexPluginAppCacheKey({
+					appServer,
+					agentDir: scope.agentDir,
+					authProfileId: profileId,
+					accountId,
+					envApiKeyFingerprint: usesNativeAuth || preparedAuth || profileId ? void 0 : resolveCodexAppServerFallbackApiKeyCacheKey({ startOptions: appServer.start }),
+					appServerVersion: client.getServerVersion(),
+					runtimeIdentity: client.getRuntimeIdentity()
+				}),
+				validateCurrent
+			});
+			await validateCurrent();
+			return result;
+		} finally {
+			unsubscribe();
+		}
+	});
+}
+//#endregion
 //#region extensions/codex/src/command-handlers.ts
 const CODEX_HOST_INSPECTION_SUBCOMMANDS = /* @__PURE__ */ new Set([
 	"account",
@@ -2420,10 +3066,24 @@ async function handleCodexSubcommand(ctx, options) {
 	const sandboxBlock = resolveCodexNativeCommandSandboxBlock(ctx, normalized, rest);
 	if (sandboxBlock) return { text: sandboxBlock };
 	if (normalized === "plugins") {
+		if (rest[0]?.toLowerCase() === "refresh") {
+			if (rest.length !== 1) return { text: "Usage: /codex plugins refresh — refresh hosted app inventory for the current Codex account/runtime." };
+			if (!canMutateCodexHost(ctx)) return { text: "Only an owner or operator.admin gateway client can refresh hosted app inventory." };
+			return await withCodexPluginCommandContext({
+				deps,
+				ctx,
+				pluginConfig: options.pluginConfig
+			}, (context) => refreshCodexHostedApps(context));
+		}
 		if (!deps.codexPluginsManagementIo) return { text: "Codex sub-plugin management is not wired up (codexPluginsManagementIo dep is undefined). Edit ~/.openclaw/openclaw.json or use `openclaw config patch` until the runtime exposes the IO." };
 		let appServerScope;
 		const getAppServerScope = () => appServerScope ??= resolveCommandAppServerScope(deps, ctx, options.pluginConfig);
 		return await handleCodexPluginsSubcommand(ctx, rest, deps.codexPluginsManagementIo, {
+			withContext: (run) => withCodexPluginCommandContext({
+				deps,
+				ctx,
+				pluginConfig: options.pluginConfig
+			}, run),
 			workspaceDir: async () => {
 				const data = readCodexConversationBindingData(await ctx.getCurrentConversationBinding());
 				return (data?.kind === "codex-app-server-session" ? data.workspaceDir : void 0)?.trim() || deps.resolveCodexDefaultWorkspaceDir(options.pluginConfig);