@openclaw/codex 2026.9.1-beta.1 → 2026.9.1

package/dist/{isolated-completion-Cv6FqygM.js → isolated-completion-kg9kv4iH.js}

@@ -1,7 +1,7 @@
-import { h as readCodexPluginConfig, r as resolveCodexAppServerHomeScope } from "./config-giW8X0QA.js";
-import { pt as resolveCodexAppServerPreparedAuthHandoff, vt as isJsonObject } from "./shared-client-DKz23hHY.js";
-import { t as runBoundedCodexAppServerTurn } from "./bounded-turn-B7iBUcuP.js";
-import { a as createAttributedCodexAssistantMessage } from "./event-projector-assistant-message-C5-Ds8mA.js";
+import { $t as isJsonObject, Wt as resolveCodexAppServerPreparedAuthHandoff } from "./shared-client-DxcfF9KX.js";
+import { E as readCodexPluginConfig, r as resolveCodexAppServerHomeScope } from "./config-BhmfC1s6.js";
+import { t as runBoundedCodexAppServerTurn } from "./bounded-turn-wzJrwKKe.js";
+import { a as createAttributedCodexAssistantMessage } from "./event-projector-assistant-message-DHRFXKbS.js";
 //#region extensions/codex/src/app-server/isolated-completion.ts
 const ISOLATED_PASSIVE_ITEM_TYPES = /* @__PURE__ */ new Set(["agentMessage", "reasoning"]);
 function assertIsolatedCompletionItems(items, prompt) {

package/dist/launch-args-RXQwn8zV.js

@@ -0,0 +1,90 @@
+//#region extensions/codex/src/app-server/launch-args.ts
+const CODEX_VALUE_OPTIONS = /* @__PURE__ */ new Set([
+	"-m",
+	"--model",
+	"--local-provider",
+	"-p",
+	"--profile",
+	"-s",
+	"--sandbox",
+	"-a",
+	"--ask-for-approval",
+	"-C",
+	"--cd",
+	"--add-dir",
+	"--remote",
+	"--remote-auth-token-env",
+	"-c",
+	"--config",
+	"--enable",
+	"--disable",
+	"--listen",
+	"--code-mode-host",
+	"--ws-auth",
+	"--ws-token-file",
+	"--ws-token-sha256",
+	"--ws-shared-secret-file",
+	"--ws-issuer",
+	"--ws-audience",
+	"--ws-max-clock-skew-seconds"
+]);
+/** One tokenization owner for launch, turn policy, reviewer trust, and private turns. */
+function readCodexArgs(args) {
+	const tokens = [];
+	let nativeSubcommand = false;
+	let end = 0;
+	for (const [index, arg] of args.entries()) {
+		if (index < end) continue;
+		end = index + 1;
+		const attached = /^(--[^=]+)=([\s\S]*)$/u.exec(arg) ?? /^(-[cmpisaC])=?([\s\S]+)$/u.exec(arg);
+		const name = attached?.[1] ?? arg;
+		let value = attached?.[2];
+		if (name === "-i" || name === "--image") while (args[end]?.startsWith("-") === false) end += 1;
+		else if (!attached && CODEX_VALUE_OPTIONS.has(name)) {
+			value = args[end];
+			if (value !== void 0) end += 1;
+		}
+		tokens.push({
+			index,
+			end,
+			name,
+			value
+		});
+		if (name === "app-server") nativeSubcommand = true;
+		if (name === "--" && nativeSubcommand) break;
+	}
+	return tokens;
+}
+function readCodexAppServerConfigOptions(args) {
+	return readCodexArgs(args).filter(({ name }) => name === "-c" || name === "--config" || name === "-p" || name === "--profile");
+}
+/** The stdio proxy forwards to an external server; it does not own that runtime. */
+function isCodexAppServerProxyLaunch(args) {
+	const tokens = readCodexArgs(args);
+	const server = tokens.findLastIndex(({ name }) => name === "app-server");
+	return server >= 0 && tokens.slice(server + 1).find(({ name }) => !name.startsWith("-"))?.name === "proxy";
+}
+/** Keeps Codex overrides in one CLI scope without rewriting raw TOML or wrapper prefixes. */
+function normalizeCodexAppServerArgs(rawArgs, enforcedOverride) {
+	const tokens = readCodexArgs(rawArgs);
+	const subcommandIndex = tokens.findLast(({ name }) => name === "app-server")?.index ?? -1;
+	const prefix = subcommandIndex < 0 ? [...rawArgs] : rawArgs.slice(0, subcommandIndex);
+	const suffix = [];
+	if (subcommandIndex >= 0) for (const token of tokens) {
+		if (token.index <= subcommandIndex) continue;
+		if (token.name === "--") {
+			suffix.push(...rawArgs.slice(token.index));
+			break;
+		}
+		(token.name === "-c" || token.name === "--config" ? prefix : suffix).push(...rawArgs.slice(token.index, token.end));
+	}
+	if (enforcedOverride && !(prefix.at(-2) === "-c" && prefix.at(-1) === enforcedOverride)) prefix.push("-c", enforcedOverride);
+	const normalized = subcommandIndex < 0 ? prefix : [
+		...prefix,
+		"app-server",
+		...suffix
+	];
+	return normalized.length === rawArgs.length && normalized.every((arg, index) => arg === rawArgs[index]) ? rawArgs : normalized;
+}
+//#endregion
+export { normalizeCodexAppServerArgs as n, readCodexAppServerConfigOptions as r, isCodexAppServerProxyLaunch as t };

package/dist/{managed-binary-DFYK4DWq.js → managed-binary-4-Vjz5GH.js}

@@ -46,7 +46,7 @@ function resolveFirstExistingMacOSDesktopCodexBundledMarketplacePath(params = {}
 * Version and package pins for the managed Codex app-server runtime.
 */
 /** Exact Codex app-server version shipped by the OpenClaw Codex bridge. */
-const CODEX_APP_SERVER_VERSION = "0.150.1";
+const CODEX_APP_SERVER_VERSION = "0.152.1";
 /** Inclusive runtime compatibility floor for external app-server binaries. */
 const MIN_SUPPORTED_CODEX_APP_SERVER_VERSION = "0.149.0";
 /** npm package name for the managed Codex app-server binary. */
@@ -91,12 +91,16 @@ function resolveManagedCodexNativeCommand(command, options = {}) {
 	if (!packageRoot) return;
 	const resolvePackageJson = options.resolvePackageJson ?? resolvePackageJsonFromRoot;
 	const pathExists = options.pathExists ?? existsSync;
-	for (const packageName of [target.packageName, MANAGED_CODEX_APP_SERVER_PACKAGE]) {
-		const packageJsonPath = resolvePackageJson(packageName, packageRoot);
-		if (!packageJsonPath) continue;
-		const candidate = path.join(path.dirname(packageJsonPath), "vendor", target.triple, "bin", platform === "win32" ? "codex.exe" : "codex");
-		if (pathExists(candidate)) return candidate;
-	}
+	const packageJsonPath = resolvePackageJson(target.packageName, packageRoot) ?? resolvePackageJson("@openai/codex", packageRoot);
+	if (!packageJsonPath) return;
+	const candidate = path.join(path.dirname(packageJsonPath), "vendor", target.triple, "bin", platform === "win32" ? "codex.exe" : "codex");
+	return pathExists(candidate) ? candidate : void 0;
+}
+/** Recognizes only the official npm entrypoint, not arbitrary configured wrappers. */
+function resolvePackagedCodexNativeCommand(entrypoint) {
+	const packageRoot = path.dirname(path.dirname(entrypoint));
+	if (path.basename(packageRoot) !== "codex" || path.basename(path.dirname(packageRoot)) !== "@openai" || path.relative(packageRoot, entrypoint) !== path.join("bin", "codex.js")) return;
+	return resolveManagedCodexNativeCommand(entrypoint);
 }
 /** Returns whether a command is one of the standard macOS desktop app executables. */
 function isManagedCodexDesktopCommand(command, platform = process.platform) {
@@ -147,7 +151,8 @@ function resolveCodexNativeTarget(platform, arch) {
 }
 function resolvePackageJsonFromRoot(packageName, root) {
 	try {
-		return createRequire(path.join(root, "package.json")).resolve(`${packageName}/package.json`);
+		const manifestPath = realpathSync(path.join(root, "package.json"));
+		return createRequire(manifestPath).resolve(`${packageName}/package.json`);
 	} catch {
 		return;
 	}
@@ -245,4 +250,4 @@ async function commandPathExists(filePath, platform) {
 	}
 }
 //#endregion
-export { CODEX_APP_SERVER_VERSION as a, resolveMacOSDesktopCodexAppPathCandidates as c, setManagedCodexPluginRoot as i, resolveMacOSDesktopCodexBundledMarketplaceCandidates as l, resolveManagedCodexAppServerStartOptions as n, MIN_SUPPORTED_CODEX_APP_SERVER_VERSION as o, resolveManagedCodexNativeCommand as r, resolveFirstExistingMacOSDesktopCodexBundledMarketplacePath as s, isManagedCodexDesktopCommand as t, resolveMacOSDesktopCodexComputerUseServiceAppCandidates as u };
+export { setManagedCodexPluginRoot as a, resolveFirstExistingMacOSDesktopCodexBundledMarketplacePath as c, resolveMacOSDesktopCodexComputerUseServiceAppCandidates as d, resolvePackagedCodexNativeCommand as i, resolveMacOSDesktopCodexAppPathCandidates as l, resolveManagedCodexAppServerStartOptions as n, CODEX_APP_SERVER_VERSION as o, resolveManagedCodexNativeCommand as r, MIN_SUPPORTED_CODEX_APP_SERVER_VERSION as s, isManagedCodexDesktopCommand as t, resolveMacOSDesktopCodexBundledMarketplaceCandidates as u };

package/dist/media-understanding-provider.js

@@ -1,4 +1,4 @@
-import { t as runBoundedCodexAppServerTurn } from "./bounded-turn-B7iBUcuP.js";
+import { t as runBoundedCodexAppServerTurn } from "./bounded-turn-wzJrwKKe.js";
 import { isRecord } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { validateJsonSchemaValue } from "openclaw/plugin-sdk/json-schema-runtime";
 //#region extensions/codex/media-understanding-provider.ts

package/dist/model-catalog-CUM68Hkl.js

@@ -0,0 +1,101 @@
+import { r as buildCodexRuntimeModelParams } from "./harness-DXVZ5II5.js";
+import { $t as isJsonObject, r as captureSharedCodexAppServerCatalogLifetime } from "./shared-client-DxcfF9KX.js";
+import { E as readCodexPluginConfig, i as resolveCodexAppServerRuntimeOptions } from "./config-BhmfC1s6.js";
+import { t as listAllCodexAppServerModels } from "./models-sYnEc0gd.js";
+import { o as withCodexAppServerJsonClient } from "./request-DYAI5FQE.js";
+//#region extensions/codex/src/app-server/model-catalog.ts
+const DEFAULT_MODEL_DISCOVERY_TIMEOUT_MS = 2500;
+const INPUT_TYPES = /* @__PURE__ */ new Set([
+	"text",
+	"image",
+	"audio",
+	"video",
+	"document"
+]);
+function isModelInputType(value) {
+	return INPUT_TYPES.has(value);
+}
+function codexAppServerModelsToCatalogEntries(models, runtime) {
+	return models.map((model, providerOrder) => {
+		const input = model.inputModalities.filter(isModelInputType);
+		const runtimeParams = buildCodexRuntimeModelParams(model.id, model.model);
+		return {
+			provider: "openai",
+			id: model.id,
+			name: model.displayName ?? model.id,
+			providerOrder,
+			nativeRuntime: runtime,
+			reasoning: model.supportedReasoningEfforts.length > 0,
+			...input.length > 0 ? { input } : {},
+			...runtimeParams ? { params: runtimeParams } : {},
+			compat: {
+				supportsReasoningEffort: model.supportedReasoningEfforts.length > 0,
+				supportedReasoningEfforts: model.supportedReasoningEfforts
+			}
+		};
+	});
+}
+/** One harness registration owns its observations; none travel with worker snapshots. */
+function createCodexAppServerModelCatalog(runtime) {
+	const scopes = /* @__PURE__ */ new WeakMap();
+	const scopeKey = (params) => JSON.stringify([
+		params.agentId,
+		params.agentDir,
+		params.workspaceDir
+	]);
+	let disposed = false;
+	return {
+		dispose() {
+			disposed = true;
+		},
+		read(params, pluginConfig) {
+			const observation = scopes.get(params.config)?.get(scopeKey(params));
+			return !disposed && params.provider === "openai" && observation !== void 0 && observation.pluginConfig === pluginConfig && observation.models?.has(params.modelId) && observation.accountType && observation.isCurrent?.() ? { accountType: observation.accountType } : void 0;
+		},
+		async load(params, pluginConfig) {
+			if (disposed) return [];
+			let observations = scopes.get(params.config);
+			if (!observations) {
+				observations = /* @__PURE__ */ new Map();
+				scopes.set(params.config, observations);
+			}
+			const key = scopeKey(params);
+			const observation = { pluginConfig };
+			observations.set(key, observation);
+			const discovery = readCodexPluginConfig(pluginConfig).discovery;
+			if (discovery?.enabled === false) return [];
+			const { start } = resolveCodexAppServerRuntimeOptions({ pluginConfig });
+			const timeoutMs = discovery?.timeoutMs ?? DEFAULT_MODEL_DISCOVERY_TIMEOUT_MS;
+			const result = await withCodexAppServerJsonClient({
+				startOptions: start,
+				config: params.config,
+				agentDir: params.agentDir,
+				timeoutMs
+			}, async (request, client) => {
+				const isCurrent = captureSharedCodexAppServerCatalogLifetime(client);
+				const models = (await listAllCodexAppServerModels({
+					request,
+					limit: 100,
+					includeHidden: true
+				})).models.filter((model) => !model.hidden || params.configuredModelRefs?.some((ref) => ref.provider === "openai" && ref.model === model.id));
+				const account = await request({
+					method: "account/read",
+					requestParams: { refreshToken: false }
+				});
+				const observedType = isJsonObject(account.account) ? account.account.type : void 0;
+				return {
+					models,
+					isCurrent,
+					accountType: account.requiresOpenaiAuth === true ? observedType === "apiKey" || observedType === "chatgpt" ? observedType : void 0 : void 0
+				};
+			});
+			if (disposed || observations.get(key) !== observation || !result.isCurrent()) return [];
+			observation.models = new Set(result.models.map((model) => model.id));
+			observation.accountType = result.accountType;
+			observation.isCurrent = result.isCurrent;
+			return codexAppServerModelsToCatalogEntries(result.models, runtime);
+		}
+	};
+}
+//#endregion
+export { createCodexAppServerModelCatalog };

package/dist/{models-TS3HBU-q.js → models-sYnEc0gd.js}

@@ -1,4 +1,4 @@
-import { t as assertCodexModelListResponse } from "./protocol-validators-VeJxxJ0U.js";
+import { Y as assertCodexModelListResponse } from "./shared-client-DxcfF9KX.js";
 import { normalizeOptionalString, uniqueStrings } from "openclaw/plugin-sdk/string-coerce-runtime";
 //#region extensions/codex/src/app-server/models.ts
 /**
@@ -7,22 +7,18 @@ import { normalizeOptionalString, uniqueStrings } from "openclaw/plugin-sdk/stri
 */
 /** Lists one Codex app-server model page using the configured auth/client options. */
 async function listCodexAppServerModels(options = {}) {
-	return await withCodexAppServerModelClient(options, async ({ client, timeoutMs }) => requestModelListPage(client, {
-		...options,
-		timeoutMs
-	}));
+	return await withCodexAppServerModelRequest(options, async (request) => requestModelListPage(request, options));
 }
 /** Walks Codex app-server model pages until exhaustion or the max-page guard. */
 async function listAllCodexAppServerModels(options = {}) {
 	const maxPages = normalizeMaxPages(options.maxPages);
-	return await withCodexAppServerModelClient(options, async ({ client, timeoutMs }) => {
+	return await withCodexAppServerModelRequest(options, async (request) => {
 		const models = [];
 		let cursor = options.cursor;
 		let nextCursor;
 		for (let page = 0; page < maxPages; page += 1) {
-			const result = await requestModelListPage(client, {
+			const result = await requestModelListPage(request, {
 				...options,
-				timeoutMs,
 				cursor
 			});
 			models.push(...result.models);
@@ -37,18 +33,13 @@ async function listAllCodexAppServerModels(options = {}) {
 		};
 	});
 }
-async function withCodexAppServerModelClient(options, run) {
+async function withCodexAppServerModelRequest(options, run) {
+	if (options.request) return await run(options.request);
 	const timeoutMs = options.timeoutMs ?? 2500;
 	const useSharedClient = options.sharedClient !== false;
-	const { createIsolatedCodexAppServerClient, getLeasedSharedCodexAppServerClient, releaseLeasedSharedCodexAppServerClient } = await import("./shared-client-DKz23hHY.js").then((n) => n.y);
-	const client = useSharedClient ? await getLeasedSharedCodexAppServerClient({
-		startOptions: options.startOptions,
-		timeoutMs,
-		authProfileId: options.authProfileId,
-		authRequirement: options.authRequirement,
-		agentDir: options.agentDir,
-		config: options.config
-	}) : await createIsolatedCodexAppServerClient({
+	const { createIsolatedCodexAppServerClient, getLeasedSharedCodexAppServerClient, releaseLeasedSharedCodexAppServerClient } = await import("./shared-client-DxcfF9KX.js").then((n) => n.x);
+	const { requestCodexAppServerClientJson } = await import("./request-DYAI5FQE.js").then((n) => n.a);
+	const client = await (useSharedClient ? getLeasedSharedCodexAppServerClient : createIsolatedCodexAppServerClient)({
 		startOptions: options.startOptions,
 		timeoutMs,
 		authProfileId: options.authProfileId,
@@ -57,21 +48,26 @@ async function withCodexAppServerModelClient(options, run) {
 		config: options.config
 	});
 	try {
-		return await run({
+		return await run((request) => requestCodexAppServerClientJson({
+			...request,
 			client,
-			timeoutMs
-		});
+			timeoutMs,
+			config: options.config
+		}));
 	} finally {
 		if (useSharedClient) releaseLeasedSharedCodexAppServerClient(client);
 		else client.close();
 	}
 }
-async function requestModelListPage(client, options) {
-	return readModelListResult(await client.request("model/list", {
-		limit: options.limit ?? null,
-		cursor: options.cursor ?? null,
-		includeHidden: options.includeHidden ?? null
-	}, { timeoutMs: options.timeoutMs }));
+async function requestModelListPage(request, options) {
+	return readModelListResult(await request({
+		method: "model/list",
+		requestParams: {
+			limit: options.limit ?? null,
+			cursor: options.cursor ?? null,
+			includeHidden: options.includeHidden ?? null
+		}
+	}));
 }
 /** Parses a raw Codex app-server model/list response into OpenClaw's normalized shape. */
 function readModelListResult(value) {
@@ -101,7 +97,8 @@ function readCodexModel(value) {
 	};
 }
 function readReasoningEfforts(value) {
-	return uniqueStrings(value.map((entry) => normalizeOptionalString(entry.reasoningEffort)).filter((entry) => entry !== void 0));
+	const efforts = value.map((entry) => normalizeOptionalString(entry.reasoningEffort)).filter((entry) => entry !== void 0);
+	return uniqueStrings(efforts);
 }
 function normalizeMaxPages(value) {
 	return typeof value === "number" && Number.isFinite(value) && value > 0 ? Math.floor(value) : 20;

package/dist/{native-subagent-monitor-4Mfq2HDs.js → native-subagent-monitor-CnH147jH.js}

@@ -1,21 +1,16 @@
-import { $ as releaseCodexAppServerLiveThread, et as retainCodexAppServerLiveThread, q as claimCodexAppServerLiveThread, vt as isJsonObject } from "./shared-client-DKz23hHY.js";
-import { A as shouldSynthesizeToolProgressForItem, B as readNullableString$1, C as isSideEffectingNativeToolItem, D as itemTitle, E as itemStatus, F as readItem, L as readNonEmptyString, M as normalizeOptionalString$1, P as readHookOutputEntries, R as readNonEmptyStringArray, S as isNonSuccessItemStatus, T as itemName, k as shouldRecordNativeToolTranscript, w as itemKind, x as isMutatingNativeToolItem, y as auditNativeToolTerminalStatus } from "./attempt-client-cleanup-bfsmcQ6m.js";
-import { t as attachCodexMirrorIdentity } from "./upstream-prompt-provenance-CFmsKwr9.js";
-import { n as sanitizeCodexHistoryImagePayloads } from "./image-payload-sanitizer-CnfoUPCE.js";
+import { $t as isJsonObject, At as retainCodexAppServerLiveThread, kt as releaseCodexAppServerLiveThread, xt as claimCodexAppServerLiveThread } from "./shared-client-DxcfF9KX.js";
+import { A as shouldRecordNativeToolTranscript, C as isSideEffectingNativeToolItem, D as itemTitle, E as itemStatus, F as readHookOutputEntries, I as readItem, N as normalizeOptionalString$1, R as readNonEmptyString, S as isNonSuccessItemStatus, T as itemName, V as readNullableString$1, j as shouldSynthesizeToolProgressForItem, w as itemKind, x as isMutatingNativeToolItem, y as auditNativeToolTerminalStatus, z as readNonEmptyStringArray } from "./attempt-client-cleanup-DYHcRQAa.js";
+import { t as attachCodexMirrorIdentity } from "./upstream-prompt-provenance-LphB8slG.js";
 import { t as resolveCodexLocalRuntimeAttribution } from "./local-runtime-attribution-B_2mnqhb.js";
-import { n as codexApprovalTimeoutText } from "./plugin-approval-roundtrip-bUm777tR.js";
+import { n as codexApprovalTimeoutText } from "./plugin-approval-roundtrip-CNe-Xrjx.js";
+import { n as readCodexMirroredSessionHistoryMessages } from "./session-history-C5J1AKzG.js";
 import { asFiniteNumber, asNonArrayRecord, normalizeOptionalString, readStringField } from "openclaw/plugin-sdk/string-coerce-runtime";
-import fs from "node:fs/promises";
 import path from "node:path";
 import { asDateTimestampMs } from "openclaw/plugin-sdk/number-runtime";
 import { TOOL_PROGRESS_OUTPUT_MAX_CHARS, embeddedAgentLog, emitAgentEvent, formatErrorMessage, formatToolAggregate, formatToolProgressOutput, inferToolMetaFromArgs, runAgentHarnessAfterToolCallHook } from "openclaw/plugin-sdk/agent-harness-runtime";
-import { getSessionEntry, parseSqliteSessionFileMarker, resolveTranscriptSessionKeyBySessionId } from "openclaw/plugin-sdk/session-store-runtime";
 import { truncateUtf16Safe } from "openclaw/plugin-sdk/text-utility-runtime";
 import { redactSensitiveFieldValue, redactToolPayloadText } from "openclaw/plugin-sdk/logging-core";
-import { readCodexSessionTranscriptEventsBeforeAdmission } from "openclaw/plugin-sdk/codex-session-transcript-runtime";
-import { readSessionTranscriptEvents } from "openclaw/plugin-sdk/session-transcript-runtime";
 import { KeyedAsyncQueue } from "openclaw/plugin-sdk/keyed-async-queue";
-import { buildSessionContext, migrateSessionEntries, parseSessionEntries } from "openclaw/plugin-sdk/agent-sessions";
 import { createAgentHarnessTaskRuntime, deliverAgentHarnessTaskCompletion, isDurableAgentHarnessCompletionDelivery } from "openclaw/plugin-sdk/agent-harness-task-runtime";
 //#region extensions/codex/src/app-server/event-projector-tool-output.ts
 const TOOL_TRANSCRIPT_OUTPUT_MAX_CHARS = 1e4;
@@ -114,7 +109,8 @@ function appendBoundedToolTranscriptText(currentPrefix, delta, originalLength) {
 	};
 	const textBudget = TOOL_TRANSCRIPT_OUTPUT_MAX_CHARS - notice.length;
 	const remaining = Math.max(0, textBudget - currentPrefix.length);
-	const rawPrefix = truncateUtf16Safe(remaining > 0 ? `${currentPrefix}${truncateUtf16Safe(delta, remaining)}` : currentPrefix, textBudget);
+	const prefix = remaining > 0 ? `${currentPrefix}${truncateUtf16Safe(delta, remaining)}` : currentPrefix;
+	const rawPrefix = truncateUtf16Safe(prefix, textBudget);
 	return {
 		text: `${rawPrefix}${notice}`,
 		rawPrefix
@@ -127,7 +123,8 @@ function truncateToolTranscriptText(text, originalLength = text.length) {
 	if (originalLength <= 1e4 && text.length <= 1e4) return text;
 	const notice = toolTranscriptTruncationNotice(originalLength);
 	if (notice.length >= 1e4) return notice.slice(1, 10001);
-	return `${truncateUtf16Safe(text, TOOL_TRANSCRIPT_OUTPUT_MAX_CHARS - notice.length)}${notice}`;
+	const textBudget = TOOL_TRANSCRIPT_OUTPUT_MAX_CHARS - notice.length;
+	return `${truncateUtf16Safe(text, textBudget)}${notice}`;
 }
 function formatToolSummary(toolName, meta) {
 	const trimmedMeta = meta?.trim();
@@ -570,7 +567,7 @@ var CodexToolProgressProjection = class {
 		const args = itemToolArgs(item);
 		if (!toolName || !shouldEmitTranscriptToolProgress(toolName, args)) return;
 		this.resultSummaryItemIds.add(item.id);
-		const meta = this.shouldEmitToolOutput() || !isCommandBearingToolItem(item, args) ? itemMeta(item, this.toolProgressDetailMode()) : void 0;
+		const meta = this.shouldIncludeFormattedMeta(isCommandBearingToolItem(item, args)) ? itemMeta(item, this.toolProgressDetailMode()) : void 0;
 		this.emitToolResultMessage({
 			itemId: item.id,
 			text: formatToolSummary(toolName, meta)
@@ -582,9 +579,10 @@ var CodexToolProgressProjection = class {
 		const toolName = itemName(item);
 		const output = itemOutputText(item, this.output.textByItem);
 		if (!toolName || !output || !shouldEmitTranscriptToolProgress(toolName, itemToolArgs(item))) return;
+		const meta = this.shouldIncludeFormattedMeta(isCommandBearingToolItem(item, itemToolArgs(item))) ? itemMeta(item, this.toolProgressDetailMode()) : void 0;
 		this.emitToolResultMessage({
 			itemId: item.id,
-			text: formatToolOutput(toolName, itemMeta(item, this.toolProgressDetailMode()), output),
+			text: formatToolOutput(toolName, meta, output),
 			finalOutput: true,
 			isError: isNonSuccessItemStatus(itemStatus(item))
 		});
@@ -643,6 +641,7 @@ var CodexToolProgressProjection = class {
 		try {
 			Promise.resolve(this.params.onToolResult?.({
 				text,
+				...(this.params.messageChannel || this.params.messageProvider) && { channelData: { openclawToolProgressId: params.itemId } },
 				...params.isError === true ? { isError: true } : {}
 			})).catch(() => {});
 		} catch {}
@@ -653,11 +652,15 @@ var CodexToolProgressProjection = class {
 	shouldEmitToolOutput() {
 		return typeof this.params.shouldEmitToolOutput === "function" ? this.params.shouldEmitToolOutput() : this.params.verboseLevel === "full";
 	}
+	shouldIncludeFormattedMeta(commandBearing) {
+		const channel = this.params.messageChannel ?? this.params.messageProvider;
+		return !commandBearing || !channel && this.shouldEmitToolOutput();
+	}
 	emitTranscriptToolCallProgress(params) {
 		if (!shouldEmitTranscriptToolProgress(params.name, params.arguments)) return;
 		this.transcriptProgressCallIds.add(params.id);
 		const args = normalizeToolTranscriptArguments(params.arguments);
-		const meta = this.shouldEmitToolOutput() || !isCodexCommandBearingToolCall(params.name, args) ? inferToolMetaFromArgs(params.name, args, { detailMode: this.toolProgressDetailMode() }) : void 0;
+		const meta = this.shouldIncludeFormattedMeta(isCodexCommandBearingToolCall(params.name, args)) ? inferToolMetaFromArgs(params.name, args, { detailMode: this.toolProgressDetailMode() }) : void 0;
 		if (!this.params.onToolResult || !this.shouldEmitToolResult() || this.resultSummaryItemIds.has(params.id) || this.resultOutputStreamedItemIds.has(params.id)) return;
 		this.resultSummaryItemIds.add(params.id);
 		this.emitToolResultMessage({
@@ -717,85 +720,6 @@ var CodexToolProgressProjection = class {
 	}
 };
 //#endregion
-//#region extensions/codex/src/app-server/session-history.ts
-/**
-* Reads OpenClaw session history for Codex transcript mirroring and sanitizes
-* image payloads before replaying messages into the app-server projector.
-*/
-function isMissingFileError(error) {
-	return Boolean(error && typeof error === "object" && "code" in error && error.code === "ENOENT");
-}
-/** Returns sanitized session-context messages for a Codex mirrored session file. */
-async function readCodexMirroredSessionHistoryMessages(target, admission) {
-	try {
-		const entries = await readCodexMirroredSessionEntries(target, admission);
-		if (entries.length === 0) return [];
-		const firstEntry = entries[0];
-		if (firstEntry?.type !== "session") return [];
-		if (typeof firstEntry.id !== "string") return;
-		if (firstEntry.id !== target.sessionId) return [];
-		migrateSessionEntries(entries);
-		return sanitizeCodexHistoryImagePayloads(buildSessionContext(entries.filter((entry) => {
-			return entry !== null && typeof entry === "object" && !Array.isArray(entry) && entry.type !== "session";
-		})).messages, "codex mirrored history");
-	} catch (error) {
-		if (isMissingFileError(error)) return [];
-		return;
-	}
-}
-async function readCodexMirroredSessionEntries(target, admission) {
-	if (target.sessionTarget) {
-		const { agentId, sessionId, sessionKey, storePath } = target.sessionTarget;
-		if (!agentId || !sessionId || !sessionKey || !storePath || sessionId !== target.sessionId || target.agentId !== void 0 && agentId !== target.agentId || target.sessionKey !== void 0 && sessionKey !== target.sessionKey) return [];
-		const transcriptTarget = {
-			agentId,
-			sessionId,
-			sessionKey,
-			storePath
-		};
-		return await (admission ? readCodexSessionTranscriptEventsBeforeAdmission(transcriptTarget, admission) : readSessionTranscriptEvents(transcriptTarget));
-	}
-	const sqliteMarker = parseSqliteSessionFileMarker(target.sessionFile);
-	if (sqliteMarker) {
-		if (sqliteMarker.sessionId !== target.sessionId || target.agentId !== void 0 && sqliteMarker.agentId !== target.agentId) return [];
-		const sessionKey = resolveSqliteMarkerSessionKey(target, sqliteMarker);
-		if (!sessionKey) return [];
-		const transcriptTarget = {
-			agentId: sqliteMarker.agentId,
-			sessionId: sqliteMarker.sessionId,
-			sessionKey,
-			storePath: sqliteMarker.storePath
-		};
-		return await (admission ? readCodexSessionTranscriptEventsBeforeAdmission(transcriptTarget, admission) : readSessionTranscriptEvents(transcriptTarget));
-	}
-	if (admission) {
-		if (admission.sessionId !== target.sessionId || target.agentId !== void 0 && admission.agentId !== target.agentId || target.sessionKey !== void 0 && admission.sessionKey !== target.sessionKey) return [];
-		return await readCodexSessionTranscriptEventsBeforeAdmission({
-			agentId: admission.agentId,
-			sessionId: admission.sessionId,
-			sessionKey: admission.sessionKey,
-			storePath: admission.storePath
-		}, admission);
-	}
-	return parseSessionEntries(await fs.readFile(target.sessionFile, "utf-8"));
-}
-function resolveSqliteMarkerSessionKey(target, marker) {
-	const explicitSessionKey = target.sessionKey?.trim();
-	if (explicitSessionKey) {
-		const explicitEntry = getSessionEntry({
-			agentId: marker.agentId,
-			sessionKey: explicitSessionKey,
-			storePath: marker.storePath
-		});
-		if (explicitEntry) return explicitEntry.sessionId === marker.sessionId ? explicitSessionKey : void 0;
-	}
-	return resolveTranscriptSessionKeyBySessionId({
-		agentId: marker.agentId,
-		sessionId: marker.sessionId,
-		storePath: marker.storePath
-	});
-}
-//#endregion
 //#region extensions/codex/src/app-server/event-projector-tool-transcript.ts
 const ZERO_USAGE = {
 	input: 0,
@@ -866,6 +790,7 @@ var CodexToolTranscriptProjection = class {
 		this.nativeMcpAppResultDetailsAttempted = /* @__PURE__ */ new Set();
 		this.approvalReviewsByCallId = /* @__PURE__ */ new Map();
 		this.rawNativeToolOutputByCallId = /* @__PURE__ */ new Map();
+		this.pendingRawPatchOutputIds = /* @__PURE__ */ new Set();
 		this.codeModeNativePatchInputsByCallId = /* @__PURE__ */ new Map();
 	}
 	get transcriptMessages() {
@@ -969,14 +894,18 @@ var CodexToolTranscriptProjection = class {
 			} catch {
 				return;
 			}
-			if (args) this.recordToolCall({
-				id: callId,
-				name: "apply_patch",
-				arguments: args
-			});
+			if (args) {
+				this.pendingRawPatchOutputIds.add(callId);
+				this.recordToolCall({
+					id: callId,
+					name: "apply_patch",
+					arguments: args
+				});
+			}
 			return;
 		}
 		if (type !== "custom_tool_call_output" && type !== "function_call_output" || this.namesById.get(callId) !== "apply_patch" && !this.codeModeNativePatchInputsByCallId.has(callId)) return;
+		this.pendingRawPatchOutputIds.delete(callId);
 		const text = typeof item.output === "string" ? item.output : Array.isArray(item.output) ? collectDynamicToolContentText(item.output) : "";
 		if (!text.trim()) return;
 		const codeModePatchInput = this.codeModeNativePatchInputsByCallId.get(callId);
@@ -1168,13 +1097,20 @@ var CodexToolTranscriptProjection = class {
 		this.callIds.add(params.id);
 		this.namesById.set(params.id, params.name);
 		this.progress.recordTranscriptCall(params);
-		this.messages.push(attachCodexMirrorIdentity(this.createToolCallMessage(params), `${this.turnId}:tool:${params.id}:call`));
+		const message = attachCodexMirrorIdentity(this.createToolCallMessage(params), `${this.turnId}:tool:${params.id}:call`);
+		this.messages.push(message);
+		this.options.checkpointMessage?.({ read: () => message });
 	}
 	recordToolResult(params) {
 		if (!params.id || !params.name || this.resultIds.has(params.id)) return;
 		this.resultIds.add(params.id);
 		this.progress.recordTranscriptResult(params);
-		this.messages.push(attachCodexMirrorIdentity(this.createToolResultMessage(params), `${this.turnId}:tool:${params.id}:result`));
+		const message = attachCodexMirrorIdentity(this.createToolResultMessage(params), `${this.turnId}:tool:${params.id}:result`);
+		this.messages.push(message);
+		this.options.checkpointMessage?.({
+			read: () => message,
+			ready: () => !this.pendingRawPatchOutputIds.has(params.id)
+		});
 	}
 	recordMissingToolError(missingTranscriptIds, missingTrajectoryIds) {
 		const firstMissingId = missingTranscriptIds.find((id) => Boolean(this.namesById.get(id))) ?? missingTrajectoryIds.find((id) => Boolean(this.trajectoryNamesById.get(id) ?? this.namesById.get(id)));
@@ -1288,6 +1224,7 @@ function normalizeApprovalReviewStatus(status) {
 	return status === "inProgress" ? "in_progress" : status === "timedOut" ? "timed_out" : status;
 }
 const GUARDIAN_TIMEOUT_WARNING = "Automatic approval review timed out while evaluating the requested approval.";
+const LOG_ONLY_CODEX_WARNING_PATTERNS = [/^Configured service tier `[^`\r\n]+` is not advertised as supported for model `[^`\r\n]+` and will be omitted from requests\.$/, /^Code Mode is enabled in configuration, but model `[^`\r\n]+` does not advertise Code Mode support\. This may degrade model performance\. Disable `features\.code_mode` and `features\.code_mode_only`, or select a model whose metadata enables Code Mode\.$/];
 function projectNormalizedToolItem(params) {
 	const { item } = params;
 	if (!item || !shouldSynthesizeToolProgressForItem(item)) return;
@@ -1429,7 +1366,8 @@ var CodexEventProjection = class {
 	}
 	handleWarning(params) {
 		const message = [readStringField(params, "summary") ?? readStringField(params, "message"), readStringField(params, "details")].filter(Boolean).join("\n");
-		if (message) this.emitAgentEvent({
+		if (LOG_ONLY_CODEX_WARNING_PATTERNS.some((pattern) => pattern.test(message))) embeddedAgentLog.warn(message);
+		else if (message) this.emitAgentEvent({
 			stream: "notice",
 			data: {
 				phase: "warning",
@@ -2347,19 +2285,21 @@ var Monitor = class {
 		if (childState && !childState.terminal) this.emitChildTaskActivity(notification, childState);
 		this.captureChildAssistantMessage(notification);
 		await this.handleChildTurnCompletion(notification);
-		if (notification.method === "thread/status/changed" && threadId && threadStatus) if (threadStatus !== "systemerror") {
-			if (childState) this.clearSystemErrorFallback(childState);
-		} else {
-			if (childState) {
-				this.resumeChild(childState, { scheduleRecovery: false });
-				this.setRecoveryFallback(childState, systemErrorFallbackCompletion(childState.childThreadId), this.now());
+		if (notification.method === "thread/status/changed" && threadId && threadStatus) {
+			if (threadStatus !== "systemerror") {
+				if (childState) this.clearSystemErrorFallback(childState);
+			} else {
+				if (childState) {
+					this.resumeChild(childState, { scheduleRecovery: false });
+					this.setRecoveryFallback(childState, systemErrorFallbackCompletion(childState.childThreadId), this.now());
+				}
+				this.reconcileChildThread(threadId).catch((error) => {
+					this.logRecoveryFailure(threadId, error);
+					return false;
+				}).then((reconciled) => {
+					if (!reconciled && childState && this.childStates.get(threadId) === childState) this.scheduleRecoveryPoll(childState);
+				});
 			}
-			this.reconcileChildThread(threadId).catch((error) => {
-				this.logRecoveryFailure(threadId, error);
-				return false;
-			}).then((reconciled) => {
-				if (!reconciled && childState && this.childStates.get(threadId) === childState) this.scheduleRecoveryPoll(childState);
-			});
 		}
 		await this.handleCompletionNotification(notification);
 	}
@@ -3379,4 +3319,4 @@ function unrefTimer(timer) {
 	if (typeof timer === "object" && timer && "unref" in timer) timer.unref();
 }
 //#endregion
-export { readCodexMirroredSessionHistoryMessages as a, inferCodexDynamicToolMeta as c, sanitizeCodexToolArguments as d, sanitizeCodexToolResponse as f, CodexToolTranscriptProjection as i, isCodexCommandBearingToolCall as l, CodexEventProjection as n, CodexToolProgressProjection as o, emitCodexAgentEvent as r, shouldEmitTranscriptToolProgress as s, codexNativeSubagentMonitorRuntime as t, resolveCodexToolProgressDetailMode as u };
+export { CodexToolProgressProjection as a, isCodexCommandBearingToolCall as c, sanitizeCodexToolResponse as d, CodexToolTranscriptProjection as i, resolveCodexToolProgressDetailMode as l, CodexEventProjection as n, shouldEmitTranscriptToolProgress as o, emitCodexAgentEvent as r, inferCodexDynamicToolMeta as s, codexNativeSubagentMonitorRuntime as t, sanitizeCodexToolArguments as u };