dsh-codex-subscription 2.1.0 → 2.1.1-beta.1

package/lib/index.js

@@ -1,18 +1,20 @@
-import { clientRequestSchema } from "@deepseek-ai/dsh-client-connection";
 import { createHash, randomBytes, randomUUID } from "node:crypto";
-import { defineTool } from "@deepseek-ai/dsh-tools";
+import { closeOpenAICodexWebSocketSessions, resetOpenAICodexWebSocketDebugStats } from "@earendil-works/pi-ai/api/openai-codex-responses";
+import { execFile, spawn } from "node:child_process";
+import { request } from "node:https";
+import { AsyncLocalStorage } from "node:async_hooks";
+import { PassThrough, Readable } from "node:stream";
+import { promisify } from "node:util";
+import { HttpsProxyAgent } from "https-proxy-agent";
+import WebSocket from "ws";
+import { clientRequestSchema } from "@deepseek-ai/dsh-client-connection";
 import { lstat, mkdir, open, readFile, rename, rm, stat } from "node:fs/promises";
+import { defineTool } from "@deepseek-ai/dsh-tools";
 import * as dshCredentials from "@deepseek-ai/dsh-credentials";
 import { dshHomePath, resolveDshHome } from "@deepseek-ai/dsh-home-paths";
 import { LlmError, createUserMessage } from "@deepseek-ai/dsh-llm";
 import { PiAiAdapter } from "@deepseek-ai/dsh-llm-pi-ai";
 import z from "@deepseek-ai/schemastery";
-import { execFile, spawn } from "node:child_process";
-import { request } from "node:https";
-import { AsyncLocalStorage } from "node:async_hooks";
-import { Readable } from "node:stream";
-import { promisify } from "node:util";
-import { HttpsProxyAgent } from "https-proxy-agent";
 import { openaiCodexProvider as createOpenAICodexProvider } from "@earendil-works/pi-ai/providers/openai-codex";
 import { createModels } from "@earendil-works/pi-ai";
 import { WebError } from "@deepseek-ai/dsh-web";
@@ -286,6 +288,16 @@ const supportsCodexFastMode = (modelId) => typeof modelId === "string" && (/^gpt
 //#endregion
 //#region src/preference-fields.js
 const PREFERENCE_FIELDS = Object.freeze({
+	connectionMode: {
+		choices: ["sse", "websocket"],
+		default: "sse",
+		error: "Invalid connection mode"
+	},
+	subagentBackend: {
+		choices: ["dsh", "codex"],
+		default: "dsh",
+		error: "Invalid subagent backend"
+	},
 	[QUICK_QUOTA_MODE_FIELD]: {
 		choices: [
 			"off",
@@ -330,1572 +342,1945 @@ const PREFERENCE_FIELDS = Object.freeze({
 	}
 });
 //#endregion
-//#region src/rpc-contract.js
-const RPC_ENDPOINTS = Object.freeze([
-	"status",
-	"login/start",
-	"login/status",
-	"login/submit",
-	"login/cancel",
-	"logout",
-	"account/select",
-	"account/remove",
-	"usage",
-	"diagnostics",
-	"preferences/status",
-	"preferences/models",
-	"preferences/update",
-	"reset-credit/inspect",
-	"reset-credit/prepare",
-	"reset-credit/consume",
-	"image/original/chunk",
-	"sketch/connect",
-	"sketch/poll",
-	"sketch/claim",
-	"sketch/result",
-	"sketch/disconnect"
-]);
-//#endregion
-//#region src/subscription-transport.js
-/** Exact routes stay inside DSH's authenticated /api bridge and body limit. */
-function registerSubscriptionTransport(connection, handler) {
-	const disposers = [];
+//#region src/oauth-network.js
+const execFileAsync = promisify(execFile);
+const CODEX_AUTH_HOST = "auth.openai.com";
+const CODEX_SUBSCRIPTION_HOST = "chatgpt.com";
+const CODEX_HOSTS = /* @__PURE__ */ new Set([CODEX_AUTH_HOST, CODEX_SUBSCRIPTION_HOST]);
+const networkScope = new AsyncLocalStorage();
+let activeScopes = 0;
+let baseFetch;
+let scopedFetch;
+let baseWebSocket;
+let scopedWebSocket;
+let activeWebSocketScopes = 0;
+function normalizeProxy(raw) {
+	if (typeof raw !== "string" || raw.trim() === "") return void 0;
+	const value = raw.trim().includes("://") ? raw.trim() : `http://${raw.trim()}`;
 	try {
-		for (const endpoint of RPC_ENDPOINTS) {
-			const method = `codex-subscription/${endpoint}`;
-			disposers.push(connection.fetch.register({
-				path: `/api/${method}`,
-				methods: ["POST"],
-				requestBody: "buffered",
-				async fetch(request) {
-					if (request.headers.get("content-type")?.split(";", 1)[0]?.trim().toLowerCase() !== "application/json") return new Response("content type must be application/json", { status: 415 });
-					let body;
-					try {
-						body = await request.json();
-					} catch {
-						return new Response("invalid JSON", { status: 400 });
-					}
-					const envelope = clientRequestSchema.safeParse(body);
-					if (!envelope.success || envelope.data.method !== method) return new Response("invalid RPC envelope", { status: 400 });
-					let result;
-					try {
-						request.signal.throwIfAborted();
-						result = await handler(endpoint, envelope.data.payload, request.signal);
-					} catch {
-						result = {
-							ok: false,
-							error: {
-								code: "internal",
-								message: "Subscription request failed",
-								details: { issues: [] }
-							}
-						};
-					}
-					return Response.json({
-						type: "server-response",
-						rpcId: envelope.data.rpcId,
-						result
-					});
-				}
-			}));
-		}
-	} catch (error) {
-		for (const dispose of disposers.reverse()) dispose();
-		throw error;
+		const url = new URL(value);
+		if (!["http:", "https:"].includes(url.protocol) || url.hostname === "") return void 0;
+		return url.toString();
+	} catch {
+		return;
 	}
-	return () => {
-		for (const dispose of disposers.reverse()) dispose();
-	};
 }
-//#endregion
-//#region src/sketch-agent-bridge.js
-function createSketchAgentBridge({ enabled, now = Date.now, timeoutMs = 2e4 }) {
-	const sessions = /* @__PURE__ */ new Map();
-	const fail = (entry, message) => {
-		for (const task of entry.tasks.values()) task.reject(Error(message));
-		entry.tasks.clear();
+function bypassesProxy(hostname, port, rawNoProxy) {
+	if (typeof rawNoProxy !== "string" || rawNoProxy.trim() === "") return false;
+	return rawNoProxy.split(/[\s,]+/u).some((raw) => {
+		const entry = raw.trim().toLowerCase();
+		if (entry === "*") return true;
+		if (entry === "") return false;
+		const match = /^(.*?)(?::(\d+))?$/u.exec(entry);
+		const host = match?.[1]?.replace(/^\./u, "");
+		const entryPort = match?.[2];
+		if (!host || entryPort && entryPort !== port) return false;
+		return hostname === host || hostname.endsWith(`.${host}`);
+	});
+}
+function proxyFromEnvironment(env = process.env, target = new URL(`https://${CODEX_AUTH_HOST}/`)) {
+	if (bypassesProxy(target.hostname.toLowerCase(), target.port || "443", env.NO_PROXY ?? env.no_proxy)) return void 0;
+	return normalizeProxy(env.HTTPS_PROXY ?? env.https_proxy ?? env.ALL_PROXY ?? env.all_proxy);
+}
+function selectWindowsProxy(value) {
+	if (typeof value !== "string") return void 0;
+	const entries = value.split(";").map((item) => item.trim()).filter(Boolean);
+	const https = entries.find((item) => /^https=/iu.test(item));
+	const http = entries.find((item) => /^http=/iu.test(item));
+	const selected = (https ?? http ?? entries.find((item) => !item.includes("=")))?.replace(/^[^=]+=/u, "");
+	return normalizeProxy(selected);
+}
+async function windowsSystemProxy(options = {}) {
+	const run = options.execFile ?? execFileAsync;
+	const reg = `${process.env.SystemRoot ?? "C:\\Windows"}\\System32\\reg.exe`;
+	const key = "HKCU\\Software\\Microsoft\\Windows\\CurrentVersion\\Internet Settings";
+	try {
+		const enabled = await run(reg, [
+			"query",
+			key,
+			"/v",
+			"ProxyEnable"
+		], {
+			windowsHide: true,
+			encoding: "utf8"
+		});
+		if (!/REG_DWORD\s+0x1\b/iu.test(enabled.stdout)) return void 0;
+		const configured = await run(reg, [
+			"query",
+			key,
+			"/v",
+			"ProxyServer"
+		], {
+			windowsHide: true,
+			encoding: "utf8"
+		});
+		return selectWindowsProxy(/^\s*ProxyServer\s+REG_\w+\s+(.+)$/imu.exec(configured.stdout)?.[1]);
+	} catch {
+		return;
+	}
+}
+async function macSystemProxy(options = {}) {
+	const run = options.execFile ?? execFileAsync;
+	try {
+		const result = await run("/usr/sbin/scutil", ["--proxy"], { encoding: "utf8" });
+		if (!/^\s*HTTPSEnable\s*:\s*1\s*$/imu.test(result.stdout)) return void 0;
+		const host = /^\s*HTTPSProxy\s*:\s*(\S+)\s*$/imu.exec(result.stdout)?.[1];
+		const port = /^\s*HTTPSPort\s*:\s*(\d+)\s*$/imu.exec(result.stdout)?.[1];
+		return normalizeProxy(host && port ? `${host}:${port}` : void 0);
+	} catch {
+		return;
+	}
+}
+async function resolveCodexOAuthProxy(options = {}) {
+	return (await resolveCodexProxy(options)).url;
+}
+async function resolveCodexProxy(options = {}) {
+	const target = options.target ?? new URL(`https://${CODEX_AUTH_HOST}/`);
+	const env = options.env ?? process.env;
+	if (bypassesProxy(target.hostname.toLowerCase(), target.port || "443", env.NO_PROXY ?? env.no_proxy)) return {
+		url: void 0,
+		source: "bypass"
 	};
-	const find = (payload) => {
-		const entry = sessions.get(payload.sessionId);
-		if (!entry || entry.token !== payload.token || now() - entry.seen > 1e4) throw Error("Sketch connection expired");
-		entry.seen = now();
-		return entry;
+	const envProxy = proxyFromEnvironment(env, target);
+	if (envProxy) return {
+		url: envProxy,
+		source: "environment"
 	};
-	return {
-		async rpc(endpoint, payload) {
-			try {
-				if (!enabled()) throw Error("Sketch is disabled");
-				if (!payload || typeof payload.sessionId !== "string" || !payload.sessionId.length || payload.sessionId.length > 200) throw Error("Invalid session");
-				if (endpoint === "sketch/connect") {
-					for (const [id, entry] of sessions) if (now() - entry.seen >= 1e4) {
-						fail(entry, "Sketch connection expired");
-						sessions.delete(id);
-					}
-					const previous = sessions.get(payload.sessionId);
-					if (previous && now() - previous.seen < 1e4) throw Error("Another board is connected to this session");
-					if (previous) fail(previous, "Sketch connection replaced");
-					const entry = {
-						token: randomUUID(),
-						seen: now(),
-						tasks: /* @__PURE__ */ new Map(),
-						cancelled: []
-					};
-					sessions.set(payload.sessionId, entry);
-					return {
-						ok: true,
-						value: { token: entry.token }
-					};
-				}
-				const entry = find(payload);
-				if (endpoint === "sketch/poll") return {
-					ok: true,
-					value: [...entry.cancelled.splice(0).map((id) => ({
-						id,
-						cancelled: true
-					})), ...[...entry.tasks].filter(([, t]) => !t.delivered).map(([id, t]) => {
-						t.delivered = true;
-						return {
-							id,
-							request: t.request,
-							expiresAt: t.expiresAt
-						};
-					})]
-				};
-				if (endpoint === "sketch/claim") {
-					const task = entry.tasks.get(payload.id);
-					return {
-						ok: true,
-						value: Boolean(task && task.delivered && task.expiresAt > now())
-					};
-				}
-				if (endpoint === "sketch/disconnect") {
-					fail(entry, "Sketch board closed");
-					sessions.delete(payload.sessionId);
-					return {
-						ok: true,
-						value: null
-					};
-				}
-				if (endpoint === "sketch/result") {
-					const task = entry.tasks.get(payload.id);
-					if (task) {
-						entry.tasks.delete(payload.id);
-						payload.error ? task.reject(Error(String(payload.error).slice(0, 500))) : task.resolve(payload.value);
-					}
-					return {
-						ok: true,
-						value: null
-					};
-				}
-				throw Error("Unknown sketch route");
-			} catch (error) {
-				return {
-					ok: false,
-					error: {
-						code: "invalid-input",
-						message: error.message,
-						details: { issues: [] }
-					}
-				};
-			}
-		},
-		request(sessionId, request, signal) {
-			if (!enabled()) return Promise.reject(Error("Sketch is disabled"));
-			const entry = sessions.get(sessionId);
-			if (!entry || now() - entry.seen > 1e4) return Promise.reject(Error("Switch to this session in DSH with sketch editing enabled"));
-			if (entry.tasks.size) return Promise.reject(Error("Another sketch operation is pending"));
-			if (JSON.stringify(request).length > 2e6) return Promise.reject(Error("Sketch batch is too large"));
-			return new Promise((resolve, reject) => {
-				const id = randomUUID();
-				const finish = (callback, value) => {
-					clearTimeout(timer);
-					signal?.removeEventListener("abort", abort);
-					entry.tasks.delete(id);
-					callback(value);
-				};
-				const cancel = (message) => {
-					if (entry.tasks.get(id)?.delivered) {
-						entry.cancelled.push(id);
-						if (entry.cancelled.length > 32) entry.cancelled.shift();
-					}
-					finish(reject, Error(message));
-				};
-				const abort = () => cancel("Sketch operation interrupted; inspect recentRequests before retrying");
-				const timer = setTimeout(() => cancel("Sketch response timed out; inspect recentRequests before retrying"), timeoutMs);
-				entry.tasks.set(id, {
-					request,
-					expiresAt: now() + timeoutMs,
-					delivered: false,
-					resolve: (value) => finish(resolve, value),
-					reject: (error) => finish(reject, error)
+	const platform = options.platform ?? process.platform;
+	const system = platform === "win32" ? await windowsSystemProxy(options) : platform === "darwin" ? await macSystemProxy(options) : void 0;
+	return system ? {
+		url: system,
+		source: "system"
+	} : {
+		url: void 0,
+		source: "direct"
+	};
+}
+function bodyBytes(body) {
+	if (body === void 0 || body === null) return void 0;
+	if (typeof body === "string") return Buffer.from(body);
+	if (body instanceof URLSearchParams) return Buffer.from(body.toString());
+	if (body instanceof Uint8Array) return Buffer.from(body);
+	throw new TypeError("Unsupported Codex OAuth request body");
+}
+function fetchThroughProxy(input, init, proxyUrl) {
+	const target = new URL(typeof input === "string" || input instanceof URL ? input : input.url);
+	const body = bodyBytes(init?.body);
+	const headers = new Headers(init?.headers);
+	if (body && !headers.has("content-length")) headers.set("content-length", String(body.byteLength));
+	return new Promise((resolve, reject) => {
+		const request$1 = request(target, {
+			method: init?.method ?? "GET",
+			headers: Object.fromEntries(headers.entries()),
+			agent: new HttpsProxyAgent(proxyUrl),
+			signal: init?.signal
+		}, (response) => {
+			const responseHeaders = new Headers();
+			for (const [name, value] of Object.entries(response.headers)) if (Array.isArray(value)) value.forEach((item) => responseHeaders.append(name, item));
+			else if (value !== void 0) responseHeaders.set(name, value);
+			const status = response.statusCode ?? 500;
+			const empty = init?.method === "HEAD" || [
+				204,
+				205,
+				304
+			].includes(status);
+			resolve(new Response(empty ? null : Readable.toWeb(response), {
+				status,
+				statusText: response.statusMessage,
+				headers: responseHeaders
+			}));
+		});
+		request$1.on("error", reject);
+		if (body) request$1.write(body);
+		request$1.end();
+	});
+}
+async function withCodexNetwork(run, options = {}) {
+	if (options.websocket && activeWebSocketScopes === 0) {
+		baseWebSocket = globalThis.WebSocket;
+		scopedWebSocket = new Proxy(baseWebSocket ?? WebSocket, { construct(target, args, newTarget) {
+			const scope = networkScope.getStore();
+			const url = new URL(String(args[0]));
+			if (!scope?.options.websocket || url.protocol !== "wss:" || url.hostname !== CODEX_SUBSCRIPTION_HOST) return Reflect.construct(target, args, newTarget);
+			const proxy = scope.options.websocketProxy;
+			return new WebSocket(args[0], {
+				...args[1],
+				...proxy ? { agent: new HttpsProxyAgent(proxy) } : {}
+			});
+		} });
+		globalThis.WebSocket = scopedWebSocket;
+	}
+	if (options.websocket) activeWebSocketScopes += 1;
+	if (activeScopes === 0) {
+		baseFetch = globalThis.fetch;
+		scopedFetch = async (input, init) => {
+			const scope = networkScope.getStore();
+			if (scope === void 0) return baseFetch(input, init);
+			const { options: scopedOptions, allowedHosts, resolved } = scope;
+			const proxyFetch = scopedOptions.fetchThroughProxy ?? fetchThroughProxy;
+			const target = new URL(typeof input === "string" || input instanceof URL ? input : input.url);
+			if (target.protocol !== "https:" || !allowedHosts.has(target.hostname)) return baseFetch(input, init);
+			let proxy = resolved.get(target.hostname);
+			if (proxy === void 0) {
+				proxy = resolveCodexProxy({
+					...scopedOptions,
+					target
 				});
-				signal?.addEventListener("abort", abort, { once: true });
-				if (signal?.aborted) abort();
+				resolved.set(target.hostname, proxy);
+			}
+			const route = await proxy;
+			scopedOptions.onRoute?.(route.source);
+			return route.url === void 0 ? baseFetch(input, init) : proxyFetch(input, init, route.url);
+		};
+		globalThis.fetch = scopedFetch;
+	}
+	activeScopes += 1;
+	const scope = {
+		options,
+		allowedHosts: options.hosts ?? CODEX_HOSTS,
+		resolved: /* @__PURE__ */ new Map()
+	};
+	try {
+		return await networkScope.run(scope, run);
+	} finally {
+		if (options.websocket && --activeWebSocketScopes === 0) {
+			if (globalThis.WebSocket === scopedWebSocket) globalThis.WebSocket = baseWebSocket;
+			baseWebSocket = void 0;
+			scopedWebSocket = void 0;
+		}
+		activeScopes -= 1;
+		if (activeScopes === 0) {
+			if (globalThis.fetch === scopedFetch) globalThis.fetch = baseFetch;
+			baseFetch = void 0;
+			scopedFetch = void 0;
+		}
+	}
+}
+function classifyTransportError(error) {
+	const name = error?.name;
+	const code = String(error?.code ?? error?.cause?.code ?? "");
+	if (name === "AbortError" || name === "TimeoutError" || /ETIMEDOUT|UND_ERR_CONNECT_TIMEOUT/u.test(code)) return "timeout";
+	if (/ENOTFOUND|EAI_AGAIN/u.test(code)) return "dns";
+	if (/CERT_|TLS|SSL/u.test(code)) return "tls";
+	if (/ECONN|EPIPE|UND_ERR_SOCKET/u.test(code)) return "connection";
+	return "network";
+}
+const elapsedBucket = (elapsed) => elapsed < 1e3 ? "under-1s" : elapsed < 5e3 ? "1-5s" : elapsed < 15e3 ? "5-15s" : "over-15s";
+function createCodexNetworkTransport(options = {}) {
+	const attempts = /* @__PURE__ */ new Map();
+	const now = options.now ?? Date.now;
+	const run = async (area, operation, connection = {}) => {
+		const startedAt = now();
+		let route = attempts.get(area)?.route ?? "direct";
+		let routed = false;
+		try {
+			const value = await withCodexNetwork(operation, {
+				...options,
+				...connection,
+				onRoute: (source) => {
+					route = source;
+					routed = true;
+				}
+			});
+			if (value instanceof Response && !value.ok) attempts.set(area, {
+				status: "failed",
+				stage: "http",
+				code: "http-error",
+				httpStatus: value.status,
+				route,
+				elapsed: elapsedBucket(now() - startedAt)
+			});
+			else if (routed || value instanceof Response) attempts.set(area, {
+				status: "ok",
+				route,
+				elapsed: elapsedBucket(now() - startedAt)
 			});
+			return value;
+		} catch (error) {
+			if (routed) attempts.set(area, {
+				status: "failed",
+				stage: "transport",
+				code: classifyTransportError(error),
+				route,
+				elapsed: elapsedBucket(now() - startedAt)
+			});
+			throw error;
+		}
+	};
+	return Object.freeze({
+		run,
+		fetch: (area, input, init) => run(area, () => globalThis.fetch(input, init)),
+		snapshot: () => Object.fromEntries([...attempts].map(([area, value]) => [area, { ...value }]))
+	});
+}
+//#endregion
+//#region src/subscription-connection.js
+function createSubscriptionConnection({ resolveMode = () => "sse", resolveProxy = resolveCodexOAuthProxy } = {}) {
+	const namespace = randomUUID();
+	const sessions = /* @__PURE__ */ new Set();
+	return {
+		async prepare(options = {}) {
+			if (resolveMode() !== "websocket") return { options: {
+				...options,
+				transport: "sse"
+			} };
+			const proxy = await resolveProxy({ target: new URL("https://chatgpt.com/") });
+			const sessionId = options.sessionId && `dsh-${createHash("sha256").update(JSON.stringify([
+				namespace,
+				options.sessionId,
+				options.apiKey,
+				proxy
+			])).digest("hex").slice(0, 56)}`;
+			if (sessionId) sessions.add(sessionId);
+			return {
+				options: {
+					...options,
+					sessionId,
+					transport: "websocket-cached",
+					websocketConnectTimeoutMs: 1e4,
+					env: {}
+				},
+				network: {
+					websocket: true,
+					websocketProxy: proxy
+				}
+			};
 		},
 		dispose() {
-			for (const entry of sessions.values()) fail(entry, "Sketch service stopped");
+			for (const session of sessions) {
+				closeOpenAICodexWebSocketSessions(session);
+				resetOpenAICodexWebSocketDebugStats(session);
+			}
 			sessions.clear();
 		}
 	};
 }
 //#endregion
-//#region src/sketch-command-schema.js
-const number = { type: "number" };
-const string = { type: "string" };
-const object = (properties) => ({
-	type: "object",
-	additionalProperties: false,
-	properties
-});
-const points = {
-	type: "array",
-	items: object({
-		x: {
-			...number,
-			required: true
-		},
-		y: {
-			...number,
-			required: true
-		}
-	})
-};
-const point = object({
-	x: {
-		...number,
-		required: true
-	},
-	y: {
-		...number,
-		required: true
-	}
-});
-const style = {
-	color: string,
-	width: number,
-	opacity: number,
-	fill: { type: "boolean" },
-	text: string,
-	points
-};
-const sketchCommandArray = {
-	type: "array",
-	items: object({
-		op: {
-			type: "string",
-			required: true,
-			enum: [
-				"stroke",
-				"object",
-				"layer",
-				"resize"
-			]
-		},
-		id: {
-			oneOf: [{ type: "string" }, { type: "integer" }],
-			description: "Object string ID. Layer add: optional NEW unique integer ID; other layer actions: existing layer ID."
-		},
-		after: {
-			type: "integer",
-			description: "Layer add only: existing layer to insert after; defaults to active."
-		},
-		start: point,
-		segments: {
-			type: "array",
-			items: object({
-				control1: {
-					...point,
-					required: true
-				},
-				control2: {
-					...point,
-					required: true
-				},
-				end: {
-					...point,
-					required: true
+//#region src/rpc-contract.js
+const RPC_ENDPOINTS = Object.freeze([
+	"status",
+	"login/start",
+	"login/status",
+	"login/submit",
+	"login/cancel",
+	"logout",
+	"account/select",
+	"account/remove",
+	"usage",
+	"diagnostics",
+	"preferences/status",
+	"preferences/models",
+	"preferences/update",
+	"reset-credit/inspect",
+	"reset-credit/prepare",
+	"reset-credit/consume",
+	"image/original/chunk",
+	"sketch/connect",
+	"sketch/poll",
+	"sketch/claim",
+	"sketch/result",
+	"sketch/disconnect"
+]);
+//#endregion
+//#region src/subscription-transport.js
+/** Exact routes stay inside DSH's authenticated /api bridge and body limit. */
+function registerSubscriptionTransport(connection, handler) {
+	const disposers = [];
+	try {
+		for (const endpoint of RPC_ENDPOINTS) {
+			const method = `codex-subscription/${endpoint}`;
+			disposers.push(connection.fetch.register({
+				path: `/api/${method}`,
+				methods: ["POST"],
+				requestBody: "buffered",
+				async fetch(request) {
+					if (request.headers.get("content-type")?.split(";", 1)[0]?.trim().toLowerCase() !== "application/json") return new Response("content type must be application/json", { status: 415 });
+					let body;
+					try {
+						body = await request.json();
+					} catch {
+						return new Response("invalid JSON", { status: 400 });
+					}
+					const envelope = clientRequestSchema.safeParse(body);
+					if (!envelope.success || envelope.data.method !== method) return new Response("invalid RPC envelope", { status: 400 });
+					let result;
+					try {
+						request.signal.throwIfAborted();
+						result = await handler(endpoint, envelope.data.payload, request.signal);
+					} catch {
+						result = {
+							ok: false,
+							error: {
+								code: "internal",
+								message: "Subscription request failed",
+								details: { issues: [] }
+							}
+						};
+					}
+					return Response.json({
+						type: "server-response",
+						rpcId: envelope.data.rpcId,
+						result
+					});
 				}
-			})
-		},
-		layer: { type: "integer" },
-		shape: {
-			type: "string",
-			enum: [
-				"pen",
-				"line",
-				"arrow",
-				"text",
-				"rectangle",
-				"circle",
-				"ellipse",
-				"polygon",
-				"bezier",
-				"eraser"
-			]
-		},
-		...style,
-		action: {
-			type: "string",
-			enum: [
-				"update",
-				"duplicate",
-				"delete",
-				"add",
-				"select",
-				"rename",
-				"visible",
-				"up",
-				"down",
-				"clear"
-			]
-		},
-		value: string,
-		ratio: {
-			type: "string",
-			enum: [
-				"1:1",
-				"4:3",
-				"3:4",
-				"16:9",
-				"9:16"
-			]
-		},
-		patch: object(style),
-		transform: object({
-			dx: number,
-			dy: number,
-			scaleX: number,
-			scaleY: number
-		})
-	})
-};
+			}));
+		}
+	} catch (error) {
+		for (const dispose of disposers.reverse()) dispose();
+		throw error;
+	}
+	return () => {
+		for (const dispose of disposers.reverse()) dispose();
+	};
+}
 //#endregion
-//#region src/sketch-agent-tool.js
-function createSketchAgentTool(bridge, attachments) {
-	return defineTool({
-		name: "codex_sketch",
-		description: "Edit the sketch board in this session using native editable strokes and layers. Use for @sketch requests and explicit follow-up edits to that drawing. The toolbar pen button is for manual drawing; do not require the user to open it. Start with inspect for the runId, documentId, revision and command reference. Apply atomic batches, preview between stages, and call finish to save the finished draft and release the editing lock. save is only a checkpoint. finish returns an image only when the user enables experimental preview feedback. Closing the board does not stop drawing. If the user stops drawing, do not retry. Never generates AI images, sends messages or attaches images automatically. Inspect automatically opens the board in the currently viewed session. Do not ask the user to open it first. If the session is not visible in DSH, ask them to switch to it. On timeout inspect before retrying; reuse the exact requestId only for the same request.",
-		parameters: {
-			action: {
-				type: "string",
-				required: true,
-				enum: [
-					"inspect",
-					"apply",
-					"preview",
-					"save",
-					"finish"
-				]
-			},
-			runId: {
-				type: "string",
-				description: "From inspect; required for all other actions. Never reuse a stopped run."
-			},
-			documentId: {
-				type: "string",
-				description: "From inspect; required except for inspect."
-			},
-			revision: {
-				type: "integer",
-				description: "From latest response; required for apply/save/finish."
-			},
-			requestId: {
-				type: "string",
-				description: "Unique id for apply/save/finish; exact retries are deduplicated. After timeout inspect recentRequests before repeating a write."
-			},
-			commands: {
-				oneOf: [sketchCommandArray, { type: "string" }],
-				description: "Prefer a native command array. Legacy JSON string also accepted. Required for apply. Use named objects and update existing IDs; prefer Bezier start + segments (control1/control2/end) for curves, not hundreds of pen points."
-			},
-			name: {
-				type: "string",
-				description: "Draft name for save/finish."
-			},
-			offset: {
-				type: "integer",
-				description: "inspect only: object list offset, default 0. Follow nextOffset for further pages."
-			},
-			objectId: {
-				type: "string",
-				description: "inspect only: return full editable geometry for this object, in layer (defaults to active layer)."
+//#region src/subagent-auth.js
+const AUTH_ERROR = "Codex subscription authorization failed; check the selected account";
+/** Keep refresh rotation in the plugin's existing serialized credential store. */
+async function createSubagentTokens({ resolveAuth, store, refresh, signal }) {
+	signal.throwIfAborted();
+	await resolveAuth();
+	const initial = await store.read("openai-codex", { signal });
+	if (initial?.type !== "oauth" || !initial.accountId || !initial.access) throw new Error(AUTH_ERROR);
+	const accountId = initial.accountId;
+	let access = initial.access;
+	return async (previousAccountId, forceRefresh = false) => {
+		signal.throwIfAborted();
+		if (previousAccountId !== void 0 && previousAccountId !== accountId) throw new Error(AUTH_ERROR);
+		let credential;
+		if (previousAccountId !== void 0 || forceRefresh) {
+			const rejectedAccess = access;
+			credential = await store.modify("openai-codex", async (current) => {
+				if (current?.accountId !== accountId) throw new Error(AUTH_ERROR);
+				if (current.access !== rejectedAccess) return current;
+				const next = await refresh(current);
+				if (next?.accountId !== accountId) throw new Error(AUTH_ERROR);
+				return next;
+			}, { signal });
+		} else credential = await store.read("openai-codex", { signal });
+		signal.throwIfAborted();
+		if (credential?.accountId !== accountId || !credential.access) throw new Error(AUTH_ERROR);
+		access = credential.access;
+		return {
+			accessToken: access,
+			chatgptAccountId: accountId
+		};
+	};
+}
+/**
+* Authenticate the official DSH provider's private app-server connection.
+* DSH still owns framing, process containment, turns, tool approvals and disposal.
+* Only the documented external-auth handshake and thread policy are adapted.
+* No token is passed in argv, environment, logs or a second auth.json.
+*/
+function authenticatedSubagentChild(child, { Transport, getTokens, thread, signal }) {
+	const stdin = new PassThrough();
+	const stdout = new PassThrough();
+	const host = new Transport(stdin, stdout);
+	const server = new Transport(child.stdout, child.stdin);
+	let initialized = false;
+	let authenticated;
+	let closed = false;
+	const close = () => {
+		if (closed) return;
+		closed = true;
+		host.close();
+		server.close();
+		stdin.destroy();
+		stdout.end();
+	};
+	const authorize = async (previousAccountId, refresh = false) => {
+		try {
+			return await getTokens(previousAccountId, refresh);
+		} catch {
+			throw new Error(AUTH_ERROR);
+		}
+	};
+	const login = () => authenticated ??= (async () => {
+		const tokens = await authorize();
+		signal.throwIfAborted();
+		try {
+			return await server.request("account/login/start", {
+				type: "chatgptAuthTokens",
+				...tokens
+			}, AbortSignal.any([signal, AbortSignal.timeout(1e4)]));
+		} catch {
+			throw new Error(AUTH_ERROR);
+		}
+	})();
+	host.onRequest(async (method, params) => {
+		if (method === "initialize") {
+			const result = await server.request(method, {
+				...params,
+				capabilities: {
+					...params.capabilities,
+					experimentalApi: true
+				}
+			}, signal);
+			initialized = true;
+			return result;
+		}
+		if (method === "thread/start") {
+			if (!initialized) throw new Error("Codex initialization incomplete");
+			await login();
+			return server.request(method, {
+				...params,
+				...thread
+			}, signal);
+		}
+		return server.request(method, params, signal);
+	});
+	host.onNotification((method, params) => server.notify(method, params));
+	server.onRequest((method, params) => method === "account/chatgptAuthTokens/refresh" ? authorize(params.previousAccountId ?? void 0, true) : host.request(method, params, signal));
+	server.onNotification((method, params) => host.notify(method, params));
+	host.start();
+	server.start();
+	child.done.then(close, close);
+	return new Proxy(child, { get(target, key) {
+		if (key === "stdin") return stdin;
+		if (key === "stdout") return stdout;
+		const value = Reflect.get(target, key, target);
+		return typeof value === "function" ? value.bind(target) : value;
+	} });
+}
+//#endregion
+//#region src/subagent-backend.js
+const SUBAGENT_PROVIDER = "codex-subscription-subagent";
+const MODES = /* @__PURE__ */ new Set([
+	"read-only",
+	"workspace-write",
+	"danger-full-access"
+]);
+function subagentThreadPolicy(parent, policy) {
+	if (!MODES.has(policy?.mode)) throw new Error("DSH subagent sandbox policy is unavailable");
+	const selected = parent.session.requestHeader?.()?.config ?? parent.options ?? {};
+	const subscription = selected.provider === "openai-codex" && typeof selected.model === "string";
+	return {
+		model: subscription ? selected.model : "gpt-5.6-luna",
+		modelProvider: "openai",
+		approvalPolicy: "never",
+		sandbox: policy.mode,
+		config: { model_reasoning_effort: subscription ? selected.reasoningEffort ?? "low" : "low" }
+	};
+}
+/** Reuse the official DSH process/turn provider; keep only subscription auth here. */
+function createSubscriptionSubagent({ ctx, nativeHome, resolveAuth, store, refresh, loadRuntime }) {
+	let runtime;
+	const load = () => runtime ??= loadRuntime().catch((error) => {
+		runtime = void 0;
+		throw error;
+	});
+	const active = /* @__PURE__ */ new Set();
+	let disposed = false;
+	return {
+		provider: {
+			name: SUBAGENT_PROVIDER,
+			capabilities: {
+				agentOptions: false,
+				outputSchema: false,
+				depthLimit: false,
+				toolFilter: false,
+				persona: false
 			},
-			layer: {
-				type: "integer",
-				description: "inspect only: layer containing objectId."
+			inheritsParentContext: false,
+			async start(request) {
+				if (disposed) throw new Error("Codex subagent is unavailable");
+				const controller = new AbortController();
+				active.add(controller);
+				const signal = AbortSignal.any([request.signal, controller.signal]);
+				let run;
+				try {
+					const thread = subagentThreadPolicy(request.parent, ctx.sandboxPolicy.resolve({ session: request.parent.session }));
+					const getTokens = await createSubagentTokens({
+						resolveAuth,
+						store,
+						refresh,
+						signal
+					});
+					const { official, Transport } = await load();
+					const proxy = await resolveCodexOAuthProxy({ target: new URL("https://chatgpt.com/") });
+					signal.throwIfAborted();
+					await mkdir(nativeHome, { recursive: true });
+					const env = {
+						CODEX_HOME: nativeHome,
+						...proxy ? {
+							HTTPS_PROXY: proxy,
+							HTTP_PROXY: proxy,
+							ALL_PROXY: proxy
+						} : {}
+					};
+					let delegate;
+					official.apply({
+						subagents: { registerProvider(value) {
+							delegate = value;
+						} },
+						subprocess: { spawn: (spec) => authenticatedSubagentChild(ctx.subprocess.spawn({
+							...spec,
+							env: {
+								...spec.env,
+								...env
+							}
+						}), {
+							Transport,
+							getTokens,
+							thread,
+							signal
+						}) },
+						logger: { warn: () => ctx.logger?.warn?.("Codex subscription subtask failed") }
+					}, {
+						model: thread.model,
+						env,
+						permissionMode: "never",
+						disposeGraceMs: 1e3
+					});
+					run = await delegate.start({
+						...request,
+						signal
+					});
+					const result = run.result.finally(() => active.delete(controller));
+					return {
+						...run,
+						result,
+						async dispose() {
+							controller.abort();
+							await run.dispose();
+							active.delete(controller);
+						}
+					};
+				} catch (error) {
+					controller.abort();
+					await run?.dispose();
+					active.delete(controller);
+					throw error;
+				}
 			}
 		},
-		timeoutMs: 25e3,
-		isConcurrencySafe: () => false,
-		async execute(args, exec) {
-			const sessionId = exec.agent?.id;
-			if (typeof sessionId !== "string") throw Error("A session-owned sketch call is required");
-			const request = { ...args };
-			if (args.action === "apply") try {
-				request.commands = typeof args.commands === "string" ? JSON.parse(args.commands) : args.commands;
-				if (!Array.isArray(request.commands)) throw Error();
-			} catch {
-				throw Error("commands must be a native array or JSON array string");
-			}
-			const value = await bridge.request(sessionId, request, exec.signal);
-			if (value.png) {
-				if (!/^data:image\/png;base64,/.test(value.png) || value.png.length > 8 * 1024 * 1024) throw Error("Invalid sketch preview");
-				const image = await attachments.saveImage({
-					data: new Uint8Array(Buffer.from(value.png.split(",")[1], "base64")),
-					mediaType: "image/png",
-					name: "sketch-preview.png"
-				});
-				const { png, ...snapshot } = value;
-				return {
-					...snapshot,
-					image
-				};
-			}
-			return value;
-		},
-		output: {
-			schema: {
-				type: "object",
-				additionalProperties: true
-			},
-			render: (_args, value) => [{
-				type: "text",
-				text: JSON.stringify({
-					...value,
-					image: void 0
-				})
-			}, ...value.image ? [{
-				type: "image",
-				attachment: value.image
-			}] : []]
+		prepare: load,
+		dispose() {
+			disposed = true;
+			for (const controller of active) controller.abort();
 		}
-	});
+	};
 }
-//#endregion
-//#region src/sketch-codec-route.js
-function registerSketchCodec(connection) {
-	let source;
-	return connection.fetch.register({
-		path: "/api/codex-subscription/sketch-psd-worker",
-		methods: ["GET"],
-		requestBody: "buffered",
-		async fetch() {
-			source ??= await readFile(new URL("./sketch-psd-worker.js", import.meta.url));
-			return new Response(source, { headers: {
-				"content-type": "text/javascript; charset=utf-8",
-				"cache-control": "no-store"
-			} });
-		}
+/** Change only standard independent spawn tools; leave fork/custom tools untouched. */
+function createSubagentBackendSwitcher({ entries, prepare, persist }) {
+	const originals = /* @__PURE__ */ new Map();
+	let selected = "dsh";
+	let tail = Promise.resolve();
+	let disposed = false;
+	const standard = (entry, config) => entry?.options?.name === "@deepseek-ai/dsh-tool-subagent" && config?.provider === "spawn" && !config.agentOptions && !config.persona && !config.toolFilter;
+	const convert = (config) => ({
+		...config,
+		provider: SUBAGENT_PROVIDER,
+		modelSelectionSettings: false,
+		backgroundMode: "one-shot",
+		maxDepth: "provider-managed"
 	});
-}
-//#endregion
-//#region src/account-vault.js
-const VERSION = 1;
-const DEFAULT_LABEL = "Account 1";
-const clone$1 = (value) => value === void 0 ? void 0 : structuredClone(value);
-const EMAIL_MAX_LENGTH = 254;
-const EMAIL_PATTERN = /^[^\s@]+@[^\s@]+\.[^\s@]+$/u;
-/** Keep only a bounded, display-safe email address from a trusted OAuth result. */
-function normalizeAccountEmail(value) {
-	if (typeof value !== "string") return void 0;
-	const email = value.trim();
-	return email.length > 0 && email.length <= EMAIL_MAX_LENGTH && EMAIL_PATTERN.test(email) ? email : void 0;
-}
-function decodeJwtPayload(access) {
-	if (typeof access !== "string") return void 0;
-	const encoded = access.split(".")[1];
-	if (typeof encoded !== "string" || encoded.length === 0) return void 0;
-	try {
-		return JSON.parse(Buffer.from(encoded, "base64url").toString("utf8"));
-	} catch {
-		return;
-	}
-}
-function emailFromAccessToken(access) {
-	const payload = decodeJwtPayload(access);
-	return normalizeAccountEmail(payload?.["https://api.openai.com/profile"]?.email ?? payload?.email);
-}
-/** Normalize the one non-secret account attribute that may cross the UI boundary. */
-function sanitizeOAuthCredential(value) {
-	const credential = assertOAuthCredential$1(value);
-	const email = emailFromAccessToken(credential.access) ?? normalizeAccountEmail(credential.email);
-	if (email === void 0) {
-		delete credential.email;
-		return credential;
-	}
+	const configure = (fiber, config) => {
+		if (!standard(fiber.entry, config)) return config;
+		if (!originals.has(fiber)) originals.set(fiber, { ...config });
+		return selected === "codex" ? convert(config) : config;
+	};
+	const select = (mode) => {
+		if (!["dsh", "codex"].includes(mode)) return Promise.reject(/* @__PURE__ */ new Error("Invalid subagent backend"));
+		const next = tail.catch(() => {}).then(async () => {
+			if (disposed) throw new Error("Subagent backend is unavailable");
+			const all = [...entries()];
+			for (const entry of all) if (entry.fiber && standard(entry, entry.fiber.config) && !originals.has(entry.fiber)) originals.set(entry.fiber, { ...entry.fiber.config });
+			if (mode === "codex") {
+				if (!originals.size && !all.some((entry) => standard(entry, entry.options?.config))) throw new Error("No standard DSH independent subagent tool is available");
+				await prepare();
+			}
+			const changed = [];
+			const previous = selected;
+			selected = mode;
+			try {
+				for (const [fiber, original] of originals) {
+					if (fiber.entry && fiber.entry.fiber !== fiber) {
+						originals.delete(fiber);
+						continue;
+					}
+					const before = { ...fiber.config };
+					changed.push({
+						fiber,
+						before
+					});
+					await fiber.update(mode === "codex" ? convert(original) : original, true);
+				}
+				await persist?.(mode);
+			} catch (error) {
+				selected = previous;
+				for (const { fiber, before } of changed.reverse()) await fiber.update(before, true);
+				throw error;
+			}
+		});
+		tail = next;
+		return next;
+	};
 	return {
-		...credential,
-		email
+		select,
+		configure,
+		async dispose() {
+			await tail.catch(() => {});
+			disposed = true;
+			selected = "dsh";
+			for (const [fiber, original] of originals) if (fiber.config?.provider === "codex-subscription-subagent") await fiber.update(original, true);
+			originals.clear();
+		}
 	};
 }
-function assertOAuthCredential$1(value) {
-	if (value === null || typeof value !== "object" || value.type !== "oauth" || typeof value.access !== "string" || value.access.length === 0 || typeof value.refresh !== "string" || value.refresh.length === 0 || typeof value.expires !== "number" || !Number.isFinite(value.expires)) throw new Error("Codex account vault received a malformed OAuth credential");
-	return clone$1(value);
-}
-function parseOAuthCredential$1(value) {
-	try {
-		return assertOAuthCredential$1(JSON.parse(value));
-	} catch (error) {
-		if (error?.message === "Codex account vault received a malformed OAuth credential") throw error;
-		throw new Error("Codex account vault contains malformed OAuth JSON", { cause: error });
-	}
-}
-function normalizeLabel(value) {
-	if (typeof value !== "string") throw new Error("Codex account label must be text");
-	const label = value.trim().replace(/\s+/gu, " ");
-	if (label.length === 0 || label.length > 48) throw new Error("Codex account label must contain 1 to 48 characters");
-	return label;
-}
-function assertVaultRecord(record) {
-	if (record?.kind !== "grant" || record.payload?.version !== VERSION || typeof record.payload.activeId !== "string" || !Array.isArray(record.payload.accounts) || record.payload.accounts.length === 0) throw new Error("Codex account vault contains a malformed grant record");
-	const ids = /* @__PURE__ */ new Set();
-	const accounts = record.payload.accounts.map((account) => {
-		if (account === null || typeof account !== "object" || typeof account.id !== "string" || account.id.length === 0 || ids.has(account.id)) throw new Error("Codex account vault contains a malformed account id");
-		ids.add(account.id);
-		return {
-			id: account.id,
-			label: normalizeLabel(account.label),
-			credential: sanitizeOAuthCredential(account.credential)
-		};
-	});
-	if (!ids.has(record.payload.activeId)) throw new Error("Codex account vault active account is missing");
-	const legacyAccountId = record.payload.legacyAccountId;
-	if (legacyAccountId !== void 0 && !ids.has(legacyAccountId)) throw new Error("Codex account vault legacy account is missing");
+async function loadSubagentRuntime() {
+	const [official, { JsonRpcLineTransport: Transport }] = await Promise.all([import("@deepseek-ai/dsh-subagent-codex"), import("@deepseek-ai/dsh-sdk-protocol")]);
 	return {
-		version: VERSION,
-		activeId: record.payload.activeId,
-		legacyAccountId,
-		accounts
+		official,
+		Transport
 	};
 }
-const grant = (payload) => ({
-	kind: "grant",
-	payload
-});
-var PendingOAuthCredentialStore = class {
-	#credential;
-	async read(providerId) {
-		if (providerId !== "openai-codex") throw new Error("Pending Codex login received an unknown provider");
-		return clone$1(this.#credential);
-	}
-	async list() {
-		return this.#credential === void 0 ? [] : [{
-			providerId: "openai-codex",
-			type: "oauth"
-		}];
-	}
-	async modify(providerId, update) {
-		if (providerId !== "openai-codex") throw new Error("Pending Codex login received an unknown provider");
-		const next = await update(clone$1(this.#credential));
-		if (next !== void 0) this.#credential = sanitizeOAuthCredential(next);
-		return clone$1(this.#credential);
-	}
-	async delete(providerId) {
-		if (providerId !== "openai-codex") throw new Error("Pending Codex login received an unknown provider");
-		this.#credential = void 0;
-	}
-	credential() {
-		return clone$1(this.#credential);
-	}
-};
-/**
-* Multi-account owner state stored in DSH's atomic plugin credential record.
-* The old single-account reference remains as a rollback source and is kept in
-* sync whenever that imported account rotates its refresh token.
-*/
-var DshOAuthAccountVault = class {
-	#tail = Promise.resolve();
-	constructor(credentials, options) {
-		if (credentials === void 0 || credentials === null || typeof credentials.readRecord !== "function" || typeof credentials.modifyRecord !== "function") throw new Error("Codex multi-account requires DSH credential records");
-		this.credentials = credentials;
-		this.key = options.key;
-		this.legacyRef = options.legacyRef;
-		this.legacyRefs = Object.freeze([...options.legacyRefs ?? []]);
-		this.createId = options.createId ?? randomUUID;
-		this.onLegacySyncFailure = options.onLegacySyncFailure ?? (() => {});
-	}
-	#enqueue(operation) {
-		const current = this.#tail.catch(() => void 0).then(operation);
-		this.#tail = current.catch(() => void 0);
-		return current;
-	}
-	async #legacyCredential() {
-		for (const ref of [this.legacyRef, ...this.legacyRefs]) {
-			const hit = await this.credentials.resolve(ref);
-			if (hit?.value === void 0 || hit.value === "") continue;
-			return {
-				ref,
-				credential: parseOAuthCredential$1(hit.value)
-			};
-		}
-	}
-	async #ensurePayload() {
-		const existing = await this.credentials.readRecord(this.key);
-		if (existing !== void 0) return assertVaultRecord(existing);
-		const legacy = await this.#legacyCredential();
-		if (legacy === void 0) return void 0;
-		const id = this.createId();
-		return assertVaultRecord(await this.credentials.modifyRecord(this.key, (current) => {
-			if (current !== void 0) return Promise.resolve(current);
-			return Promise.resolve(grant({
-				version: VERSION,
-				activeId: id,
-				legacyAccountId: id,
-				accounts: [{
-					id,
-					label: DEFAULT_LABEL,
-					credential: legacy.credential
-				}]
-			}));
-		}));
-	}
-	async #modifyPayload(update) {
-		await this.#ensurePayload();
-		let previousLegacy;
-		const payload = assertVaultRecord(await this.credentials.modifyRecord(this.key, async (current) => {
-			if (current === void 0) throw new Error("Codex account vault is not signed in");
-			const payload = assertVaultRecord(current);
-			previousLegacy = payload.accounts.find((account) => account.id === payload.legacyAccountId)?.credential;
-			const next = await update(clone$1(payload));
-			return grant(next);
-		}));
-		const legacy = payload.accounts.find((account) => account.id === payload.legacyAccountId)?.credential;
-		try {
-			if (legacy === void 0) {
-				if (previousLegacy !== void 0) await this.credentials.unset(this.legacyRef);
-			} else if (JSON.stringify(legacy) !== JSON.stringify(previousLegacy)) await this.credentials.set(this.legacyRef, JSON.stringify(legacy));
-		} catch {
-			this.onLegacySyncFailure();
-		}
-		return payload;
-	}
-	list() {
-		return this.#enqueue(async () => {
-			const payload = await this.#ensurePayload();
-			if (payload === void 0) return [];
-			return payload.accounts.map((account) => ({
-				id: account.id,
-				label: account.label,
-				active: account.id === payload.activeId,
-				expiresAt: account.credential.expires,
-				...account.credential.email === void 0 ? {} : { email: account.credential.email }
-			}));
-		});
-	}
-	readActive() {
-		return this.#enqueue(async () => {
-			const payload = await this.#ensurePayload();
-			return clone$1(payload?.accounts.find((account) => account.id === payload.activeId)?.credential);
-		});
-	}
-	activeId() {
-		return this.#enqueue(async () => (await this.#ensurePayload())?.activeId);
-	}
-	add(label, credential) {
-		return this.#enqueue(async () => {
-			const normalizedLabel = normalizeLabel(label);
-			const validated = sanitizeOAuthCredential(credential);
-			await this.#ensurePayload();
-			const id = this.createId();
-			const account = (await this.#modifyPayload((current) => ({
-				...current,
-				activeId: id,
-				accounts: [...current.accounts, {
-					id,
-					label: normalizedLabel,
-					credential: validated
-				}]
-			}))).accounts.find((candidate) => candidate.id === id);
-			return {
-				id,
-				label: account.label,
-				active: true,
-				expiresAt: account.credential.expires,
-				...account.credential.email === void 0 ? {} : { email: account.credential.email }
-			};
-		});
-	}
-	select(id) {
-		return this.#enqueue(async () => {
-			await this.#modifyPayload((current) => {
-				if (!current.accounts.some((account) => account.id === id)) throw new Error("Unknown Codex account");
-				return {
-					...current,
-					activeId: id
-				};
-			});
-		});
-	}
-	modifyActive(update) {
-		return this.#enqueue(async () => {
-			if (await this.#ensurePayload() === void 0) {
-				const initial = await update(void 0);
-				if (initial === void 0) return void 0;
-				const credential = sanitizeOAuthCredential(initial);
-				await this.credentials.set(this.legacyRef, JSON.stringify(credential));
-				await this.#ensurePayload();
-				return clone$1(credential);
-			}
-			let result;
-			await this.#modifyPayload(async (current) => {
-				const index = current.accounts.findIndex((account) => account.id === current.activeId);
-				const previous = clone$1(current.accounts[index].credential);
-				const next = await update(previous);
-				if (next === void 0) {
-					result = previous;
-					return current;
+//#endregion
+//#region src/sketch-agent-bridge.js
+function createSketchAgentBridge({ enabled, now = Date.now, timeoutMs = 2e4 }) {
+	const sessions = /* @__PURE__ */ new Map();
+	const fail = (entry, message) => {
+		for (const task of entry.tasks.values()) task.reject(Error(message));
+		entry.tasks.clear();
+	};
+	const find = (payload) => {
+		const entry = sessions.get(payload.sessionId);
+		if (!entry || entry.token !== payload.token || now() - entry.seen > 1e4) throw Error("Sketch connection expired");
+		entry.seen = now();
+		return entry;
+	};
+	return {
+		async rpc(endpoint, payload) {
+			try {
+				if (!enabled()) throw Error("Sketch is disabled");
+				if (!payload || typeof payload.sessionId !== "string" || !payload.sessionId.length || payload.sessionId.length > 200) throw Error("Invalid session");
+				if (endpoint === "sketch/connect") {
+					for (const [id, entry] of sessions) if (now() - entry.seen >= 1e4) {
+						fail(entry, "Sketch connection expired");
+						sessions.delete(id);
+					}
+					const previous = sessions.get(payload.sessionId);
+					if (previous && now() - previous.seen < 1e4) throw Error("Another board is connected to this session");
+					if (previous) fail(previous, "Sketch connection replaced");
+					const entry = {
+						token: randomUUID(),
+						seen: now(),
+						tasks: /* @__PURE__ */ new Map(),
+						cancelled: []
+					};
+					sessions.set(payload.sessionId, entry);
+					return {
+						ok: true,
+						value: { token: entry.token }
+					};
 				}
-				const credential = sanitizeOAuthCredential(next);
-				if (credential.email === void 0 && previous.email !== void 0) credential.email = previous.email;
-				const accounts = [...current.accounts];
-				accounts[index] = {
-					...accounts[index],
-					credential
+				const entry = find(payload);
+				if (endpoint === "sketch/poll") return {
+					ok: true,
+					value: [...entry.cancelled.splice(0).map((id) => ({
+						id,
+						cancelled: true
+					})), ...[...entry.tasks].filter(([, t]) => !t.delivered).map(([id, t]) => {
+						t.delivered = true;
+						return {
+							id,
+							request: t.request,
+							expiresAt: t.expiresAt
+						};
+					})]
 				};
-				result = clone$1(credential);
+				if (endpoint === "sketch/claim") {
+					const task = entry.tasks.get(payload.id);
+					return {
+						ok: true,
+						value: Boolean(task && task.delivered && task.expiresAt > now())
+					};
+				}
+				if (endpoint === "sketch/disconnect") {
+					fail(entry, "Sketch board closed");
+					sessions.delete(payload.sessionId);
+					return {
+						ok: true,
+						value: null
+					};
+				}
+				if (endpoint === "sketch/result") {
+					const task = entry.tasks.get(payload.id);
+					if (task) {
+						entry.tasks.delete(payload.id);
+						payload.error ? task.reject(Error(String(payload.error).slice(0, 500))) : task.resolve(payload.value);
+					}
+					return {
+						ok: true,
+						value: null
+					};
+				}
+				throw Error("Unknown sketch route");
+			} catch (error) {
 				return {
-					...current,
-					accounts
+					ok: false,
+					error: {
+						code: "invalid-input",
+						message: error.message,
+						details: { issues: [] }
+					}
 				};
-			});
-			return result;
-		});
-	}
-	deleteAll() {
-		return this.#enqueue(async () => {
-			await this.credentials.deleteRecord(this.key);
-			await this.credentials.unset(this.legacyRef);
-			for (const ref of this.legacyRefs) await this.credentials.unset(ref);
-		});
-	}
-	remove(id) {
-		return this.#enqueue(async () => {
-			await this.#modifyPayload((current) => {
-				if (!current.accounts.some((account) => account.id === id)) throw new Error("Unknown Codex account");
-				if (current.accounts.length === 1) throw new Error("Cannot remove the last account; sign out instead");
-				const accounts = current.accounts.filter((account) => account.id !== id);
-				return {
-					...current,
-					activeId: current.activeId === id ? accounts[0].id : current.activeId,
-					legacyAccountId: current.legacyAccountId === id ? void 0 : current.legacyAccountId,
-					accounts
+			}
+		},
+		request(sessionId, request, signal) {
+			if (!enabled()) return Promise.reject(Error("Sketch is disabled"));
+			const entry = sessions.get(sessionId);
+			if (!entry || now() - entry.seen > 1e4) return Promise.reject(Error("Switch to this session in DSH with sketch editing enabled"));
+			if (entry.tasks.size) return Promise.reject(Error("Another sketch operation is pending"));
+			if (JSON.stringify(request).length > 2e6) return Promise.reject(Error("Sketch batch is too large"));
+			return new Promise((resolve, reject) => {
+				const id = randomUUID();
+				const finish = (callback, value) => {
+					clearTimeout(timer);
+					signal?.removeEventListener("abort", abort);
+					entry.tasks.delete(id);
+					callback(value);
 				};
+				const cancel = (message) => {
+					if (entry.tasks.get(id)?.delivered) {
+						entry.cancelled.push(id);
+						if (entry.cancelled.length > 32) entry.cancelled.shift();
+					}
+					finish(reject, Error(message));
+				};
+				const abort = () => cancel("Sketch operation interrupted; inspect recentRequests before retrying");
+				const timer = setTimeout(() => cancel("Sketch response timed out; inspect recentRequests before retrying"), timeoutMs);
+				entry.tasks.set(id, {
+					request,
+					expiresAt: now() + timeoutMs,
+					delivered: false,
+					resolve: (value) => finish(resolve, value),
+					reject: (error) => finish(reject, error)
+				});
+				signal?.addEventListener("abort", abort, { once: true });
+				if (signal?.aborted) abort();
 			});
-		});
-	}
-};
-//#endregion
-//#region src/credential-store.js
-const PROVIDER$1 = "openai-codex";
-const abortIfNeeded = (options) => options?.signal?.throwIfAborted();
-const clone = (value) => value === void 0 ? void 0 : structuredClone(value);
-function assertProvider(providerId) {
-	if (providerId !== PROVIDER$1) throw new Error(`Codex credential store does not own provider ${JSON.stringify(providerId)}`);
-}
-function assertOAuthCredential(value) {
-	if (value === void 0) return void 0;
-	if (value === null || typeof value !== "object" || value.type !== "oauth" || typeof value.access !== "string" || value.access.length === 0 || typeof value.refresh !== "string" || value.refresh.length === 0 || typeof value.expires !== "number" || !Number.isFinite(value.expires)) throw new Error("Codex credential store received a malformed OAuth credential");
-	return clone(value);
-}
-function parseOAuthCredential(value) {
-	try {
-		return assertOAuthCredential(JSON.parse(value));
-	} catch (error) {
-		if (error?.message === "Codex credential store received a malformed OAuth credential") throw error;
-		throw new Error("Codex credential store contains malformed OAuth JSON", { cause: error });
-	}
-}
-/**
-* Adapt DSH's managed string credential service to pi-ai's typed OAuth store.
-* Refresh/login/logout operations are serialized so an older refresh response
-* cannot overwrite a newer rotated token.
-*/
-var DshOAuthCredentialStore = class {
-	#chains = /* @__PURE__ */ new Map();
-	constructor(credentials, ref, legacyRefs = [], options = {}) {
-		if (credentials === void 0 || credentials === null) throw new Error("Codex OAuth requires the DSH credentials service");
-		const expirySkewMs = options.expirySkewMs ?? 0;
-		if (!Number.isFinite(expirySkewMs) || expirySkewMs < 0) throw new Error("Codex OAuth expiry skew must be a non-negative finite number");
-		this.credentials = credentials;
-		this.ref = ref;
-		this.legacyRefs = Object.freeze([...legacyRefs]);
-		this.expirySkewMs = expirySkewMs;
-		this.vault = options.vault;
-	}
-	#enqueue(providerId, operation, options) {
-		assertProvider(providerId);
-		const current = (this.#chains.get(providerId) ?? Promise.resolve()).catch(() => void 0).then(async () => {
-			abortIfNeeded(options);
-			return operation();
-		});
-		const tail = current.catch(() => void 0);
-		this.#chains.set(providerId, tail);
-		tail.finally(() => {
-			if (this.#chains.get(providerId) === tail) this.#chains.delete(providerId);
-		});
-		return current;
-	}
-	async #read(providerId, options) {
-		assertProvider(providerId);
-		abortIfNeeded(options);
-		if (this.vault !== void 0) {
-			const current = await this.vault.readActive();
-			if (current === void 0) return void 0;
-			return this.expirySkewMs === 0 ? current : {
-				...current,
-				expires: current.expires - this.expirySkewMs
-			};
+		},
+		dispose() {
+			for (const entry of sessions.values()) fail(entry, "Sketch service stopped");
+			sessions.clear();
 		}
-		let hit = await this.credentials.resolve(this.ref);
-		if (hit?.value === void 0 || hit.value === "") for (const legacyRef of this.legacyRefs) {
-			const legacy = await this.credentials.resolve(legacyRef);
-			if (legacy?.value === void 0 || legacy.value === "") continue;
-			const migrated = parseOAuthCredential(legacy.value);
-			await this.credentials.set(this.ref, JSON.stringify(migrated));
-			await this.credentials.unset(legacyRef);
-			hit = { value: JSON.stringify(migrated) };
-			break;
+	};
+}
+//#endregion
+//#region src/sketch-command-schema.js
+const number = { type: "number" };
+const string = { type: "string" };
+const object = (properties) => ({
+	type: "object",
+	additionalProperties: false,
+	properties
+});
+const points = {
+	type: "array",
+	items: object({
+		x: {
+			...number,
+			required: true
+		},
+		y: {
+			...number,
+			required: true
 		}
-		abortIfNeeded(options);
-		if (hit?.value === void 0 || hit.value === "") return void 0;
-		const credential = parseOAuthCredential(hit.value);
-		return this.expirySkewMs === 0 ? credential : {
-			...credential,
-			expires: credential.expires - this.expirySkewMs
-		};
-	}
-	read(providerId, options) {
-		return this.#enqueue(providerId, () => this.#read(providerId, options), options);
-	}
-	async list(options) {
-		abortIfNeeded(options);
-		return await this.read(PROVIDER$1, options) === void 0 ? [] : [{
-			providerId: PROVIDER$1,
-			type: "oauth"
-		}];
-	}
-	modify(providerId, update, options) {
-		return this.#enqueue(providerId, async () => {
-			if (this.vault !== void 0) {
-				const next = await this.vault.modifyActive(async (current) => {
-					const visible = current === void 0 || this.expirySkewMs === 0 ? current : {
-						...current,
-						expires: current.expires - this.expirySkewMs
-					};
-					const updated = await update(clone(visible));
-					return updated === void 0 ? void 0 : assertOAuthCredential(updated);
-				});
-				abortIfNeeded(options);
-				return clone(next);
-			}
-			const current = await this.#read(providerId, options);
-			const next = await update(clone(current));
-			abortIfNeeded(options);
-			if (next === void 0) return current;
-			const validated = assertOAuthCredential(next);
-			await this.credentials.set(this.ref, JSON.stringify(validated));
-			for (const legacyRef of this.legacyRefs) await this.credentials.unset(legacyRef);
-			abortIfNeeded(options);
-			return clone(validated);
-		}, options);
+	})
+};
+const point = object({
+	x: {
+		...number,
+		required: true
+	},
+	y: {
+		...number,
+		required: true
 	}
-	delete(providerId, options) {
-		return this.#enqueue(providerId, async () => {
-			if (this.vault !== void 0) {
-				await this.vault.deleteAll();
-				abortIfNeeded(options);
-				return;
+});
+const style = {
+	color: string,
+	width: number,
+	opacity: number,
+	fill: { type: "boolean" },
+	text: string,
+	points
+};
+const sketchCommandArray = {
+	type: "array",
+	items: object({
+		op: {
+			type: "string",
+			required: true,
+			enum: [
+				"stroke",
+				"object",
+				"layer",
+				"resize"
+			]
+		},
+		id: {
+			oneOf: [{ type: "string" }, { type: "integer" }],
+			description: "Object string ID. Layer add: optional NEW unique integer ID; other layer actions: existing layer ID."
+		},
+		after: {
+			type: "integer",
+			description: "Layer add only: existing layer to insert after; defaults to active."
+		},
+		start: point,
+		segments: {
+			type: "array",
+			items: object({
+				control1: {
+					...point,
+					required: true
+				},
+				control2: {
+					...point,
+					required: true
+				},
+				end: {
+					...point,
+					required: true
+				}
+			})
+		},
+		layer: { type: "integer" },
+		shape: {
+			type: "string",
+			enum: [
+				"pen",
+				"line",
+				"arrow",
+				"text",
+				"rectangle",
+				"circle",
+				"ellipse",
+				"polygon",
+				"bezier",
+				"eraser"
+			]
+		},
+		...style,
+		action: {
+			type: "string",
+			enum: [
+				"update",
+				"duplicate",
+				"delete",
+				"add",
+				"select",
+				"rename",
+				"visible",
+				"up",
+				"down",
+				"clear"
+			]
+		},
+		value: string,
+		ratio: {
+			type: "string",
+			enum: [
+				"1:1",
+				"4:3",
+				"3:4",
+				"16:9",
+				"9:16"
+			]
+		},
+		patch: object(style),
+		transform: object({
+			dx: number,
+			dy: number,
+			scaleX: number,
+			scaleY: number
+		})
+	})
+};
+//#endregion
+//#region src/sketch-agent-tool.js
+function createSketchAgentTool(bridge, attachments) {
+	return defineTool({
+		name: "codex_sketch",
+		description: "Edit the sketch board in this session using native editable strokes and layers. Use for @sketch requests and explicit follow-up edits to that drawing. The toolbar pen button is for manual drawing; do not require the user to open it. Start with inspect for the runId, documentId, revision and command reference. Apply atomic batches, preview between stages, and call finish to save the finished draft and release the editing lock. save is only a checkpoint. finish returns an image only when the user enables experimental preview feedback. Closing the board does not stop drawing. If the user stops drawing, do not retry. Never generates AI images, sends messages or attaches images automatically. Inspect automatically opens the board in the currently viewed session. Do not ask the user to open it first. If the session is not visible in DSH, ask them to switch to it. On timeout inspect before retrying; reuse the exact requestId only for the same request.",
+		parameters: {
+			action: {
+				type: "string",
+				required: true,
+				enum: [
+					"inspect",
+					"apply",
+					"preview",
+					"save",
+					"finish"
+				]
+			},
+			runId: {
+				type: "string",
+				description: "From inspect; required for all other actions. Never reuse a stopped run."
+			},
+			documentId: {
+				type: "string",
+				description: "From inspect; required except for inspect."
+			},
+			revision: {
+				type: "integer",
+				description: "From latest response; required for apply/save/finish."
+			},
+			requestId: {
+				type: "string",
+				description: "Unique id for apply/save/finish; exact retries are deduplicated. After timeout inspect recentRequests before repeating a write."
+			},
+			commands: {
+				oneOf: [sketchCommandArray, { type: "string" }],
+				description: "Prefer a native command array. Legacy JSON string also accepted. Required for apply. Use named objects and update existing IDs; prefer Bezier start + segments (control1/control2/end) for curves, not hundreds of pen points."
+			},
+			name: {
+				type: "string",
+				description: "Draft name for save/finish."
+			},
+			offset: {
+				type: "integer",
+				description: "inspect only: object list offset, default 0. Follow nextOffset for further pages."
+			},
+			objectId: {
+				type: "string",
+				description: "inspect only: return full editable geometry for this object, in layer (defaults to active layer)."
+			},
+			layer: {
+				type: "integer",
+				description: "inspect only: layer containing objectId."
 			}
-			await this.credentials.unset(this.ref);
-			for (const legacyRef of this.legacyRefs) await this.credentials.unset(legacyRef);
-			abortIfNeeded(options);
-		}, options);
-	}
-};
-/** Return only account state that is safe to expose to the browser client. */
-function createCodexAuthService(models, store, options = {}) {
-	const runLogin = options.runLogin ?? ((run) => run());
-	const accountVault = options.accountVault;
-	const createLoginModels = options.createLoginModels;
-	const createPendingStore = options.createPendingStore ?? (() => new PendingOAuthCredentialStore());
-	return Object.freeze({
-		async status(options) {
-			const current = await store.read(PROVIDER$1, options);
-			const accounts = await accountVault?.list();
-			if (current === void 0) return {
-				authenticated: false,
-				provider: PROVIDER$1,
-				...accounts === void 0 ? {} : { accounts }
-			};
-			return {
-				authenticated: true,
-				provider: PROVIDER$1,
-				type: "oauth",
-				expiresAt: current.expires,
-				...accounts === void 0 ? {} : { accounts }
-			};
 		},
-		login(interaction, input = {}) {
-			if (input.label !== void 0) {
-				if (accountVault === void 0 || createLoginModels === void 0) throw new Error("Codex multi-account is unavailable");
-				return runLogin(async () => {
-					const pending = createPendingStore();
-					await createLoginModels(pending).login(PROVIDER$1, "oauth", interaction);
-					const credential = pending.credential();
-					if (credential === void 0) throw new Error("Codex login did not return credentials");
-					await accountVault.add(input.label, credential);
+		timeoutMs: 25e3,
+		isConcurrencySafe: () => false,
+		async execute(args, exec) {
+			const sessionId = exec.agent?.id;
+			if (typeof sessionId !== "string") throw Error("A session-owned sketch call is required");
+			const request = { ...args };
+			if (args.action === "apply") try {
+				request.commands = typeof args.commands === "string" ? JSON.parse(args.commands) : args.commands;
+				if (!Array.isArray(request.commands)) throw Error();
+			} catch {
+				throw Error("commands must be a native array or JSON array string");
+			}
+			const value = await bridge.request(sessionId, request, exec.signal);
+			if (value.png) {
+				if (!/^data:image\/png;base64,/.test(value.png) || value.png.length > 8 * 1024 * 1024) throw Error("Invalid sketch preview");
+				const image = await attachments.saveImage({
+					data: new Uint8Array(Buffer.from(value.png.split(",")[1], "base64")),
+					mediaType: "image/png",
+					name: "sketch-preview.png"
 				});
+				const { png, ...snapshot } = value;
+				return {
+					...snapshot,
+					image
+				};
 			}
-			return runLogin(() => models.login(PROVIDER$1, "oauth", interaction));
-		},
-		async select(id) {
-			if (accountVault === void 0) throw new Error("Codex multi-account is unavailable");
-			await accountVault.select(id);
-			return this.status();
-		},
-		async remove(id) {
-			if (accountVault === void 0) throw new Error("Codex multi-account is unavailable");
-			await accountVault.remove(id);
-			return this.status();
+			return value;
 		},
-		logout(options) {
-			return models.logout(PROVIDER$1, options);
+		output: {
+			schema: {
+				type: "object",
+				additionalProperties: true
+			},
+			render: (_args, value) => [{
+				type: "text",
+				text: JSON.stringify({
+					...value,
+					image: void 0
+				})
+			}, ...value.image ? [{
+				type: "image",
+				attachment: value.image
+			}] : []]
 		}
 	});
 }
 //#endregion
-//#region src/external-url.js
-const OPENAI_AUTH_ORIGIN = "https://auth.openai.com";
-/** Validate the only external origin this plugin may launch. */
-function assertCodexAuthUrl(value) {
-	let url;
+//#region src/sketch-codec-route.js
+function registerSketchCodec(connection) {
+	let source;
+	return connection.fetch.register({
+		path: "/api/codex-subscription/sketch-psd-worker",
+		methods: ["GET"],
+		requestBody: "buffered",
+		async fetch() {
+			source ??= await readFile(new URL("./sketch-psd-worker.js", import.meta.url));
+			return new Response(source, { headers: {
+				"content-type": "text/javascript; charset=utf-8",
+				"cache-control": "no-store"
+			} });
+		}
+	});
+}
+//#endregion
+//#region src/account-vault.js
+const VERSION = 1;
+const DEFAULT_LABEL = "Account 1";
+const clone$1 = (value) => value === void 0 ? void 0 : structuredClone(value);
+const EMAIL_MAX_LENGTH = 254;
+const EMAIL_PATTERN = /^[^\s@]+@[^\s@]+\.[^\s@]+$/u;
+/** Keep only a bounded, display-safe email address from a trusted OAuth result. */
+function normalizeAccountEmail(value) {
+	if (typeof value !== "string") return void 0;
+	const email = value.trim();
+	return email.length > 0 && email.length <= EMAIL_MAX_LENGTH && EMAIL_PATTERN.test(email) ? email : void 0;
+}
+function decodeJwtPayload(access) {
+	if (typeof access !== "string") return void 0;
+	const encoded = access.split(".")[1];
+	if (typeof encoded !== "string" || encoded.length === 0) return void 0;
 	try {
-		url = new URL(value);
+		return JSON.parse(Buffer.from(encoded, "base64url").toString("utf8"));
 	} catch {
-		throw new Error("Codex auth URL is invalid");
+		return;
 	}
-	if (url.protocol !== "https:") throw new Error("Codex auth URL must use HTTPS");
-	if (url.origin !== OPENAI_AUTH_ORIGIN || url.username !== "" || url.password !== "") throw new Error("Codex auth URL must use the OpenAI auth origin");
-	return url.href;
-}
-/** Return a shell-free native opener command for the current desktop. */
-function commandForCodexAuthUrl(value, platform = process.platform) {
-	const url = assertCodexAuthUrl(value);
-	if (platform === "win32") return {
-		file: "rundll32.exe",
-		args: ["url.dll,FileProtocolHandler", url],
-		shell: false
-	};
-	if (platform === "darwin") return {
-		file: "open",
-		args: [url],
-		shell: false
-	};
-	if (platform === "linux") return {
-		file: "xdg-open",
-		args: [url],
-		shell: false
-	};
-	throw new Error(`Codex auth URL opener is unsupported on ${platform}`);
 }
-function openCodexAuthUrl(value, options = {}) {
-	const command = commandForCodexAuthUrl(value, options.platform);
-	const spawnProcess = options.spawn ?? spawn;
-	return new Promise((resolve, reject) => {
-		const child = spawnProcess(command.file, command.args, {
-			detached: true,
-			stdio: "ignore",
-			windowsHide: true,
-			shell: command.shell
-		});
-		child.once("error", reject);
-		child.once("spawn", () => {
-			child.unref();
-			resolve();
-		});
-	});
+function emailFromAccessToken(access) {
+	const payload = decodeJwtPayload(access);
+	return normalizeAccountEmail(payload?.["https://api.openai.com/profile"]?.email ?? payload?.email);
 }
-//#endregion
-//#region src/login-coordinator.js
-const LOGIN_METHODS = /* @__PURE__ */ new Set(["browser", "device_code"]);
-const TERMINAL_PHASES = /* @__PURE__ */ new Set([
-	"authenticated",
-	"failed",
-	"cancelled"
-]);
-const publicClone = (value) => structuredClone(value);
-const asObject = (value) => value !== null && typeof value === "object" ? value : {};
-const ok = (value) => ({
-	ok: true,
-	value
-});
-const badRequest = (message) => ({
-	ok: false,
-	error: {
-		code: "bad-request",
-		message,
-		details: { issues: [] }
-	}
-});
-const accountStatusError = (message) => ({
-	ok: false,
-	error: {
-		code: "internal",
-		message,
-		details: { issues: [] }
-	}
-});
-const classifyAccountStatusError = (error) => {
-	const message = error instanceof Error ? error.message : "";
-	if (/malformed (?:OAuth|grant|account vault)|received a malformed OAuth|contains malformed OAuth/iu.test(message)) return ["credential-malformed", "Codex account credentials are malformed"];
-	if (/credential|account vault|readRecord|credential store|credentials service/iu.test(message)) return ["credential-unavailable", "Codex account credentials are unavailable"];
-	const code = typeof error?.code === "string" ? error.code.toUpperCase() : "";
-	if (error?.name === "TimeoutError" || [
-		"TIMEOUT",
-		"ETIMEDOUT",
-		"UND_ERR_CONNECT_TIMEOUT"
-	].includes(code)) return ["transport", "Codex account status service is unavailable"];
-	if ([
-		"ECONNRESET",
-		"ECONNREFUSED",
-		"ENOTFOUND",
-		"EAI_AGAIN",
-		"NETWORK",
-		"NETWORK_ERROR",
-		"TRANSPORT"
-	].includes(code) || error?.name === "NetworkError") return ["transport", "Codex account status service is unavailable"];
-	return ["unknown", "Could not read Codex account status"];
-};
-const deferred = () => {
-	let resolve;
-	let reject;
+/** Normalize the one non-secret account attribute that may cross the UI boundary. */
+function sanitizeOAuthCredential(value) {
+	const credential = assertOAuthCredential$1(value);
+	const email = emailFromAccessToken(credential.access) ?? normalizeAccountEmail(credential.email);
+	if (email === void 0) {
+		delete credential.email;
+		return credential;
+	}
 	return {
-		promise: new Promise((onResolve, onReject) => {
-			resolve = onResolve;
-			reject = onReject;
-		}),
-		resolve,
-		reject
+		...credential,
+		email
 	};
-};
-const publicPrompt = (prompt) => ({
-	type: prompt.type,
-	message: String(prompt.message ?? ""),
-	...typeof prompt.placeholder === "string" ? { placeholder: prompt.placeholder } : {}
-});
-function classifyLoginFailure(error) {
-	const message = error instanceof Error ? error.message : "";
-	if (/token exchange failed/iu.test(message)) return "token-exchange";
-	if (/fetch failed|\b(?:ECONN|ENOTFOUND|ETIMEDOUT|CERT_|socket|network)\b/iu.test(message)) return "network";
-	if (/extract accountId|account[_ -]?id/iu.test(message)) return "account-claim";
-	if (/credential|credentials-local|OAuth JSON/iu.test(message)) return "credential-store";
-	if (/Missing authorization code|State mismatch|callback/iu.test(message)) return "callback";
-	return "provider";
 }
-/** Own one host-side login without exposing tokens to the browser client. */
-var CodexLoginCoordinator = class {
-	#sessions = /* @__PURE__ */ new Map();
-	#activeId;
-	constructor(auth, options = {}) {
-		this.auth = auth;
-		this.createId = options.createId ?? (() => crypto.randomUUID());
-	}
-	async accountStatus(options) {
-		return publicClone(await this.auth.status(options));
+function assertOAuthCredential$1(value) {
+	if (value === null || typeof value !== "object" || value.type !== "oauth" || typeof value.access !== "string" || value.access.length === 0 || typeof value.refresh !== "string" || value.refresh.length === 0 || typeof value.expires !== "number" || !Number.isFinite(value.expires)) throw new Error("Codex account vault received a malformed OAuth credential");
+	return clone$1(value);
+}
+function parseOAuthCredential$1(value) {
+	try {
+		return assertOAuthCredential$1(JSON.parse(value));
+	} catch (error) {
+		if (error?.message === "Codex account vault received a malformed OAuth credential") throw error;
+		throw new Error("Codex account vault contains malformed OAuth JSON", { cause: error });
 	}
-	supportState() {
-		const active = this.#activeId === void 0 ? void 0 : this.#sessions.get(this.#activeId);
-		if (active === void 0) return { phase: "idle" };
+}
+function normalizeLabel(value) {
+	if (typeof value !== "string") throw new Error("Codex account label must be text");
+	const label = value.trim().replace(/\s+/gu, " ");
+	if (label.length === 0 || label.length > 48) throw new Error("Codex account label must contain 1 to 48 characters");
+	return label;
+}
+function assertVaultRecord(record) {
+	if (record?.kind !== "grant" || record.payload?.version !== VERSION || typeof record.payload.activeId !== "string" || !Array.isArray(record.payload.accounts) || record.payload.accounts.length === 0) throw new Error("Codex account vault contains a malformed grant record");
+	const ids = /* @__PURE__ */ new Set();
+	const accounts = record.payload.accounts.map((account) => {
+		if (account === null || typeof account !== "object" || typeof account.id !== "string" || account.id.length === 0 || ids.has(account.id)) throw new Error("Codex account vault contains a malformed account id");
+		ids.add(account.id);
 		return {
-			method: active.view.method,
-			phase: active.view.phase,
-			...active.view.phase === "failed" ? { failure: classifyLoginFailure(active.hostError) } : {}
+			id: account.id,
+			label: normalizeLabel(account.label),
+			credential: sanitizeOAuthCredential(account.credential)
 		};
+	});
+	if (!ids.has(record.payload.activeId)) throw new Error("Codex account vault active account is missing");
+	const legacyAccountId = record.payload.legacyAccountId;
+	if (legacyAccountId !== void 0 && !ids.has(legacyAccountId)) throw new Error("Codex account vault legacy account is missing");
+	return {
+		version: VERSION,
+		activeId: record.payload.activeId,
+		legacyAccountId,
+		accounts
+	};
+}
+const grant = (payload) => ({
+	kind: "grant",
+	payload
+});
+var PendingOAuthCredentialStore = class {
+	#credential;
+	async read(providerId) {
+		if (providerId !== "openai-codex") throw new Error("Pending Codex login received an unknown provider");
+		return clone$1(this.#credential);
 	}
-	async start({ method, label }) {
-		if (!LOGIN_METHODS.has(method)) throw new Error(`unsupported Codex login method: ${String(method)}`);
-		if (label !== void 0 && (typeof label !== "string" || label.trim().length === 0 || label.trim().length > 48)) throw new Error("unsupported Codex account label");
-		const active = this.#activeId === void 0 ? void 0 : this.#sessions.get(this.#activeId);
-		if (active !== void 0 && !TERMINAL_PHASES.has(active.view.phase)) {
-			active.view = {
-				id: active.view.id,
-				provider: "openai-codex",
-				method: active.view.method,
-				phase: "cancelled",
-				authenticated: false
+	async list() {
+		return this.#credential === void 0 ? [] : [{
+			providerId: "openai-codex",
+			type: "oauth"
+		}];
+	}
+	async modify(providerId, update) {
+		if (providerId !== "openai-codex") throw new Error("Pending Codex login received an unknown provider");
+		const next = await update(clone$1(this.#credential));
+		if (next !== void 0) this.#credential = sanitizeOAuthCredential(next);
+		return clone$1(this.#credential);
+	}
+	async delete(providerId) {
+		if (providerId !== "openai-codex") throw new Error("Pending Codex login received an unknown provider");
+		this.#credential = void 0;
+	}
+	credential() {
+		return clone$1(this.#credential);
+	}
+};
+/**
+* Multi-account owner state stored in DSH's atomic plugin credential record.
+* The old single-account reference remains as a rollback source and is kept in
+* sync whenever that imported account rotates its refresh token.
+*/
+var DshOAuthAccountVault = class {
+	#tail = Promise.resolve();
+	constructor(credentials, options) {
+		if (credentials === void 0 || credentials === null || typeof credentials.readRecord !== "function" || typeof credentials.modifyRecord !== "function") throw new Error("Codex multi-account requires DSH credential records");
+		this.credentials = credentials;
+		this.key = options.key;
+		this.legacyRef = options.legacyRef;
+		this.legacyRefs = Object.freeze([...options.legacyRefs ?? []]);
+		this.createId = options.createId ?? randomUUID;
+		this.onLegacySyncFailure = options.onLegacySyncFailure ?? (() => {});
+	}
+	#enqueue(operation) {
+		const current = this.#tail.catch(() => void 0).then(operation);
+		this.#tail = current.catch(() => void 0);
+		return current;
+	}
+	async #legacyCredential() {
+		for (const ref of [this.legacyRef, ...this.legacyRefs]) {
+			const hit = await this.credentials.resolve(ref);
+			if (hit?.value === void 0 || hit.value === "") continue;
+			return {
+				ref,
+				credential: parseOAuthCredential$1(hit.value)
 			};
-			active.controller.abort(/* @__PURE__ */ new Error("Codex login replaced by a new attempt"));
 		}
-		if (active !== void 0) this.#sessions.delete(active.view.id);
+	}
+	async #ensurePayload() {
+		const existing = await this.credentials.readRecord(this.key);
+		if (existing !== void 0) return assertVaultRecord(existing);
+		const legacy = await this.#legacyCredential();
+		if (legacy === void 0) return void 0;
 		const id = this.createId();
-		const ready = deferred();
-		const controller = new AbortController();
-		const session = {
-			controller,
-			prompt: void 0,
-			ready,
-			view: {
-				id,
-				provider: "openai-codex",
-				method,
-				phase: "starting",
-				authenticated: false
-			}
-		};
-		this.#sessions.set(id, session);
-		this.#activeId = id;
-		const publishReady = () => ready.resolve(publicClone(session.view));
-		const interaction = {
-			signal: controller.signal,
-			prompt: async (prompt) => {
-				controller.signal.throwIfAborted();
-				if (prompt.type === "select") return method;
-				if (![
-					"manual_code",
-					"text",
-					"secret"
-				].includes(prompt.type)) throw new Error(`unsupported Codex auth prompt: ${String(prompt.type)}`);
-				const answer = deferred();
-				session.prompt = answer;
-				session.view = {
-					...session.view,
-					phase: "waiting_input",
-					prompt: publicPrompt(prompt)
-				};
-				const abortPrompt = () => answer.reject(controller.signal.reason ?? /* @__PURE__ */ new Error("login cancelled"));
-				controller.signal.addEventListener("abort", abortPrompt, { once: true });
-				prompt.signal?.addEventListener("abort", abortPrompt, { once: true });
-				publishReady();
-				try {
-					return await answer.promise;
-				} finally {
-					controller.signal.removeEventListener("abort", abortPrompt);
-					prompt.signal?.removeEventListener("abort", abortPrompt);
-					if (session.prompt === answer) session.prompt = void 0;
-				}
-			},
-			notify: (event) => {
-				if (controller.signal.aborted) return;
-				if (event.type === "auth_url") session.view = {
-					...session.view,
-					phase: "waiting_browser",
-					authUrl: assertCodexAuthUrl(event.url),
-					...typeof event.instructions === "string" ? { instructions: event.instructions } : {}
-				};
-				else if (event.type === "device_code") session.view = {
-					...session.view,
-					phase: "waiting_device",
-					deviceCode: {
-						userCode: event.userCode,
-						verificationUri: assertCodexAuthUrl(event.verificationUri),
-						...typeof event.intervalSeconds === "number" ? { intervalSeconds: event.intervalSeconds } : {},
-						...typeof event.expiresInSeconds === "number" ? { expiresInSeconds: event.expiresInSeconds } : {}
-					}
-				};
-				else session.view = {
-					...session.view,
-					message: String(event.message ?? "")
-				};
-				publishReady();
-			}
-		};
-		session.run = Promise.resolve().then(() => this.auth.login(interaction, label === void 0 ? {} : { label: label.trim() })).then(async () => {
-			if (controller.signal.aborted) return;
-			const status = await this.auth.status();
-			session.view = {
+		return assertVaultRecord(await this.credentials.modifyRecord(this.key, (current) => {
+			if (current !== void 0) return Promise.resolve(current);
+			return Promise.resolve(grant({
+				version: VERSION,
+				activeId: id,
+				legacyAccountId: id,
+				accounts: [{
+					id,
+					label: DEFAULT_LABEL,
+					credential: legacy.credential
+				}]
+			}));
+		}));
+	}
+	async #modifyPayload(update) {
+		await this.#ensurePayload();
+		let previousLegacy;
+		const payload = assertVaultRecord(await this.credentials.modifyRecord(this.key, async (current) => {
+			if (current === void 0) throw new Error("Codex account vault is not signed in");
+			const payload = assertVaultRecord(current);
+			previousLegacy = payload.accounts.find((account) => account.id === payload.legacyAccountId)?.credential;
+			const next = await update(clone$1(payload));
+			return grant(next);
+		}));
+		const legacy = payload.accounts.find((account) => account.id === payload.legacyAccountId)?.credential;
+		try {
+			if (legacy === void 0) {
+				if (previousLegacy !== void 0) await this.credentials.unset(this.legacyRef);
+			} else if (JSON.stringify(legacy) !== JSON.stringify(previousLegacy)) await this.credentials.set(this.legacyRef, JSON.stringify(legacy));
+		} catch {
+			this.onLegacySyncFailure();
+		}
+		return payload;
+	}
+	list() {
+		return this.#enqueue(async () => {
+			const payload = await this.#ensurePayload();
+			if (payload === void 0) return [];
+			return payload.accounts.map((account) => ({
+				id: account.id,
+				label: account.label,
+				active: account.id === payload.activeId,
+				expiresAt: account.credential.expires,
+				...account.credential.email === void 0 ? {} : { email: account.credential.email }
+			}));
+		});
+	}
+	readActive() {
+		return this.#enqueue(async () => {
+			const payload = await this.#ensurePayload();
+			return clone$1(payload?.accounts.find((account) => account.id === payload.activeId)?.credential);
+		});
+	}
+	activeId() {
+		return this.#enqueue(async () => (await this.#ensurePayload())?.activeId);
+	}
+	add(label, credential) {
+		return this.#enqueue(async () => {
+			const normalizedLabel = normalizeLabel(label);
+			const validated = sanitizeOAuthCredential(credential);
+			await this.#ensurePayload();
+			const id = this.createId();
+			const account = (await this.#modifyPayload((current) => ({
+				...current,
+				activeId: id,
+				accounts: [...current.accounts, {
+					id,
+					label: normalizedLabel,
+					credential: validated
+				}]
+			}))).accounts.find((candidate) => candidate.id === id);
+			return {
 				id,
-				provider: "openai-codex",
-				method,
-				phase: "authenticated",
-				authenticated: status.authenticated === true,
-				...typeof status.expiresAt === "number" ? { expiresAt: status.expiresAt } : {}
+				label: account.label,
+				active: true,
+				expiresAt: account.credential.expires,
+				...account.credential.email === void 0 ? {} : { email: account.credential.email }
 			};
-		}).catch(async (error) => {
-			if (controller.signal.aborted) {
-				session.view = {
-					id,
-					provider: "openai-codex",
-					method,
-					phase: "cancelled",
-					authenticated: false
+		});
+	}
+	select(id) {
+		return this.#enqueue(async () => {
+			await this.#modifyPayload((current) => {
+				if (!current.accounts.some((account) => account.id === id)) throw new Error("Unknown Codex account");
+				return {
+					...current,
+					activeId: id
 				};
-				return;
+			});
+		});
+	}
+	modifyActive(update) {
+		return this.#enqueue(async () => {
+			if (await this.#ensurePayload() === void 0) {
+				const initial = await update(void 0);
+				if (initial === void 0) return void 0;
+				const credential = sanitizeOAuthCredential(initial);
+				await this.credentials.set(this.legacyRef, JSON.stringify(credential));
+				await this.#ensurePayload();
+				return clone$1(credential);
 			}
-			try {
-				if (label !== void 0) throw error;
-				const status = await this.auth.status();
-				if (status.authenticated === true) {
-					session.view = {
-						id,
-						provider: "openai-codex",
-						method,
-						phase: "authenticated",
-						authenticated: true,
-						...typeof status.expiresAt === "number" ? { expiresAt: status.expiresAt } : {}
-					};
-					return;
+			let result;
+			await this.#modifyPayload(async (current) => {
+				const index = current.accounts.findIndex((account) => account.id === current.activeId);
+				const previous = clone$1(current.accounts[index].credential);
+				const next = await update(previous);
+				if (next === void 0) {
+					result = previous;
+					return current;
 				}
-			} catch {}
-			session.view = {
-				id,
-				provider: "openai-codex",
-				method,
-				phase: "failed",
-				authenticated: false,
-				error: "Codex login failed"
-			};
-			session.hostError = error;
-		}).finally(publishReady);
-		return ready.promise;
+				const credential = sanitizeOAuthCredential(next);
+				if (credential.email === void 0 && previous.email !== void 0) credential.email = previous.email;
+				const accounts = [...current.accounts];
+				accounts[index] = {
+					...accounts[index],
+					credential
+				};
+				result = clone$1(credential);
+				return {
+					...current,
+					accounts
+				};
+			});
+			return result;
+		});
 	}
-	read(id) {
-		const session = this.#sessions.get(id);
-		if (session === void 0) throw new Error("unknown Codex login");
-		return publicClone(session.view);
+	deleteAll() {
+		return this.#enqueue(async () => {
+			await this.credentials.deleteRecord(this.key);
+			await this.credentials.unset(this.legacyRef);
+			for (const ref of this.legacyRefs) await this.credentials.unset(ref);
+		});
 	}
-	async submit({ id, value }) {
-		const session = this.#sessions.get(id);
-		if (session === void 0) throw new Error("unknown Codex login");
-		if (session.prompt === void 0 || session.view.phase !== "waiting_input") throw new Error("Codex login is not waiting for input");
-		if (typeof value !== "string" || value.trim() === "") throw new Error("Codex login input is empty");
-		const answer = session.prompt;
-		session.prompt = void 0;
-		session.view = {
-			...session.view,
-			phase: session.view.authUrl === void 0 ? "starting" : "waiting_browser",
-			prompt: void 0
-		};
-		answer.resolve(value);
-		return this.read(id);
+	remove(id) {
+		return this.#enqueue(async () => {
+			await this.#modifyPayload((current) => {
+				if (!current.accounts.some((account) => account.id === id)) throw new Error("Unknown Codex account");
+				if (current.accounts.length === 1) throw new Error("Cannot remove the last account; sign out instead");
+				const accounts = current.accounts.filter((account) => account.id !== id);
+				return {
+					...current,
+					activeId: current.activeId === id ? accounts[0].id : current.activeId,
+					legacyAccountId: current.legacyAccountId === id ? void 0 : current.legacyAccountId,
+					accounts
+				};
+			});
+		});
 	}
-	async cancel(id) {
-		const session = this.#sessions.get(id);
-		if (session === void 0) throw new Error("unknown Codex login");
-		if (!TERMINAL_PHASES.has(session.view.phase)) {
-			session.view = {
-				id,
-				provider: "openai-codex",
-				method: session.view.method,
-				phase: "cancelled",
-				authenticated: false
+};
+//#endregion
+//#region src/credential-store.js
+const PROVIDER$1 = "openai-codex";
+const abortIfNeeded = (options) => options?.signal?.throwIfAborted();
+const clone = (value) => value === void 0 ? void 0 : structuredClone(value);
+function assertProvider(providerId) {
+	if (providerId !== PROVIDER$1) throw new Error(`Codex credential store does not own provider ${JSON.stringify(providerId)}`);
+}
+function assertOAuthCredential(value) {
+	if (value === void 0) return void 0;
+	if (value === null || typeof value !== "object" || value.type !== "oauth" || typeof value.access !== "string" || value.access.length === 0 || typeof value.refresh !== "string" || value.refresh.length === 0 || typeof value.expires !== "number" || !Number.isFinite(value.expires)) throw new Error("Codex credential store received a malformed OAuth credential");
+	return clone(value);
+}
+function parseOAuthCredential(value) {
+	try {
+		return assertOAuthCredential(JSON.parse(value));
+	} catch (error) {
+		if (error?.message === "Codex credential store received a malformed OAuth credential") throw error;
+		throw new Error("Codex credential store contains malformed OAuth JSON", { cause: error });
+	}
+}
+/**
+* Adapt DSH's managed string credential service to pi-ai's typed OAuth store.
+* Refresh/login/logout operations are serialized so an older refresh response
+* cannot overwrite a newer rotated token.
+*/
+var DshOAuthCredentialStore = class {
+	#chains = /* @__PURE__ */ new Map();
+	constructor(credentials, ref, legacyRefs = [], options = {}) {
+		if (credentials === void 0 || credentials === null) throw new Error("Codex OAuth requires the DSH credentials service");
+		const expirySkewMs = options.expirySkewMs ?? 0;
+		if (!Number.isFinite(expirySkewMs) || expirySkewMs < 0) throw new Error("Codex OAuth expiry skew must be a non-negative finite number");
+		this.credentials = credentials;
+		this.ref = ref;
+		this.legacyRefs = Object.freeze([...legacyRefs]);
+		this.expirySkewMs = expirySkewMs;
+		this.vault = options.vault;
+	}
+	#enqueue(providerId, operation, options) {
+		assertProvider(providerId);
+		const current = (this.#chains.get(providerId) ?? Promise.resolve()).catch(() => void 0).then(async () => {
+			abortIfNeeded(options);
+			return operation();
+		});
+		const tail = current.catch(() => void 0);
+		this.#chains.set(providerId, tail);
+		tail.finally(() => {
+			if (this.#chains.get(providerId) === tail) this.#chains.delete(providerId);
+		});
+		return current;
+	}
+	async #read(providerId, options) {
+		assertProvider(providerId);
+		abortIfNeeded(options);
+		if (this.vault !== void 0) {
+			const current = await this.vault.readActive();
+			if (current === void 0) return void 0;
+			return this.expirySkewMs === 0 ? current : {
+				...current,
+				expires: current.expires - this.expirySkewMs
 			};
-			session.controller.abort(/* @__PURE__ */ new Error("Codex login cancelled"));
 		}
-		return this.read(id);
-	}
-	async logout(options) {
-		if (this.#activeId !== void 0) {
-			const active = this.#sessions.get(this.#activeId);
-			if (active !== void 0 && !TERMINAL_PHASES.has(active.view.phase)) await this.cancel(active.view.id);
+		let hit = await this.credentials.resolve(this.ref);
+		if (hit?.value === void 0 || hit.value === "") for (const legacyRef of this.legacyRefs) {
+			const legacy = await this.credentials.resolve(legacyRef);
+			if (legacy?.value === void 0 || legacy.value === "") continue;
+			const migrated = parseOAuthCredential(legacy.value);
+			await this.credentials.set(this.ref, JSON.stringify(migrated));
+			await this.credentials.unset(legacyRef);
+			hit = { value: JSON.stringify(migrated) };
+			break;
 		}
-		await this.auth.logout(options);
-		return this.accountStatus(options);
+		abortIfNeeded(options);
+		if (hit?.value === void 0 || hit.value === "") return void 0;
+		const credential = parseOAuthCredential(hit.value);
+		return this.expirySkewMs === 0 ? credential : {
+			...credential,
+			expires: credential.expires - this.expirySkewMs
+		};
 	}
-	async selectAccount(id) {
-		return publicClone(await this.auth.select(id));
+	read(providerId, options) {
+		return this.#enqueue(providerId, () => this.#read(providerId, options), options);
 	}
-	async removeAccount(id) {
-		return publicClone(await this.auth.remove(id));
+	async list(options) {
+		abortIfNeeded(options);
+		return await this.read(PROVIDER$1, options) === void 0 ? [] : [{
+			providerId: PROVIDER$1,
+			type: "oauth"
+		}];
 	}
-};
-/** Map the loopback-only DSH Connection channel onto the coordinator. */
-function createCodexRpcHandler(coordinator, options = {}) {
-	const openExternal = options.openExternal;
-	return async (endpoint, payload, signal) => {
-		try {
-			signal.throwIfAborted();
-			const input = asObject(payload);
-			if (endpoint === "status") try {
-				return ok(await coordinator.accountStatus({ signal }));
-			} catch (error) {
-				if (signal.aborted) throw error;
-				const [, message] = classifyAccountStatusError(error);
-				return accountStatusError(message);
-			}
-			if (endpoint === "login/start") {
-				const started = await coordinator.start({
-					method: input.method,
-					label: input.label
+	modify(providerId, update, options) {
+		return this.#enqueue(providerId, async () => {
+			if (this.vault !== void 0) {
+				const next = await this.vault.modifyActive(async (current) => {
+					const visible = current === void 0 || this.expirySkewMs === 0 ? current : {
+						...current,
+						expires: current.expires - this.expirySkewMs
+					};
+					const updated = await update(clone(visible));
+					return updated === void 0 ? void 0 : assertOAuthCredential(updated);
 				});
-				if (input.openExternal !== true) return ok(started);
-				const url = started.authUrl ?? started.deviceCode?.verificationUri;
-				if (typeof url !== "string" || openExternal === void 0) return ok({
-					...started,
-					externalOpened: false
+				abortIfNeeded(options);
+				return clone(next);
+			}
+			const current = await this.#read(providerId, options);
+			const next = await update(clone(current));
+			abortIfNeeded(options);
+			if (next === void 0) return current;
+			const validated = assertOAuthCredential(next);
+			await this.credentials.set(this.ref, JSON.stringify(validated));
+			for (const legacyRef of this.legacyRefs) await this.credentials.unset(legacyRef);
+			abortIfNeeded(options);
+			return clone(validated);
+		}, options);
+	}
+	delete(providerId, options) {
+		return this.#enqueue(providerId, async () => {
+			if (this.vault !== void 0) {
+				await this.vault.deleteAll();
+				abortIfNeeded(options);
+				return;
+			}
+			await this.credentials.unset(this.ref);
+			for (const legacyRef of this.legacyRefs) await this.credentials.unset(legacyRef);
+			abortIfNeeded(options);
+		}, options);
+	}
+};
+/** Return only account state that is safe to expose to the browser client. */
+function createCodexAuthService(models, store, options = {}) {
+	const runLogin = options.runLogin ?? ((run) => run());
+	const accountVault = options.accountVault;
+	const createLoginModels = options.createLoginModels;
+	const createPendingStore = options.createPendingStore ?? (() => new PendingOAuthCredentialStore());
+	return Object.freeze({
+		async status(options) {
+			const current = await store.read(PROVIDER$1, options);
+			const accounts = await accountVault?.list();
+			if (current === void 0) return {
+				authenticated: false,
+				provider: PROVIDER$1,
+				...accounts === void 0 ? {} : { accounts }
+			};
+			return {
+				authenticated: true,
+				provider: PROVIDER$1,
+				type: "oauth",
+				expiresAt: current.expires,
+				...accounts === void 0 ? {} : { accounts }
+			};
+		},
+		login(interaction, input = {}) {
+			if (input.label !== void 0) {
+				if (accountVault === void 0 || createLoginModels === void 0) throw new Error("Codex multi-account is unavailable");
+				return runLogin(async () => {
+					const pending = createPendingStore();
+					await createLoginModels(pending).login(PROVIDER$1, "oauth", interaction);
+					const credential = pending.credential();
+					if (credential === void 0) throw new Error("Codex login did not return credentials");
+					await accountVault.add(input.label, credential);
 				});
-				try {
-					await openExternal(url);
-					return ok({
-						...started,
-						externalOpened: true
-					});
-				} catch {
-					return ok({
-						...started,
-						externalOpened: false
-					});
-				}
 			}
-			if (endpoint === "login/status") return ok(coordinator.read(input.id));
-			if (endpoint === "login/submit") return ok(await coordinator.submit({
-				id: input.id,
-				value: input.value
-			}));
-			if (endpoint === "login/cancel") return ok(await coordinator.cancel(input.id));
-			if (endpoint === "logout") return ok(await coordinator.logout({ signal }));
-			if (endpoint === "account/select") return ok(await coordinator.selectAccount(input.id));
-			if (endpoint === "account/remove") return ok(await coordinator.removeAccount(input.id));
-			return badRequest(`unknown Codex auth endpoint: ${endpoint}`);
-		} catch (error) {
-			if (signal.aborted) throw error;
-			const message = error instanceof Error && /^(unknown|unsupported|a Codex|Codex login)/.test(error.message) ? error.message : "Codex request failed";
-			return badRequest(message);
+			return runLogin(() => models.login(PROVIDER$1, "oauth", interaction));
+		},
+		async select(id) {
+			if (accountVault === void 0) throw new Error("Codex multi-account is unavailable");
+			await accountVault.select(id);
+			return this.status();
+		},
+		async remove(id) {
+			if (accountVault === void 0) throw new Error("Codex multi-account is unavailable");
+			await accountVault.remove(id);
+			return this.status();
+		},
+		logout(options) {
+			return models.logout(PROVIDER$1, options);
 		}
-	};
-}
-//#endregion
-//#region src/oauth-network.js
-const execFileAsync = promisify(execFile);
-const CODEX_AUTH_HOST = "auth.openai.com";
-const CODEX_HOSTS = /* @__PURE__ */ new Set([CODEX_AUTH_HOST, "chatgpt.com"]);
-const networkScope = new AsyncLocalStorage();
-let activeScopes = 0;
-let baseFetch;
-let scopedFetch;
-function normalizeProxy(raw) {
-	if (typeof raw !== "string" || raw.trim() === "") return void 0;
-	const value = raw.trim().includes("://") ? raw.trim() : `http://${raw.trim()}`;
-	try {
-		const url = new URL(value);
-		if (!["http:", "https:"].includes(url.protocol) || url.hostname === "") return void 0;
-		return url.toString();
-	} catch {
-		return;
-	}
-}
-function bypassesProxy(hostname, port, rawNoProxy) {
-	if (typeof rawNoProxy !== "string" || rawNoProxy.trim() === "") return false;
-	return rawNoProxy.split(/[\s,]+/u).some((raw) => {
-		const entry = raw.trim().toLowerCase();
-		if (entry === "*") return true;
-		if (entry === "") return false;
-		const match = /^(.*?)(?::(\d+))?$/u.exec(entry);
-		const host = match?.[1]?.replace(/^\./u, "");
-		const entryPort = match?.[2];
-		if (!host || entryPort && entryPort !== port) return false;
-		return hostname === host || hostname.endsWith(`.${host}`);
 	});
 }
-function proxyFromEnvironment(env = process.env, target = new URL(`https://${CODEX_AUTH_HOST}/`)) {
-	if (bypassesProxy(target.hostname.toLowerCase(), target.port || "443", env.NO_PROXY ?? env.no_proxy)) return void 0;
-	return normalizeProxy(env.HTTPS_PROXY ?? env.https_proxy ?? env.ALL_PROXY ?? env.all_proxy);
-}
-function selectWindowsProxy(value) {
-	if (typeof value !== "string") return void 0;
-	const entries = value.split(";").map((item) => item.trim()).filter(Boolean);
-	const https = entries.find((item) => /^https=/iu.test(item));
-	const http = entries.find((item) => /^http=/iu.test(item));
-	const selected = (https ?? http ?? entries.find((item) => !item.includes("=")))?.replace(/^[^=]+=/u, "");
-	return normalizeProxy(selected);
-}
-async function windowsSystemProxy(options = {}) {
-	const run = options.execFile ?? execFileAsync;
-	const reg = `${process.env.SystemRoot ?? "C:\\Windows"}\\System32\\reg.exe`;
-	const key = "HKCU\\Software\\Microsoft\\Windows\\CurrentVersion\\Internet Settings";
-	try {
-		const enabled = await run(reg, [
-			"query",
-			key,
-			"/v",
-			"ProxyEnable"
-		], {
-			windowsHide: true,
-			encoding: "utf8"
-		});
-		if (!/REG_DWORD\s+0x1\b/iu.test(enabled.stdout)) return void 0;
-		const configured = await run(reg, [
-			"query",
-			key,
-			"/v",
-			"ProxyServer"
-		], {
-			windowsHide: true,
-			encoding: "utf8"
-		});
-		return selectWindowsProxy(/^\s*ProxyServer\s+REG_\w+\s+(.+)$/imu.exec(configured.stdout)?.[1]);
-	} catch {
-		return;
-	}
-}
-async function macSystemProxy(options = {}) {
-	const run = options.execFile ?? execFileAsync;
+//#endregion
+//#region src/external-url.js
+const OPENAI_AUTH_ORIGIN = "https://auth.openai.com";
+/** Validate the only external origin this plugin may launch. */
+function assertCodexAuthUrl(value) {
+	let url;
 	try {
-		const result = await run("/usr/sbin/scutil", ["--proxy"], { encoding: "utf8" });
-		if (!/^\s*HTTPSEnable\s*:\s*1\s*$/imu.test(result.stdout)) return void 0;
-		const host = /^\s*HTTPSProxy\s*:\s*(\S+)\s*$/imu.exec(result.stdout)?.[1];
-		const port = /^\s*HTTPSPort\s*:\s*(\d+)\s*$/imu.exec(result.stdout)?.[1];
-		return normalizeProxy(host && port ? `${host}:${port}` : void 0);
+		url = new URL(value);
 	} catch {
-		return;
+		throw new Error("Codex auth URL is invalid");
 	}
-}
-async function resolveCodexProxy(options = {}) {
-	const target = options.target ?? new URL(`https://${CODEX_AUTH_HOST}/`);
-	const env = options.env ?? process.env;
-	if (bypassesProxy(target.hostname.toLowerCase(), target.port || "443", env.NO_PROXY ?? env.no_proxy)) return {
-		url: void 0,
-		source: "bypass"
+	if (url.protocol !== "https:") throw new Error("Codex auth URL must use HTTPS");
+	if (url.origin !== OPENAI_AUTH_ORIGIN || url.username !== "" || url.password !== "") throw new Error("Codex auth URL must use the OpenAI auth origin");
+	return url.href;
+}
+/** Return a shell-free native opener command for the current desktop. */
+function commandForCodexAuthUrl(value, platform = process.platform) {
+	const url = assertCodexAuthUrl(value);
+	if (platform === "win32") return {
+		file: "rundll32.exe",
+		args: ["url.dll,FileProtocolHandler", url],
+		shell: false
 	};
-	const envProxy = proxyFromEnvironment(env, target);
-	if (envProxy) return {
-		url: envProxy,
-		source: "environment"
+	if (platform === "darwin") return {
+		file: "open",
+		args: [url],
+		shell: false
 	};
-	const platform = options.platform ?? process.platform;
-	const system = platform === "win32" ? await windowsSystemProxy(options) : platform === "darwin" ? await macSystemProxy(options) : void 0;
-	return system ? {
-		url: system,
-		source: "system"
-	} : {
-		url: void 0,
-		source: "direct"
+	if (platform === "linux") return {
+		file: "xdg-open",
+		args: [url],
+		shell: false
 	};
+	throw new Error(`Codex auth URL opener is unsupported on ${platform}`);
 }
-function bodyBytes(body) {
-	if (body === void 0 || body === null) return void 0;
-	if (typeof body === "string") return Buffer.from(body);
-	if (body instanceof URLSearchParams) return Buffer.from(body.toString());
-	if (body instanceof Uint8Array) return Buffer.from(body);
-	throw new TypeError("Unsupported Codex OAuth request body");
-}
-function fetchThroughProxy(input, init, proxyUrl) {
-	const target = new URL(typeof input === "string" || input instanceof URL ? input : input.url);
-	const body = bodyBytes(init?.body);
-	const headers = new Headers(init?.headers);
-	if (body && !headers.has("content-length")) headers.set("content-length", String(body.byteLength));
+function openCodexAuthUrl(value, options = {}) {
+	const command = commandForCodexAuthUrl(value, options.platform);
+	const spawnProcess = options.spawn ?? spawn;
 	return new Promise((resolve, reject) => {
-		const request$1 = request(target, {
-			method: init?.method ?? "GET",
-			headers: Object.fromEntries(headers.entries()),
-			agent: new HttpsProxyAgent(proxyUrl),
-			signal: init?.signal
-		}, (response) => {
-			const responseHeaders = new Headers();
-			for (const [name, value] of Object.entries(response.headers)) if (Array.isArray(value)) value.forEach((item) => responseHeaders.append(name, item));
-			else if (value !== void 0) responseHeaders.set(name, value);
-			const status = response.statusCode ?? 500;
-			const empty = init?.method === "HEAD" || [
-				204,
-				205,
-				304
-			].includes(status);
-			resolve(new Response(empty ? null : Readable.toWeb(response), {
-				status,
-				statusText: response.statusMessage,
-				headers: responseHeaders
-			}));
+		const child = spawnProcess(command.file, command.args, {
+			detached: true,
+			stdio: "ignore",
+			windowsHide: true,
+			shell: command.shell
+		});
+		child.once("error", reject);
+		child.once("spawn", () => {
+			child.unref();
+			resolve();
 		});
-		request$1.on("error", reject);
-		if (body) request$1.write(body);
-		request$1.end();
 	});
 }
-async function withCodexNetwork(run, options = {}) {
-	if (activeScopes === 0) {
-		baseFetch = globalThis.fetch;
-		scopedFetch = async (input, init) => {
-			const scope = networkScope.getStore();
-			if (scope === void 0) return baseFetch(input, init);
-			const { options: scopedOptions, allowedHosts, resolved } = scope;
-			const proxyFetch = scopedOptions.fetchThroughProxy ?? fetchThroughProxy;
-			const target = new URL(typeof input === "string" || input instanceof URL ? input : input.url);
-			if (target.protocol !== "https:" || !allowedHosts.has(target.hostname)) return baseFetch(input, init);
-			let proxy = resolved.get(target.hostname);
-			if (proxy === void 0) {
-				proxy = resolveCodexProxy({
-					...scopedOptions,
-					target
-				});
-				resolved.set(target.hostname, proxy);
+//#endregion
+//#region src/login-coordinator.js
+const LOGIN_METHODS = /* @__PURE__ */ new Set(["browser", "device_code"]);
+const TERMINAL_PHASES = /* @__PURE__ */ new Set([
+	"authenticated",
+	"failed",
+	"cancelled"
+]);
+const publicClone = (value) => structuredClone(value);
+const asObject = (value) => value !== null && typeof value === "object" ? value : {};
+const ok = (value) => ({
+	ok: true,
+	value
+});
+const badRequest = (message) => ({
+	ok: false,
+	error: {
+		code: "bad-request",
+		message,
+		details: { issues: [] }
+	}
+});
+const accountStatusError = (message) => ({
+	ok: false,
+	error: {
+		code: "internal",
+		message,
+		details: { issues: [] }
+	}
+});
+const classifyAccountStatusError = (error) => {
+	const message = error instanceof Error ? error.message : "";
+	if (/malformed (?:OAuth|grant|account vault)|received a malformed OAuth|contains malformed OAuth/iu.test(message)) return ["credential-malformed", "Codex account credentials are malformed"];
+	if (/credential|account vault|readRecord|credential store|credentials service/iu.test(message)) return ["credential-unavailable", "Codex account credentials are unavailable"];
+	const code = typeof error?.code === "string" ? error.code.toUpperCase() : "";
+	if (error?.name === "TimeoutError" || [
+		"TIMEOUT",
+		"ETIMEDOUT",
+		"UND_ERR_CONNECT_TIMEOUT"
+	].includes(code)) return ["transport", "Codex account status service is unavailable"];
+	if ([
+		"ECONNRESET",
+		"ECONNREFUSED",
+		"ENOTFOUND",
+		"EAI_AGAIN",
+		"NETWORK",
+		"NETWORK_ERROR",
+		"TRANSPORT"
+	].includes(code) || error?.name === "NetworkError") return ["transport", "Codex account status service is unavailable"];
+	return ["unknown", "Could not read Codex account status"];
+};
+const deferred = () => {
+	let resolve;
+	let reject;
+	return {
+		promise: new Promise((onResolve, onReject) => {
+			resolve = onResolve;
+			reject = onReject;
+		}),
+		resolve,
+		reject
+	};
+};
+const publicPrompt = (prompt) => ({
+	type: prompt.type,
+	message: String(prompt.message ?? ""),
+	...typeof prompt.placeholder === "string" ? { placeholder: prompt.placeholder } : {}
+});
+function classifyLoginFailure(error) {
+	const message = error instanceof Error ? error.message : "";
+	if (/token exchange failed/iu.test(message)) return "token-exchange";
+	if (/fetch failed|\b(?:ECONN|ENOTFOUND|ETIMEDOUT|CERT_|socket|network)\b/iu.test(message)) return "network";
+	if (/extract accountId|account[_ -]?id/iu.test(message)) return "account-claim";
+	if (/credential|credentials-local|OAuth JSON/iu.test(message)) return "credential-store";
+	if (/Missing authorization code|State mismatch|callback/iu.test(message)) return "callback";
+	return "provider";
+}
+/** Own one host-side login without exposing tokens to the browser client. */
+var CodexLoginCoordinator = class {
+	#sessions = /* @__PURE__ */ new Map();
+	#activeId;
+	constructor(auth, options = {}) {
+		this.auth = auth;
+		this.createId = options.createId ?? (() => crypto.randomUUID());
+	}
+	async accountStatus(options) {
+		return publicClone(await this.auth.status(options));
+	}
+	supportState() {
+		const active = this.#activeId === void 0 ? void 0 : this.#sessions.get(this.#activeId);
+		if (active === void 0) return { phase: "idle" };
+		return {
+			method: active.view.method,
+			phase: active.view.phase,
+			...active.view.phase === "failed" ? { failure: classifyLoginFailure(active.hostError) } : {}
+		};
+	}
+	async start({ method, label }) {
+		if (!LOGIN_METHODS.has(method)) throw new Error(`unsupported Codex login method: ${String(method)}`);
+		if (label !== void 0 && (typeof label !== "string" || label.trim().length === 0 || label.trim().length > 48)) throw new Error("unsupported Codex account label");
+		const active = this.#activeId === void 0 ? void 0 : this.#sessions.get(this.#activeId);
+		if (active !== void 0 && !TERMINAL_PHASES.has(active.view.phase)) {
+			active.view = {
+				id: active.view.id,
+				provider: "openai-codex",
+				method: active.view.method,
+				phase: "cancelled",
+				authenticated: false
+			};
+			active.controller.abort(/* @__PURE__ */ new Error("Codex login replaced by a new attempt"));
+		}
+		if (active !== void 0) this.#sessions.delete(active.view.id);
+		const id = this.createId();
+		const ready = deferred();
+		const controller = new AbortController();
+		const session = {
+			controller,
+			prompt: void 0,
+			ready,
+			view: {
+				id,
+				provider: "openai-codex",
+				method,
+				phase: "starting",
+				authenticated: false
+			}
+		};
+		this.#sessions.set(id, session);
+		this.#activeId = id;
+		const publishReady = () => ready.resolve(publicClone(session.view));
+		const interaction = {
+			signal: controller.signal,
+			prompt: async (prompt) => {
+				controller.signal.throwIfAborted();
+				if (prompt.type === "select") return method;
+				if (![
+					"manual_code",
+					"text",
+					"secret"
+				].includes(prompt.type)) throw new Error(`unsupported Codex auth prompt: ${String(prompt.type)}`);
+				const answer = deferred();
+				session.prompt = answer;
+				session.view = {
+					...session.view,
+					phase: "waiting_input",
+					prompt: publicPrompt(prompt)
+				};
+				const abortPrompt = () => answer.reject(controller.signal.reason ?? /* @__PURE__ */ new Error("login cancelled"));
+				controller.signal.addEventListener("abort", abortPrompt, { once: true });
+				prompt.signal?.addEventListener("abort", abortPrompt, { once: true });
+				publishReady();
+				try {
+					return await answer.promise;
+				} finally {
+					controller.signal.removeEventListener("abort", abortPrompt);
+					prompt.signal?.removeEventListener("abort", abortPrompt);
+					if (session.prompt === answer) session.prompt = void 0;
+				}
+			},
+			notify: (event) => {
+				if (controller.signal.aborted) return;
+				if (event.type === "auth_url") session.view = {
+					...session.view,
+					phase: "waiting_browser",
+					authUrl: assertCodexAuthUrl(event.url),
+					...typeof event.instructions === "string" ? { instructions: event.instructions } : {}
+				};
+				else if (event.type === "device_code") session.view = {
+					...session.view,
+					phase: "waiting_device",
+					deviceCode: {
+						userCode: event.userCode,
+						verificationUri: assertCodexAuthUrl(event.verificationUri),
+						...typeof event.intervalSeconds === "number" ? { intervalSeconds: event.intervalSeconds } : {},
+						...typeof event.expiresInSeconds === "number" ? { expiresInSeconds: event.expiresInSeconds } : {}
+					}
+				};
+				else session.view = {
+					...session.view,
+					message: String(event.message ?? "")
+				};
+				publishReady();
 			}
-			const route = await proxy;
-			scopedOptions.onRoute?.(route.source);
-			return route.url === void 0 ? baseFetch(input, init) : proxyFetch(input, init, route.url);
 		};
-		globalThis.fetch = scopedFetch;
+		session.run = Promise.resolve().then(() => this.auth.login(interaction, label === void 0 ? {} : { label: label.trim() })).then(async () => {
+			if (controller.signal.aborted) return;
+			const status = await this.auth.status();
+			session.view = {
+				id,
+				provider: "openai-codex",
+				method,
+				phase: "authenticated",
+				authenticated: status.authenticated === true,
+				...typeof status.expiresAt === "number" ? { expiresAt: status.expiresAt } : {}
+			};
+		}).catch(async (error) => {
+			if (controller.signal.aborted) {
+				session.view = {
+					id,
+					provider: "openai-codex",
+					method,
+					phase: "cancelled",
+					authenticated: false
+				};
+				return;
+			}
+			try {
+				if (label !== void 0) throw error;
+				const status = await this.auth.status();
+				if (status.authenticated === true) {
+					session.view = {
+						id,
+						provider: "openai-codex",
+						method,
+						phase: "authenticated",
+						authenticated: true,
+						...typeof status.expiresAt === "number" ? { expiresAt: status.expiresAt } : {}
+					};
+					return;
+				}
+			} catch {}
+			session.view = {
+				id,
+				provider: "openai-codex",
+				method,
+				phase: "failed",
+				authenticated: false,
+				error: "Codex login failed"
+			};
+			session.hostError = error;
+		}).finally(publishReady);
+		return ready.promise;
 	}
-	activeScopes += 1;
-	const scope = {
-		options,
-		allowedHosts: options.hosts ?? CODEX_HOSTS,
-		resolved: /* @__PURE__ */ new Map()
-	};
-	try {
-		return await networkScope.run(scope, run);
-	} finally {
-		activeScopes -= 1;
-		if (activeScopes === 0) {
-			if (globalThis.fetch === scopedFetch) globalThis.fetch = baseFetch;
-			baseFetch = void 0;
-			scopedFetch = void 0;
+	read(id) {
+		const session = this.#sessions.get(id);
+		if (session === void 0) throw new Error("unknown Codex login");
+		return publicClone(session.view);
+	}
+	async submit({ id, value }) {
+		const session = this.#sessions.get(id);
+		if (session === void 0) throw new Error("unknown Codex login");
+		if (session.prompt === void 0 || session.view.phase !== "waiting_input") throw new Error("Codex login is not waiting for input");
+		if (typeof value !== "string" || value.trim() === "") throw new Error("Codex login input is empty");
+		const answer = session.prompt;
+		session.prompt = void 0;
+		session.view = {
+			...session.view,
+			phase: session.view.authUrl === void 0 ? "starting" : "waiting_browser",
+			prompt: void 0
+		};
+		answer.resolve(value);
+		return this.read(id);
+	}
+	async cancel(id) {
+		const session = this.#sessions.get(id);
+		if (session === void 0) throw new Error("unknown Codex login");
+		if (!TERMINAL_PHASES.has(session.view.phase)) {
+			session.view = {
+				id,
+				provider: "openai-codex",
+				method: session.view.method,
+				phase: "cancelled",
+				authenticated: false
+			};
+			session.controller.abort(/* @__PURE__ */ new Error("Codex login cancelled"));
 		}
+		return this.read(id);
 	}
-}
-function classifyTransportError(error) {
-	const name = error?.name;
-	const code = String(error?.code ?? error?.cause?.code ?? "");
-	if (name === "AbortError" || name === "TimeoutError" || /ETIMEDOUT|UND_ERR_CONNECT_TIMEOUT/u.test(code)) return "timeout";
-	if (/ENOTFOUND|EAI_AGAIN/u.test(code)) return "dns";
-	if (/CERT_|TLS|SSL/u.test(code)) return "tls";
-	if (/ECONN|EPIPE|UND_ERR_SOCKET/u.test(code)) return "connection";
-	return "network";
-}
-const elapsedBucket = (elapsed) => elapsed < 1e3 ? "under-1s" : elapsed < 5e3 ? "1-5s" : elapsed < 15e3 ? "5-15s" : "over-15s";
-function createCodexNetworkTransport(options = {}) {
-	const attempts = /* @__PURE__ */ new Map();
-	const now = options.now ?? Date.now;
-	const run = async (area, operation) => {
-		const startedAt = now();
-		let route = attempts.get(area)?.route ?? "direct";
-		let routed = false;
+	async logout(options) {
+		if (this.#activeId !== void 0) {
+			const active = this.#sessions.get(this.#activeId);
+			if (active !== void 0 && !TERMINAL_PHASES.has(active.view.phase)) await this.cancel(active.view.id);
+		}
+		await this.auth.logout(options);
+		return this.accountStatus(options);
+	}
+	async selectAccount(id) {
+		return publicClone(await this.auth.select(id));
+	}
+	async removeAccount(id) {
+		return publicClone(await this.auth.remove(id));
+	}
+};
+/** Map the loopback-only DSH Connection channel onto the coordinator. */
+function createCodexRpcHandler(coordinator, options = {}) {
+	const openExternal = options.openExternal;
+	return async (endpoint, payload, signal) => {
 		try {
-			const value = await withCodexNetwork(operation, {
-				...options,
-				onRoute: (source) => {
-					route = source;
-					routed = true;
+			signal.throwIfAborted();
+			const input = asObject(payload);
+			if (endpoint === "status") try {
+				return ok(await coordinator.accountStatus({ signal }));
+			} catch (error) {
+				if (signal.aborted) throw error;
+				const [, message] = classifyAccountStatusError(error);
+				return accountStatusError(message);
+			}
+			if (endpoint === "login/start") {
+				const started = await coordinator.start({
+					method: input.method,
+					label: input.label
+				});
+				if (input.openExternal !== true) return ok(started);
+				const url = started.authUrl ?? started.deviceCode?.verificationUri;
+				if (typeof url !== "string" || openExternal === void 0) return ok({
+					...started,
+					externalOpened: false
+				});
+				try {
+					await openExternal(url);
+					return ok({
+						...started,
+						externalOpened: true
+					});
+				} catch {
+					return ok({
+						...started,
+						externalOpened: false
+					});
 				}
-			});
-			if (value instanceof Response && !value.ok) attempts.set(area, {
-				status: "failed",
-				stage: "http",
-				code: "http-error",
-				httpStatus: value.status,
-				route,
-				elapsed: elapsedBucket(now() - startedAt)
-			});
-			else if (routed || value instanceof Response) attempts.set(area, {
-				status: "ok",
-				route,
-				elapsed: elapsedBucket(now() - startedAt)
-			});
-			return value;
+			}
+			if (endpoint === "login/status") return ok(coordinator.read(input.id));
+			if (endpoint === "login/submit") return ok(await coordinator.submit({
+				id: input.id,
+				value: input.value
+			}));
+			if (endpoint === "login/cancel") return ok(await coordinator.cancel(input.id));
+			if (endpoint === "logout") return ok(await coordinator.logout({ signal }));
+			if (endpoint === "account/select") return ok(await coordinator.selectAccount(input.id));
+			if (endpoint === "account/remove") return ok(await coordinator.removeAccount(input.id));
+			return badRequest(`unknown Codex auth endpoint: ${endpoint}`);
 		} catch (error) {
-			if (routed) attempts.set(area, {
-				status: "failed",
-				stage: "transport",
-				code: classifyTransportError(error),
-				route,
-				elapsed: elapsedBucket(now() - startedAt)
-			});
-			throw error;
+			if (signal.aborted) throw error;
+			const message = error instanceof Error && /^(unknown|unsupported|a Codex|Codex login)/.test(error.message) ? error.message : "Codex request failed";
+			return badRequest(message);
 		}
 	};
-	return Object.freeze({
-		run,
-		fetch: (area, input, init) => run(area, () => globalThis.fetch(input, init)),
-		snapshot: () => Object.fromEntries([...attempts].map(([area, value]) => [area, { ...value }]))
-	});
 }
 //#endregion
 //#region src/pi-ai-runtime.js
@@ -1912,7 +2297,7 @@ const FAST_SERVICE_TIER = "priority";
 * persistence, headers, transport, and model behavior remain owned by the
 * original provider.
 */
-function openaiCodexSubscriptionProvider({ resolveSpeedMode = () => void 0, resolveOutputVerbosity = () => OUTPUT_VERBOSITY_DEFAULT, resolveContextMode = () => void 0, resolveCustomContextWindow = () => void 0, catalog, runNetwork = (_area, operation) => operation() } = {}) {
+function openaiCodexSubscriptionProvider({ resolveSpeedMode = () => void 0, resolveOutputVerbosity = () => OUTPUT_VERBOSITY_DEFAULT, resolveContextMode = () => void 0, resolveCustomContextWindow = () => void 0, catalog, connection, runNetwork = (_area, operation) => operation() } = {}) {
 	const provider = createOpenAICodexProvider();
 	const requestToken = Object.freeze({
 		name: "DSH-managed Codex OAuth request token",
@@ -1975,19 +2360,29 @@ function openaiCodexSubscriptionProvider({ resolveSpeedMode = () => void 0, reso
 			contextWindow: requested
 		};
 	});
-	const networkIterable = (factory) => {
+	const networkIterable = (factory, options) => {
 		let iterator;
-		const getIterator = () => iterator ??= factory()[Symbol.asyncIterator]();
+		let prepared;
+		const step = async (method, value) => {
+			const request = await (prepared ??= connection?.prepare(options) ?? Promise.resolve({ options }));
+			return runNetwork("model", () => {
+				iterator ??= factory(request.options)[Symbol.asyncIterator]();
+				return iterator[method]?.(value) ?? (method === "throw" ? Promise.reject(value) : Promise.resolve({
+					done: true,
+					value
+				}));
+			}, request.network);
+		};
 		return {
 			[Symbol.asyncIterator]() {
 				return this;
 			},
-			next: (value) => runNetwork("model", () => getIterator().next(value)),
-			return: (value) => runNetwork("model", () => getIterator().return?.(value) ?? Promise.resolve({
+			next: (value) => step("next", value),
+			return: (value) => iterator ? step("return", value) : Promise.resolve({
 				done: true,
 				value
-			})),
-			throw: (error) => runNetwork("model", () => getIterator().throw?.(error) ?? Promise.reject(error))
+			}),
+			throw: (error) => iterator ? step("throw", error) : Promise.reject(error)
 		};
 	};
 	return Object.freeze({
@@ -1997,14 +2392,14 @@ function openaiCodexSubscriptionProvider({ resolveSpeedMode = () => void 0, reso
 			apiKey: requestToken
 		}),
 		getModels,
-		stream: (model, context, options) => networkIterable(() => provider.stream(model, context, withPreferences(model, options))),
-		streamSimple: (model, context, options) => networkIterable(() => provider.streamSimple(model, context, withPreferences(model, options)))
+		stream: (model, context, options) => networkIterable((prepared) => provider.stream(model, context, prepared), withPreferences(model, options)),
+		streamSimple: (model, context, options) => networkIterable((prepared) => provider.streamSimple(model, context, prepared), withPreferences(model, options))
 	});
 }
 Object.freeze(["0.82.1", "0.85.1"]);
 //#endregion
 //#region src/version.js
-const PACKAGE_VERSION = "2.1.0";
+const PACKAGE_VERSION = "2.1.1-beta.1";
 const USER_AGENT = `dsh-codex-subscription/${PACKAGE_VERSION}`;
 //#endregion
 //#region src/model-catalog.js
@@ -2029,13 +2424,35 @@ function reasoningMap(levels) {
 	for (const level of LEVELS.slice(1)) if (supported.has(level)) map[level] = level;
 	return map;
 }
+const capabilityNames = (values) => [...new Set(values.filter((value) => typeof value === "string" && /^[a-z][a-z0-9_-]{0,31}$/u.test(value)))].sort().slice(0, 16);
+function unsupportedCapabilities(value) {
+	const reasoning = capabilityNames((value.supported_reasoning_levels ?? []).map((item) => item?.effort)).filter((level) => !["none", ...LEVELS.slice(1)].includes(level));
+	const inputs = capabilityNames(Array.isArray(value.input_modalities) ? value.input_modalities : []).filter((input) => !["text", "image"].includes(input));
+	const speeds = capabilityNames([...Array.isArray(value.additional_speed_tiers) ? value.additional_speed_tiers : [], ...Array.isArray(value.service_tiers) ? value.service_tiers.map((tier) => tier?.id) : []]).filter((tier) => ![
+		"auto",
+		"default",
+		"standard",
+		"fast",
+		"priority"
+	].includes(tier));
+	return {
+		...reasoning.length ? { reasoning } : {},
+		...inputs.length ? { inputs } : {},
+		...speeds.length ? { speeds } : {}
+	};
+}
 function visibleModel(value) {
 	if (!record$4(value)) return void 0;
 	const id = nonEmpty$2(value.slug);
 	if (id === void 0 || value.visibility !== "list") return void 0;
 	const supported = Array.isArray(value.supported_reasoning_levels) ? value.supported_reasoning_levels : [];
 	const input = Array.isArray(value.input_modalities) ? value.input_modalities.filter((item) => ["text", "image"].includes(item)) : ["text", "image"];
+	const unsupported = unsupportedCapabilities({
+		...value,
+		supported_reasoning_levels: supported
+	});
 	return {
+		...Object.keys(unsupported).length ? { unsupported } : {},
 		id,
 		name: nonEmpty$2(value.display_name) ?? id,
 		description: nonEmpty$2(value.description),
@@ -2179,6 +2596,10 @@ function createOfficialModelCatalog(options = {}) {
 		getModels: (fallback) => models ?? fallback,
 		metadata: (modelId) => metadata.get(modelId),
 		revision: () => revision,
+		capabilityGaps: () => [...metadata.values()].filter((model) => model.unsupported && /^[a-z][a-z0-9._-]{0,79}$/u.test(model.id)).slice(0, 20).map((model) => ({
+			model: model.id,
+			...structuredClone(model.unsupported)
+		})),
 		status: () => ({
 			source: models === void 0 ? "fallback" : "online",
 			refresh: refreshStatus
@@ -3081,6 +3502,22 @@ async function createSubscriptionDiagnostics({ auth, preferences, login = { phas
 	}
 	const preference = preferences.status();
 	const catalog = modelCatalog?.status?.();
+	const gaps = (modelCatalog?.capabilityGaps?.() ?? []).slice(0, 20).flatMap((value) => {
+		if (!value || typeof value.model !== "string" || !/^[a-z][a-z0-9._-]{0,79}$/u.test(value.model)) return [];
+		const fields = Object.fromEntries([
+			"reasoning",
+			"inputs",
+			"speeds"
+		].flatMap((key) => {
+			const names = [...new Set((Array.isArray(value[key]) ? value[key] : []).filter((name) => typeof name === "string" && /^[a-z][a-z0-9_-]{0,31}$/u.test(name)))].slice(0, 16);
+			return names.length ? [[key, names]] : [];
+		}));
+		return Object.keys(fields).length ? [{
+			model: value.model,
+			...fields
+		}] : [];
+	});
+	if (gaps.length) issues.push({ code: "catalog-capabilities-not-adapted" });
 	return {
 		schemaVersion: 3,
 		package: "dsh-codex-subscription",
@@ -3100,7 +3537,8 @@ async function createSubscriptionDiagnostics({ auth, preferences, login = { phas
 			"failed"
 		].includes(catalog.refresh) ? { catalog: {
 			source: catalog.source,
-			refresh: catalog.refresh
+			refresh: catalog.refresh,
+			...gaps.length ? { unsupported: gaps } : {}
 		} } : {},
 		configuration: {
 			contextMode: preference.contextMode,
@@ -4226,13 +4664,17 @@ function apply(ctx) {
 	});
 	const baseProvider = createOpenAICodexProvider();
 	let resolveAuth = async () => void 0;
+	let subagentBackend;
 	const modelCatalog = createOfficialModelCatalog({
 		getAuth: (options) => resolveAuth(options),
 		readCredential: (options) => store.read(PROVIDER, options),
 		baseModels: () => baseProvider.getModels(),
 		fetch: (input, init) => network.fetch("catalog", input, init)
 	});
+	const connection = createSubscriptionConnection({ resolveMode: () => settings.get().connectionMode });
+	ctx.effect(() => () => connection.dispose());
 	const provider = openaiCodexSubscriptionProvider({
+		connection,
 		resolveSpeedMode: () => settings.get()[SPEED_MODE_FIELD],
 		resolveOutputVerbosity: () => normalizeOutputVerbosity(settings.get()[OUTPUT_VERBOSITY_FIELD]),
 		resolveContextMode: () => normalizeContextMode(settings.get()[CONTEXT_MODE_FIELD]),
@@ -4248,6 +4690,9 @@ function apply(ctx) {
 	});
 	const preferences = {
 		status: () => ({
+			connectionMode: settings.get().connectionMode ?? "sse",
+			subagentBackend: settings.get().subagentBackend ?? "dsh",
+			subagentBackendAvailable: subagentBackend !== void 0,
 			...readCapabilitySettings(settings.get()),
 			[QUICK_QUOTA_MODE_FIELD]: normalizeQuickQuotaMode(settings.get()[QUICK_QUOTA_MODE_FIELD], settings.get()[LEGACY_QUICK_QUOTA_FIELD]),
 			[SEARCH_PROVIDER_FIELD]: settings.get()[SEARCH_PROVIDER_FIELD],
@@ -4262,7 +4707,15 @@ function apply(ctx) {
 			fastModels: provider.getModels().filter((model) => modelCatalog.metadata(model.id)?.supportsFast ?? supportsCodexFastMode(model.id)).map((model) => model.id),
 			writable: ctx.settings.writable
 		}),
-		update: (patch) => settings.update(patch)
+		update: async (patch) => {
+			if (Object.hasOwn(patch, "subagentBackend")) {
+				if (!subagentBackend) throw new Error("DSH subagent services are unavailable");
+				await subagentBackend.select(patch.subagentBackend);
+			}
+			const rest = { ...patch };
+			delete rest.subagentBackend;
+			if (Object.keys(rest).length) await settings.update(rest);
+		}
 	};
 	const authModels = createModels({ credentials: store });
 	authModels.setProvider(provider);
@@ -4295,6 +4748,53 @@ function apply(ctx) {
 		return profileSnapshot;
 	};
 	resolveAuth = () => authModels.getAuth(PROVIDER);
+	ctx.inject([
+		"subagents",
+		"subprocess",
+		"sandboxPolicy"
+	], (scoped) => {
+		const instance = createSubscriptionSubagent({
+			ctx: scoped,
+			nativeHome: dshHomePath("state", "codex-subscription", "native-subagent"),
+			resolveAuth,
+			store,
+			refresh: (credential) => network.run("oauth", () => baseProvider.auth.oauth.refresh(credential)),
+			loadRuntime: loadSubagentRuntime
+		});
+		scoped.subagents.registerProvider(instance.provider);
+		const switcher = createSubagentBackendSwitcher({
+			entries: () => scoped.loader.entries(),
+			prepare: instance.prepare,
+			persist: (mode) => settings.update({ subagentBackend: mode })
+		});
+		const unconfigure = scoped.on("internal/config", function(_config, next) {
+			return switcher.configure(this, next());
+		}, { global: true });
+		let requested = "dsh";
+		const select = async (mode) => {
+			requested = mode;
+			try {
+				await switcher.select(mode);
+			} catch (error) {
+				requested = settings.get().subagentBackend ?? "dsh";
+				throw error;
+			}
+		};
+		subagentBackend = { select };
+		const sync = (value) => {
+			const mode = value.subagentBackend ?? "dsh";
+			if (mode !== requested) select(mode).catch(() => scoped.logger.warn("Could not switch the subscription subagent backend"));
+		};
+		scoped.loader.await().then(() => sync(settings.get())).catch(() => scoped.logger.warn("Could not initialize the subscription subagent backend"));
+		const unwatch = settings.watch(sync);
+		scoped.effect(() => async () => {
+			unwatch();
+			unconfigure();
+			subagentBackend = void 0;
+			instance.dispose();
+			await switcher.dispose();
+		}, "codex-subscription: subagent backend");
+	});
 	const adapterAuth = Object.freeze({
 		credentials: store,
 		authContext: Object.freeze({