@openclaw/codex 2026.9.5 → 2026.9.7

package/dist/.setup/image-payload-sanitizer-tupAr-2o.mjs

@@ -1,79 +0,0 @@
-import { isRecord } from "openclaw/plugin-sdk/string-coerce-runtime";
-import { INLINE_IMAGE_DATA_URL_PREFIX, sanitizeInlineImageDataUrl } from "openclaw/plugin-sdk/inline-image-data-url-runtime";
-//#region extensions/codex/src/app-server/image-payload-sanitizer.ts
-/**
-* Sanitizes inline image payloads mirrored through Codex history so invalid
-* base64 data becomes readable text instead of poisoning replayed transcripts.
-*/
-const IMAGE_OMITTED_TEXT = "omitted image payload: invalid inline image data";
-/** Validates and normalizes an inline image data URL for Codex history payloads. */
-function sanitizeInlineImageDataUrl$1(imageUrl) {
-	return sanitizeInlineImageDataUrl(imageUrl);
-}
-/** Builds the replacement text inserted when an inline image payload is invalid. */
-function invalidInlineImageText(label) {
-	return `[${label}] ${IMAGE_OMITTED_TEXT}`;
-}
-function sanitizeImageContentRecord(record, label) {
-	if (record.type === "image" && typeof record.data === "string") {
-		const mimeType = typeof record.mimeType === "string" ? record.mimeType : "image/png";
-		const imageUrl = sanitizeInlineImageDataUrl$1(`data:${mimeType};base64,${record.data}`);
-		if (!imageUrl) return {
-			type: "text",
-			text: invalidInlineImageText(label)
-		};
-		const commaIndex = imageUrl.indexOf(",");
-		const mime = imageUrl.slice(INLINE_IMAGE_DATA_URL_PREFIX.length, commaIndex).split(";")[0] ?? mimeType;
-		const data = imageUrl.slice(commaIndex + 1);
-		return mime === record.mimeType && data === record.data ? record : {
-			...record,
-			mimeType: mime,
-			data
-		};
-	}
-	if (record.type === "inputImage" && typeof record.imageUrl === "string") {
-		const imageUrl = sanitizeInlineImageDataUrl$1(record.imageUrl);
-		if (!imageUrl) return {
-			type: "inputText",
-			text: invalidInlineImageText(label)
-		};
-		return imageUrl === record.imageUrl ? record : {
-			...record,
-			imageUrl
-		};
-	}
-	if (record.type === "input_image" && typeof record.image_url === "string") {
-		const imageUrl = sanitizeInlineImageDataUrl$1(record.image_url);
-		if (!imageUrl) return {
-			type: "input_text",
-			text: invalidInlineImageText(label)
-		};
-		return imageUrl === record.image_url ? record : {
-			...record,
-			image_url: imageUrl
-		};
-	}
-}
-/** Sanitizes images without copying unchanged history or mutating its owned snapshot. */
-function sanitizeCodexHistoryImagePayloads(value, label) {
-	if (Array.isArray(value)) {
-		let next;
-		for (let index = 0; index < value.length; index++) {
-			const child = sanitizeCodexHistoryImagePayloads(value[index], label);
-			if (child !== value[index]) (next ??= value.slice())[index] = child;
-		}
-		return next ?? value;
-	}
-	if (!isRecord(value)) return value;
-	const imageRecord = sanitizeImageContentRecord(value, label);
-	if (imageRecord) return imageRecord;
-	let next;
-	for (const key in value) {
-		if (!Object.hasOwn(value, key)) continue;
-		const child = sanitizeCodexHistoryImagePayloads(value[key], label);
-		if (child !== value[key]) (next ??= { ...value })[key] = child;
-	}
-	return next ?? value;
-}
-//#endregion
-export { sanitizeCodexHistoryImagePayloads as n, sanitizeInlineImageDataUrl$1 as r, invalidInlineImageText as t };

package/dist/.setup/inference-proxy-CC15HuSi.mjs

@@ -1,311 +0,0 @@
-import { m as isJsonObject } from "./config-security-BRQ2mgW9.mjs";
-import { n as createCodexInferenceContext } from "./inference-context-fulhZuz8.mjs";
-import { promisify } from "node:util";
-import { zstdCompress, zstdDecompress } from "node:zlib";
-import { Writable } from "node:stream";
-import { WebSocket, WebSocketServer } from "openclaw/plugin-sdk/websocket-runtime";
-import { createServer } from "node:http";
-import { createNodeProxyAgent } from "openclaw/plugin-sdk/fetch-runtime";
-import { generateSecureToken } from "openclaw/plugin-sdk/secure-random-runtime";
-import { fetchWithSsrFGuard, isBlockedHostnameOrIp, resolvePinnedHostnameWithPolicy } from "openclaw/plugin-sdk/ssrf-runtime";
-//#region extensions/codex/src/app-server/inference-proxy.ts
-const MAX_BODY_BYTES = 33554432;
-const MAX_ERROR_BODY_BYTES = 1048576;
-const MAX_CONNECTIONS = 16;
-const compress = promisify(zstdCompress);
-const decompress = promisify(zstdDecompress);
-const HOP_HEADERS = /* @__PURE__ */ new Set([
-	"connection",
-	"keep-alive",
-	"proxy-authenticate",
-	"proxy-authorization",
-	"te",
-	"trailer",
-	"transfer-encoding",
-	"upgrade",
-	"host",
-	"content-length"
-]);
-const FAILURE = "Codex parent-local inference transport failed; retry on a fresh connection.";
-/** Private, fixed-destination relay. No upstream credentials or model content are retained. */
-async function createCodexInferenceProxy(params) {
-	const upstream = new URL(params.upstream);
-	if (upstream.protocol !== "https:" || upstream.username || upstream.password || upstream.hash) throw new Error("Codex inference requires a credential-free HTTPS upstream URL");
-	const lifetime = new AbortController();
-	const assertCurrent = () => {
-		lifetime.signal.throwIfAborted();
-		params.assertCurrent();
-	};
-	const context = createCodexInferenceContext(assertCurrent);
-	const pathPrefix = "/" + generateSecureToken({
-		bytes: 32,
-		redact: true
-	}) + upstream.pathname.replace(/\/$/, "");
-	const active = /* @__PURE__ */ new Set();
-	const sockets = /* @__PURE__ */ new Set();
-	const wss = new WebSocketServer({
-		noServer: true,
-		maxPayload: MAX_BODY_BYTES,
-		perMessageDeflate: false
-	});
-	const handshakeHeaders = /* @__PURE__ */ new WeakMap();
-	wss.on("headers", (headers, request) => {
-		for (const [key, value] of Object.entries(handshakeHeaders.get(request) ?? {})) if (!key.startsWith("sec-websocket-")) headers.push(key + ": " + value);
-		handshakeHeaders.delete(request);
-	});
-	const resolveTarget = (request) => {
-		assertCurrent();
-		if (request.headers.origin || !request.url?.startsWith(pathPrefix + "/") || isBlockedHostnameOrIp(upstream.hostname)) throw new Error(FAILURE);
-		const suffix = request.url.slice(pathPrefix.length);
-		if (suffix.startsWith("//") || suffix.includes("\\") || /%2e|%2f|%5c|(?:^|\/)\.\.?(?:\/|\?|$)/i.test(suffix)) throw new Error(FAILURE);
-		const target = new URL(upstream);
-		const incoming = new URL(suffix, "http://localhost");
-		target.pathname = upstream.pathname.replace(/\/$/, "") + incoming.pathname;
-		for (const [key, value] of incoming.searchParams) target.searchParams.append(key, value);
-		return {
-			target,
-			sampling: incoming.pathname === "/responses"
-		};
-	};
-	const prepare = (bytes, sampling) => {
-		assertCurrent();
-		if (!sampling) return {
-			bytes,
-			assertCurrent,
-			signal: void 0
-		};
-		const value = JSON.parse(bytes.toString("utf8"));
-		if (!isJsonObject(value)) throw new Error(FAILURE);
-		const prepared = context.prepare(value);
-		const rewritten = Buffer.from(JSON.stringify(prepared.body));
-		if (rewritten.length > MAX_BODY_BYTES) throw new Error(FAILURE);
-		return {
-			...prepared,
-			bytes: rewritten
-		};
-	};
-	const server = createServer((req, res) => {
-		const controller = new AbortController();
-		let guarded;
-		const abort = () => controller.abort();
-		req.once("aborted", abort);
-		res.once("close", abort);
-		(async () => {
-			try {
-				const { target, sampling } = resolveTarget(req);
-				if (req.method !== "POST" || active.size >= MAX_CONNECTIONS) throw new Error(FAILURE);
-				active.add(controller);
-				const wire = await readProxyBody(req, MAX_BODY_BYTES);
-				const encoding = req.headers["content-encoding"];
-				if (encoding && encoding !== "identity" && encoding !== "zstd") throw new Error(FAILURE);
-				const decoded = encoding === "zstd" ? await decompress(wire, { maxOutputLength: MAX_BODY_BYTES }) : wire;
-				assertCurrent();
-				const prepared = prepare(decoded, sampling);
-				const body = Buffer.from(encoding === "zstd" ? await compress(prepared.bytes) : prepared.bytes);
-				prepared.assertCurrent();
-				const signal = AbortSignal.any([
-					lifetime.signal,
-					controller.signal,
-					...prepared.signal ? [prepared.signal] : []
-				]);
-				guarded = await fetchWithSsrFGuard({
-					url: target.toString(),
-					init: {
-						method: "POST",
-						headers: relayHeaders(req.headers),
-						body,
-						signal
-					},
-					signal,
-					beforeRequest: prepared.assertCurrent,
-					requireHttps: true,
-					maxRedirects: 0,
-					capture: false,
-					mode: "trusted_env_proxy",
-					auditContext: "codex-parent-local-inference"
-				});
-				prepared.assertCurrent();
-				const headers = Object.fromEntries(guarded.response.headers);
-				delete headers["content-encoding"];
-				res.writeHead(guarded.response.status, relayHeaders(headers));
-				if (!guarded.response.body) res.end();
-				else await guarded.response.body.pipeTo(Writable.toWeb(res), { signal });
-			} catch {
-				if (!res.headersSent && !res.destroyed) res.writeHead(502, { "content-type": "text/plain" }).end(FAILURE);
-				else res.destroy();
-			} finally {
-				active.delete(controller);
-				req.off("aborted", abort);
-				res.off("close", abort);
-				await guarded?.release().catch(() => void 0);
-			}
-		})();
-	});
-	server.maxConnections = MAX_CONNECTIONS;
-	server.requestTimeout = 3e4;
-	server.headersTimeout = 1e4;
-	server.on("upgrade", (req, socket, head) => {
-		(async () => {
-			let remote;
-			let local;
-			let proxyAgent;
-			const controller = new AbortController();
-			const close = () => {
-				controller.abort();
-				active.delete(controller);
-				remote?.terminate();
-				local?.terminate();
-				proxyAgent?.destroy();
-				if (remote) sockets.delete(remote);
-				if (local) sockets.delete(local);
-				socket.destroy();
-			};
-			try {
-				const { target, sampling } = resolveTarget(req);
-				if (!sampling || active.size >= MAX_CONNECTIONS) throw new Error(FAILURE);
-				active.add(controller);
-				socket.once("close", close);
-				socket.once("error", close);
-				const signal = AbortSignal.any([lifetime.signal, controller.signal]);
-				proxyAgent = createNodeProxyAgent({
-					mode: "env",
-					targetUrl: target.href
-				});
-				const lookup = proxyAgent ? void 0 : (await resolvePinnedHostnameWithPolicy(target.hostname, { signal })).lookup;
-				assertCurrent();
-				signal.throwIfAborted();
-				target.protocol = "wss:";
-				const headers = relayHeaders(req.headers);
-				for (const key of Object.keys(headers)) if (key.startsWith("sec-websocket-")) delete headers[key];
-				remote = new WebSocket(target, {
-					headers,
-					...proxyAgent ? { agent: proxyAgent } : { lookup },
-					followRedirects: false,
-					perMessageDeflate: false,
-					maxPayload: MAX_BODY_BYTES,
-					handshakeTimeout: 1e4
-				});
-				sockets.add(remote);
-				remote.once("upgrade", (response) => {
-					handshakeHeaders.set(req, relayHeaders(response.headers));
-				});
-				remote.once("error", close);
-				remote.once("close", close);
-				remote.once("unexpected-response", (_request, response) => {
-					(async () => {
-						try {
-							const body = await readProxyBody(response, MAX_ERROR_BODY_BYTES);
-							assertCurrent();
-							signal.throwIfAborted();
-							const failureHeaders = Object.entries(relayHeaders(response.headers)).map(([key, value]) => key + ": " + value);
-							failureHeaders.push("Connection: close", "Content-Length: " + body.length);
-							const status = "HTTP/1.1 " + response.statusCode + " " + (response.statusMessage ?? "Upstream refused");
-							socket.end(Buffer.concat([Buffer.from(status + "\r\n" + failureHeaders.join("\r\n") + "\r\n\r\n"), body]), close);
-						} catch {
-							close();
-						}
-					})();
-				});
-				remote.once("open", () => {
-					try {
-						assertCurrent();
-						signal.throwIfAborted();
-						wss.handleUpgrade(req, socket, head, (accepted) => {
-							local = accepted;
-							sockets.add(accepted);
-							accepted.once("error", close);
-							accepted.once("close", close);
-							let releaseFrame = () => {};
-							accepted.on("message", (data, binary) => {
-								try {
-									if (binary) throw new Error(FAILURE);
-									const prepared = prepare(rawBytes(data), true);
-									prepared.assertCurrent();
-									releaseFrame();
-									const onAbort = () => close();
-									prepared.signal?.addEventListener("abort", onAbort, { once: true });
-									releaseFrame = () => prepared.signal?.removeEventListener("abort", onAbort);
-									if (!remote || remote.readyState !== WebSocket.OPEN || remote.bufferedAmount + prepared.bytes.length > MAX_BODY_BYTES) throw new Error(FAILURE);
-									remote.send(prepared.bytes, { binary: false }, (error) => {
-										if (error) close();
-									});
-								} catch {
-									close();
-								}
-							});
-							accepted.once("close", () => releaseFrame());
-							remote.on("message", (data, binary) => {
-								if (accepted.readyState !== WebSocket.OPEN || accepted.bufferedAmount + rawBytes(data).length > MAX_BODY_BYTES) {
-									close();
-									return;
-								}
-								accepted.send(data, { binary }, (error) => {
-									if (error) close();
-								});
-							});
-						});
-					} catch {
-						close();
-					}
-				});
-			} catch {
-				close();
-			}
-		})();
-	});
-	const close = () => {
-		lifetime.abort();
-		context.close();
-		for (const controller of active) controller.abort();
-		for (const socket of sockets) socket.terminate();
-		server.close();
-		server.closeAllConnections();
-		wss.close();
-	};
-	try {
-		await new Promise((resolve, reject) => {
-			server.once("error", reject);
-			server.listen(0, "127.0.0.1", () => {
-				server.off("error", reject);
-				resolve();
-			});
-		});
-		assertCurrent();
-		server.on("error", close);
-		const address = server.address();
-		if (!address || typeof address === "string") throw new Error(FAILURE);
-		return {
-			context,
-			upstream: upstream.toString(),
-			baseUrl: "http://127.0.0.1:" + address.port + pathPrefix,
-			assertCurrent,
-			close
-		};
-	} catch (error) {
-		close();
-		throw error;
-	}
-}
-async function readProxyBody(stream, maxBytes) {
-	const chunks = [];
-	let size = 0;
-	for await (const chunk of stream) {
-		const bytes = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
-		size += bytes.length;
-		if (size > maxBytes) throw new Error(FAILURE);
-		chunks.push(bytes);
-	}
-	return Buffer.concat(chunks);
-}
-function rawBytes(data) {
-	return Array.isArray(data) ? Buffer.concat(data) : Buffer.isBuffer(data) ? data : Buffer.from(data);
-}
-function relayHeaders(input) {
-	const excluded = new Set(HOP_HEADERS);
-	for (const token of (input.connection ?? "").split(",")) excluded.add(token.trim().toLowerCase());
-	const output = {};
-	for (const [key, value] of Object.entries(input)) if (value !== void 0 && !excluded.has(key.toLowerCase())) output[key.toLowerCase()] = Array.isArray(value) ? value.join(", ") : value;
-	return output;
-}
-//#endregion
-export { createCodexInferenceProxy };

package/dist/.setup/launch-args-DnMak49W.mjs

@@ -1,111 +0,0 @@
-//#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;
-}
-/** Uses the native CLI configuration for status without starting its transport. */
-function buildCodexLoginStatusArgs(args) {
-	const options = /* @__PURE__ */ new Set([
-		"-c",
-		"--config",
-		"-p",
-		"--profile",
-		"--enable",
-		"--disable"
-	]);
-	const tokens = readCodexArgs(args);
-	const subcommandIndex = tokens.findLast(({ name }) => name === "app-server")?.index ?? -1;
-	const prefix = subcommandIndex < 0 ? [] : args.slice(0, subcommandIndex);
-	const configArgs = tokens.filter(({ index, name }) => index > subcommandIndex && options.has(name)).flatMap(({ index, end }) => args.slice(index, end));
-	return [
-		...prefix,
-		...configArgs,
-		"login",
-		"status"
-	];
-}
-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 { readCodexAppServerConfigOptions as i, isCodexAppServerProxyLaunch as n, normalizeCodexAppServerArgs as r, buildCodexLoginStatusArgs as t };

package/dist/.setup/local-runtime-attribution-B_2mnqhb.mjs

@@ -1,19 +0,0 @@
-import { normalizeLowercaseStringOrEmpty } from "openclaw/plugin-sdk/string-coerce-runtime";
-//#region extensions/codex/src/app-server/local-runtime-attribution.ts
-const OPENAI_PROVIDER_ID = "openai";
-const OPENAI_RESPONSES_API = "openai-responses";
-const OPENAI_CODEX_RESPONSES_API = "openai-chatgpt-responses";
-/** Maps local Codex runtime plans onto the provider/api pair exposed to event projection. */
-function resolveCodexLocalRuntimeAttribution(params) {
-	const authProfileProvider = normalizeLowercaseStringOrEmpty(params.runtimePlan?.auth?.authProfileProviderForAuth);
-	if (normalizeLowercaseStringOrEmpty(params.runtimePlan?.observability.harnessId) === "codex" && authProfileProvider !== OPENAI_PROVIDER_ID && normalizeLowercaseStringOrEmpty(params.model.provider) === OPENAI_PROVIDER_ID && normalizeLowercaseStringOrEmpty(params.model.api) === OPENAI_RESPONSES_API) return {
-		provider: OPENAI_PROVIDER_ID,
-		api: OPENAI_CODEX_RESPONSES_API
-	};
-	return {
-		provider: params.provider,
-		api: params.model.api
-	};
-}
-//#endregion
-export { resolveCodexLocalRuntimeAttribution as t };

package/dist/.setup/native-subagent-history-YXaL6dMd.mjs

@@ -1,135 +0,0 @@
-import { S as readCodexNativeSubagentHistoryOwner, p as sessionBindingIdentity, y as codexNativeSubagentHistoryConnectionFingerprint } from "./session-binding-record-TH3xA0zj.mjs";
-import { t as readCodexThreadHistoryPage } from "./thread-history-page-BTx-4xsg.mjs";
-import { r as readMirrorIdentity } from "./upstream-prompt-provenance-LphB8slG.mjs";
-import { r as projectCodexThreadHistoryItem } from "./transcript-history-projection-DHNBDhCU.mjs";
-import { n as buildCodexAppServerRuntimeFingerprint, t as buildCodexAppServerConnectionFingerprint } from "./plugin-app-cache-key-BOxKP7db.mjs";
-import { i as resolveCodexBindingAppServerConnection } from "./binding-connection-Bm38niE8.mjs";
-import { c as getLeasedSharedCodexAppServerClient, h as releaseLeasedSharedCodexAppServerClient } from "./shared-client-BpTtuLQ5.mjs";
-import { a as readCodexNativeSubagentRunId, f as itemToolArgs, h as itemTranscriptResultText } from "./native-subagent-task-ids-DsuOonKv.mjs";
-import { resolveAgentDir } from "openclaw/plugin-sdk/agent-runtime";
-import { getSessionEntry, resolveStorePath } from "openclaw/plugin-sdk/session-store-runtime";
-//#region extensions/codex/src/app-server/native-subagent-history.ts
-const MAX_SUBAGENT_ANCESTRY_READS = 32;
-const taskHistoryToolItems = {
-	itemToolArgs,
-	itemTranscriptResultText
-};
-function parentThreadId(thread) {
-	const source = thread.source;
-	const spawn = source && typeof source === "object" && "subAgent" in source && typeof source.subAgent === "object" && "thread_spawn" in source.subAgent ? source.subAgent.thread_spawn : void 0;
-	return thread.parentThreadId?.trim() ?? spawn?.parent_thread_id.trim();
-}
-/** Resolves history from the parent binding's native store without adopting the child. */
-async function readCodexNativeSubagentHistory(params, options) {
-	params.assertCurrent();
-	const { task, cfg } = params;
-	const sessionKey = task.requesterSessionKey;
-	const agentId = task.agentId;
-	const threadId = readCodexNativeSubagentRunId(task.runId)?.threadId;
-	if (task.taskKind !== "codex-native" || !sessionKey || !agentId || !threadId) throw new Error("Subagent transcript owner is unavailable.");
-	const storePath = resolveStorePath(cfg.session?.store, { agentId });
-	const readSession = () => getSessionEntry({
-		agentId,
-		sessionKey,
-		storePath,
-		hydrateSkillPromptRefs: false,
-		readConsistency: "latest"
-	});
-	const session = readSession();
-	if (!session?.sessionId) throw new Error("Subagent parent session is unavailable.");
-	const sessionId = session.sessionId;
-	const lifecycleRevision = session.lifecycleRevision;
-	const historyOwner = readCodexNativeSubagentHistoryOwner(task.detail);
-	if (historyOwner && (historyOwner.lifecycleRevision ? historyOwner.lifecycleRevision !== lifecycleRevision : historyOwner.sessionId !== sessionId)) throw new Error("Subagent history owner changed; reconnect its parent session.");
-	const identity = sessionBindingIdentity({
-		agentId,
-		sessionId,
-		sessionKey,
-		config: cfg
-	});
-	const binding = options.bindingStore.read(identity);
-	if (!binding || binding.pendingSupervisionBranch) throw new Error("Subagent parent thread is unavailable.");
-	if (historyOwner && historyOwner.connectionFingerprint !== codexNativeSubagentHistoryConnectionFingerprint(binding)) throw new Error("Subagent history owner changed; reconnect its parent session.");
-	const historyParentThreadId = historyOwner?.parentThreadId ?? binding.threadId;
-	const assertCurrent = () => {
-		params.assertCurrent();
-		const currentSession = readSession();
-		const current = options.bindingStore.read(identity);
-		if (currentSession?.sessionId !== sessionId || currentSession?.lifecycleRevision !== lifecycleRevision || current?.threadId !== binding.threadId || current?.appServerRuntimeFingerprint !== binding.appServerRuntimeFingerprint || current?.connectionScope !== binding.connectionScope || current?.authProfileId !== binding.authProfileId) throw new Error("Subagent parent changed; refresh its transcript.");
-	};
-	const agentDir = resolveAgentDir(cfg, agentId);
-	const connection = await resolveCodexBindingAppServerConnection({
-		binding,
-		pluginConfig: options.pluginConfig,
-		agentDir,
-		config: cfg,
-		assertCurrent,
-		authProfileId: binding.authProfileId
-	});
-	const client = await getLeasedSharedCodexAppServerClient({
-		startOptions: connection.appServer.start,
-		timeoutMs: connection.appServer.requestTimeoutMs,
-		authProfileId: connection.clientAuthProfileId,
-		agentDir,
-		config: cfg,
-		assertCurrent
-	});
-	try {
-		assertCurrent();
-		const fingerprint = binding.connectionScope === "supervision" ? buildCodexAppServerConnectionFingerprint(connection.appServer, agentDir) : buildCodexAppServerRuntimeFingerprint({
-			appServer: connection.appServer,
-			appServerVersion: client.getServerVersion(),
-			runtimeIdentity: client.getRuntimeIdentity()
-		});
-		if (!binding.appServerRuntimeFingerprint || fingerprint !== binding.appServerRuntimeFingerprint) throw new Error("Subagent connection changed; reconnect its parent session.");
-		const read = async (method, request) => {
-			assertCurrent();
-			const result = await client.request(method, request, { assertCurrent });
-			assertCurrent();
-			return result;
-		};
-		const { thread } = await read("thread/read", {
-			threadId,
-			includeTurns: false
-		});
-		if (thread.id !== threadId || threadId === historyParentThreadId) throw new Error("Subagent transcript does not belong to this parent session.");
-		const visited = /* @__PURE__ */ new Set([threadId]);
-		let ancestor = thread;
-		for (;;) {
-			const parentId = parentThreadId(ancestor);
-			if (parentId === historyParentThreadId) break;
-			if (!parentId || visited.has(parentId) || visited.size >= MAX_SUBAGENT_ANCESTRY_READS) throw new Error("Subagent transcript does not belong to this parent session.");
-			visited.add(parentId);
-			const response = await read("thread/read", {
-				threadId: parentId,
-				includeTurns: false
-			});
-			if (response.thread.id !== parentId) throw new Error("Subagent transcript does not belong to this parent session.");
-			ancestor = response.thread;
-		}
-		const page = await readCodexThreadHistoryPage({
-			listItemPage: (request) => read("thread/items/list", request),
-			listTurnPage: (request) => read("thread/turns/list", request)
-		}, thread, {
-			threadId,
-			cursor: params.cursor,
-			limit: Math.max(1, Math.floor(Math.min(params.limit, 200) / 2))
-		}, {
-			project: (entries) => entries.map((entry) => projectCodexThreadHistoryItem(thread, entry, taskHistoryToolItems).map((message) => {
-				const messageIdentity = readMirrorIdentity(message);
-				if (!messageIdentity) throw new Error("Subagent history message is missing its native identity.");
-				return Object.assign(message, { messageId: JSON.stringify([threadId, messageIdentity]) });
-			})),
-			fits: (result) => Buffer.byteLength(JSON.stringify(result), "utf8") <= 524288
-		});
-		assertCurrent();
-		return {
-			messages: page.items.toReversed().flat(),
-			...page.nextCursor ? { nextCursor: page.nextCursor } : {}
-		};
-	} finally {
-		releaseLeasedSharedCodexAppServerClient(client);
-	}
-}
-//#endregion
-export { readCodexNativeSubagentHistory };