pockcode 0.0.1

package/dist/assets/chats.service-H6m23Fna.js

@@ -0,0 +1,4684 @@
+import { i as publishProviderEvent, l as HttpError } from "./socket.server-7dC-9Fnw.js";
+import { a as resolveProviderDataHome, i as resolvePockcodeDatabasePath, n as resolveHomePath, o as sqliteDatabaseUrl, t as ensureParentDirectory } from "./runtime-paths.server-D6rRjGVb.js";
+import { createRequire } from "node:module";
+import { chmodSync, mkdirSync } from "node:fs";
+import { copyFile, mkdir, open, readFile, readdir, rm, stat, writeFile } from "node:fs/promises";
+import { dirname, join, relative, resolve } from "node:path";
+import { randomUUID } from "node:crypto";
+import "dotenv/config";
+import { PrismaClient } from "@prisma/client";
+import { execFile, spawn } from "node:child_process";
+//#region app/server/prisma.server.ts
+var globalForPrisma = globalThis;
+var databasePath = resolvePockcodeDatabasePath();
+process.env.DATABASE_URL = sqliteDatabaseUrl(databasePath);
+ensureParentDirectory(databasePath);
+var cachedPrisma = globalForPrisma.prisma;
+var prisma = cachedPrisma && hasCurrentPrismaDelegates(cachedPrisma) ? cachedPrisma : createPrismaClient();
+if (cachedPrisma && cachedPrisma !== prisma) cachedPrisma.$disconnect().catch(() => void 0);
+function createPrismaClient() {
+	return new PrismaClient({ datasources: { db: { url: process.env.DATABASE_URL } } });
+}
+function hasCurrentPrismaDelegates(client) {
+	const maybeClient = client;
+	return Boolean(maybeClient.mcpServer && maybeClient.mcpServerInstallation);
+}
+if (process.env.NODE_ENV !== "production") globalForPrisma.prisma = prisma;
+//#endregion
+//#region app/server/database.server.ts
+var ensurePromise = null;
+function ensureDatabase() {
+	ensurePromise ??= setupDatabase();
+	return ensurePromise;
+}
+async function setupDatabase() {
+	await prisma.$executeRawUnsafe("PRAGMA foreign_keys = ON");
+	await prisma.$queryRawUnsafe("PRAGMA journal_mode = WAL");
+	await prisma.$queryRawUnsafe("PRAGMA busy_timeout = 30000");
+	for (const statement of schemaStatements) await prisma.$executeRawUnsafe(statement);
+	await ensureWorkspaceHistoryIds();
+}
+async function ensureWorkspaceHistoryIds() {
+	if (!(await prisma.$queryRawUnsafe(`PRAGMA table_info("WorkspaceHistory")`)).some((column) => column.name === "id")) await prisma.$executeRawUnsafe(`ALTER TABLE "WorkspaceHistory" ADD COLUMN "id" TEXT`);
+	const rows = await prisma.$queryRawUnsafe(`SELECT "path", "id" FROM "WorkspaceHistory" WHERE "id" IS NULL OR "id" = ''`);
+	for (const row of rows) await prisma.$executeRawUnsafe(`UPDATE "WorkspaceHistory" SET "id" = ? WHERE "path" = ?`, randomUUID(), row.path);
+	await prisma.$executeRawUnsafe(`CREATE UNIQUE INDEX IF NOT EXISTS "WorkspaceHistory_id_key" ON "WorkspaceHistory"("id")`);
+}
+var schemaStatements = [
+	`CREATE TABLE IF NOT EXISTS "ProviderSetting" (
+    "providerId" TEXT NOT NULL PRIMARY KEY,
+    "settings" JSONB NOT NULL DEFAULT '{}',
+    "createdAt" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updatedAt" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP
+  )`,
+	`CREATE TABLE IF NOT EXISTS "PluginSetting" (
+    "pluginId" TEXT NOT NULL PRIMARY KEY,
+    "enabled" BOOLEAN NOT NULL DEFAULT false,
+    "settings" JSONB NOT NULL DEFAULT '{}',
+    "secrets" JSONB NOT NULL DEFAULT '{}',
+    "createdAt" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updatedAt" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP
+  )`,
+	`CREATE TABLE IF NOT EXISTS "PluginState" (
+    "pluginId" TEXT NOT NULL PRIMARY KEY,
+    "state" JSONB NOT NULL DEFAULT '{}',
+    "createdAt" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updatedAt" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP
+  )`,
+	`CREATE TABLE IF NOT EXISTS "ProviderAccount" (
+    "id" TEXT NOT NULL PRIMARY KEY,
+    "providerId" TEXT NOT NULL,
+    "displayName" TEXT NOT NULL,
+    "status" TEXT NOT NULL DEFAULT 'DISCONNECTED',
+    "settings" JSONB NOT NULL DEFAULT '{}',
+    "runtimeDefaults" JSONB NOT NULL DEFAULT '{}',
+    "authState" JSONB,
+    "lastAuthUrl" TEXT,
+    "lastAuthMode" TEXT,
+    "lastAuthLoginId" TEXT,
+    "lastAuthUserCode" TEXT,
+    "lastError" TEXT,
+    "createdAt" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updatedAt" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP
+  )`,
+	`CREATE INDEX IF NOT EXISTS "ProviderAccount_providerId_idx" ON "ProviderAccount"("providerId")`,
+	`CREATE INDEX IF NOT EXISTS "ProviderAccount_status_idx" ON "ProviderAccount"("status")`,
+	`CREATE TABLE IF NOT EXISTS "McpServer" (
+    "id" TEXT NOT NULL PRIMARY KEY,
+    "name" TEXT NOT NULL,
+    "displayName" TEXT,
+    "transport" TEXT NOT NULL,
+    "config" JSONB NOT NULL DEFAULT '{}',
+    "enabled" BOOLEAN NOT NULL DEFAULT true,
+    "required" BOOLEAN NOT NULL DEFAULT false,
+    "startupTimeoutSec" REAL,
+    "toolTimeoutSec" REAL,
+    "toolPolicy" JSONB NOT NULL DEFAULT '{}',
+    "adapterSettings" JSONB NOT NULL DEFAULT '{}',
+    "createdAt" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updatedAt" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP
+  )`,
+	`CREATE UNIQUE INDEX IF NOT EXISTS "McpServer_name_key" ON "McpServer"("name")`,
+	`CREATE TABLE IF NOT EXISTS "McpServerInstallation" (
+    "id" TEXT NOT NULL PRIMARY KEY,
+    "serverId" TEXT NOT NULL,
+    "providerId" TEXT NOT NULL,
+    "accountId" TEXT NOT NULL,
+    "enabled" BOOLEAN NOT NULL DEFAULT true,
+    "lastSyncAt" DATETIME,
+    "lastStatus" TEXT,
+    "lastError" TEXT,
+    "createdAt" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updatedAt" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    CONSTRAINT "McpServerInstallation_serverId_fkey" FOREIGN KEY ("serverId") REFERENCES "McpServer" ("id") ON DELETE CASCADE ON UPDATE CASCADE
+  )`,
+	`CREATE UNIQUE INDEX IF NOT EXISTS "McpServerInstallation_serverId_providerId_accountId_key" ON "McpServerInstallation"("serverId", "providerId", "accountId")`,
+	`CREATE INDEX IF NOT EXISTS "McpServerInstallation_providerId_accountId_idx" ON "McpServerInstallation"("providerId", "accountId")`,
+	`CREATE TABLE IF NOT EXISTS "Chat" (
+    "id" TEXT NOT NULL PRIMARY KEY,
+    "providerId" TEXT NOT NULL,
+    "accountId" TEXT,
+    "autoRotateAccount" BOOLEAN NOT NULL DEFAULT false,
+    "title" TEXT NOT NULL,
+    "workingDirectory" TEXT,
+    "model" TEXT,
+    "reasoningEffort" TEXT,
+    "serviceTier" TEXT,
+    "collaborationMode" TEXT NOT NULL DEFAULT 'default',
+    "permissionMode" TEXT NOT NULL DEFAULT 'default',
+    "status" TEXT NOT NULL DEFAULT 'IDLE',
+    "externalThreadId" TEXT,
+    "lastActivityAt" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "createdAt" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updatedAt" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    CONSTRAINT "Chat_accountId_fkey" FOREIGN KEY ("accountId") REFERENCES "ProviderAccount" ("id") ON DELETE SET NULL ON UPDATE CASCADE
+  )`,
+	`CREATE INDEX IF NOT EXISTS "Chat_providerId_idx" ON "Chat"("providerId")`,
+	`CREATE INDEX IF NOT EXISTS "Chat_accountId_idx" ON "Chat"("accountId")`,
+	`CREATE INDEX IF NOT EXISTS "Chat_updatedAt_idx" ON "Chat"("updatedAt")`,
+	`CREATE INDEX IF NOT EXISTS "Chat_lastActivityAt_idx" ON "Chat"("lastActivityAt")`,
+	`CREATE INDEX IF NOT EXISTS "Chat_externalThreadId_idx" ON "Chat"("externalThreadId")`,
+	`CREATE TABLE IF NOT EXISTS "ChatRun" (
+    "id" TEXT NOT NULL PRIMARY KEY,
+    "chatId" TEXT NOT NULL,
+    "providerId" TEXT NOT NULL,
+    "accountId" TEXT,
+    "status" TEXT NOT NULL DEFAULT 'QUEUED',
+    "request" JSONB NOT NULL DEFAULT '{}',
+    "error" TEXT,
+    "externalTurnId" TEXT,
+    "interruptRequestedAt" DATETIME,
+    "startedAt" DATETIME,
+    "endedAt" DATETIME,
+    "createdAt" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updatedAt" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    CONSTRAINT "ChatRun_chatId_fkey" FOREIGN KEY ("chatId") REFERENCES "Chat" ("id") ON DELETE CASCADE ON UPDATE CASCADE,
+    CONSTRAINT "ChatRun_accountId_fkey" FOREIGN KEY ("accountId") REFERENCES "ProviderAccount" ("id") ON DELETE SET NULL ON UPDATE CASCADE
+  )`,
+	`CREATE INDEX IF NOT EXISTS "ChatRun_chatId_createdAt_idx" ON "ChatRun"("chatId", "createdAt")`,
+	`CREATE INDEX IF NOT EXISTS "ChatRun_providerId_idx" ON "ChatRun"("providerId")`,
+	`CREATE INDEX IF NOT EXISTS "ChatRun_accountId_idx" ON "ChatRun"("accountId")`,
+	`CREATE INDEX IF NOT EXISTS "ChatRun_externalTurnId_idx" ON "ChatRun"("externalTurnId")`,
+	`CREATE TABLE IF NOT EXISTS "MessageSchedule" (
+    "id" TEXT NOT NULL PRIMARY KEY,
+    "title" TEXT NOT NULL,
+    "message" TEXT NOT NULL,
+    "workingDirectory" TEXT NOT NULL,
+    "chatId" TEXT,
+    "providerId" TEXT NOT NULL,
+    "accountId" TEXT,
+    "model" TEXT,
+    "reasoningEffort" TEXT,
+    "serviceTier" TEXT,
+    "collaborationMode" TEXT NOT NULL DEFAULT 'default',
+    "permissionMode" TEXT NOT NULL DEFAULT 'default',
+    "goalObjective" TEXT,
+    "status" TEXT NOT NULL DEFAULT 'ACTIVE',
+    "recurrence" JSONB NOT NULL DEFAULT '{}',
+    "nextRunAt" DATETIME,
+    "lastRunAt" DATETIME,
+    "lastRunStatus" TEXT,
+    "createdAt" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updatedAt" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP
+  )`,
+	`CREATE INDEX IF NOT EXISTS "MessageSchedule_workingDirectory_idx" ON "MessageSchedule"("workingDirectory")`,
+	`CREATE INDEX IF NOT EXISTS "MessageSchedule_status_nextRunAt_idx" ON "MessageSchedule"("status", "nextRunAt")`,
+	`CREATE INDEX IF NOT EXISTS "MessageSchedule_chatId_idx" ON "MessageSchedule"("chatId")`,
+	`CREATE INDEX IF NOT EXISTS "MessageSchedule_accountId_idx" ON "MessageSchedule"("accountId")`,
+	`CREATE TABLE IF NOT EXISTS "MessageScheduleRun" (
+    "id" TEXT NOT NULL PRIMARY KEY,
+    "scheduleId" TEXT NOT NULL,
+    "chatId" TEXT,
+    "chatRunId" TEXT,
+    "scheduledFor" DATETIME NOT NULL,
+    "status" TEXT NOT NULL DEFAULT 'QUEUED',
+    "error" TEXT,
+    "startedAt" DATETIME,
+    "endedAt" DATETIME,
+    "createdAt" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updatedAt" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    CONSTRAINT "MessageScheduleRun_scheduleId_fkey" FOREIGN KEY ("scheduleId") REFERENCES "MessageSchedule" ("id") ON DELETE CASCADE ON UPDATE CASCADE
+  )`,
+	`CREATE INDEX IF NOT EXISTS "MessageScheduleRun_scheduleId_scheduledFor_idx" ON "MessageScheduleRun"("scheduleId", "scheduledFor")`,
+	`CREATE INDEX IF NOT EXISTS "MessageScheduleRun_chatId_idx" ON "MessageScheduleRun"("chatId")`,
+	`CREATE INDEX IF NOT EXISTS "MessageScheduleRun_chatRunId_idx" ON "MessageScheduleRun"("chatRunId")`,
+	`CREATE INDEX IF NOT EXISTS "MessageScheduleRun_status_idx" ON "MessageScheduleRun"("status")`,
+	`CREATE TABLE IF NOT EXISTS "WorkspaceHistory" (
+    "id" TEXT,
+    "path" TEXT NOT NULL PRIMARY KEY,
+    "name" TEXT NOT NULL,
+    "lastOpenedAt" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "createdAt" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updatedAt" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP
+  )`,
+	`CREATE INDEX IF NOT EXISTS "WorkspaceHistory_lastOpenedAt_idx" ON "WorkspaceHistory"("lastOpenedAt")`
+];
+//#endregion
+//#region app/server/json.server.ts
+function asJsonObject(value) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return;
+	return value;
+}
+function readString(value) {
+	return typeof value === "string" && value.trim() ? value.trim() : void 0;
+}
+function readBoolean(value) {
+	return typeof value === "boolean" ? value : void 0;
+}
+function readNumber(value) {
+	return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function normalizeJsonObject(value) {
+	return asJsonObject(value) ?? {};
+}
+//#endregion
+//#region app/server/providers/codex.server.ts
+var require = createRequire(import.meta.url);
+var invalidatedAccountIds = /* @__PURE__ */ new Set();
+var maxProviderChats = 200;
+var codexLiveStatusReadLimit = 8;
+var codexLogReadLimit = 5e3;
+var codexSessionSummaryTailBytes = 1024 * 1024;
+var codexInstructionsFileName = "AGENTS.md";
+var codexTurnCompletionTimeoutMs = 1800 * 1e3;
+var codexMessageReadTimeoutMs = 5e3;
+var codexStoredRunningFreshnessMs = 1800 * 1e3;
+var codexDefaultModel = "gpt-5.5";
+var codexDefaultReasoningEffort = "medium";
+var codexDefaultServiceTier = "standard";
+var codexSupportedReasoningEfforts = [
+	{
+		description: "None",
+		reasoningEffort: "none"
+	},
+	{
+		description: "Minimal",
+		reasoningEffort: "minimal"
+	},
+	{
+		description: "Low",
+		reasoningEffort: "low"
+	},
+	{
+		description: "Medium",
+		reasoningEffort: "medium"
+	},
+	{
+		description: "High",
+		reasoningEffort: "high"
+	},
+	{
+		description: "Extra High",
+		reasoningEffort: "xhigh"
+	}
+];
+var codexDefaultModelOptions = [
+	{
+		id: "gpt-5.5",
+		model: "gpt-5.5",
+		displayName: "GPT-5.5",
+		defaultReasoningEffort: codexDefaultReasoningEffort,
+		supportedReasoningEfforts: codexSupportedReasoningEfforts
+	},
+	{
+		id: "gpt-5.4",
+		model: "gpt-5.4",
+		displayName: "GPT-5.4",
+		defaultReasoningEffort: codexDefaultReasoningEffort,
+		supportedReasoningEfforts: codexSupportedReasoningEfforts
+	},
+	{
+		id: "gpt-5.4-mini",
+		model: "gpt-5.4-mini",
+		displayName: "GPT-5.4-Mini",
+		defaultReasoningEffort: codexDefaultReasoningEffort,
+		supportedReasoningEfforts: codexSupportedReasoningEfforts
+	},
+	{
+		id: "gpt-5.3-codex-spark",
+		model: "gpt-5.3-codex-spark",
+		displayName: "GPT-5.3-Codex-Spark",
+		defaultReasoningEffort: codexDefaultReasoningEffort,
+		supportedReasoningEfforts: codexSupportedReasoningEfforts
+	}
+];
+var codexProviderAdapter = {
+	definition: {
+		id: "codex",
+		label: "OpenAI Codex",
+		icon: "codex",
+		capabilities: [
+			"auth",
+			"chat",
+			"history",
+			"limits",
+			"models",
+			"accountSwitchHooks",
+			"localRuntime",
+			"threadLifecycle",
+			"fork",
+			"archive",
+			"review",
+			"compact",
+			"usage",
+			"skills",
+			"hooks",
+			"plugins",
+			"mcp",
+			"config",
+			"commandExec",
+			"shellCommand",
+			"providerSwitch"
+		],
+		composerFeatures: [
+			"accessMode",
+			"fileAttachment",
+			"folderAttachment",
+			"goal",
+			"imageAttachment",
+			"planMode"
+		],
+		defaultSettings: defaultCodexSettings(),
+		settingsFields: [
+			{
+				key: "accountsHome",
+				label: "Accounts home",
+				type: "path",
+				required: true
+			},
+			{
+				key: "historyHome",
+				label: "History home",
+				type: "path",
+				required: true
+			},
+			{
+				key: "sharedChatHome",
+				label: "Shared Codex home",
+				type: "path",
+				required: true
+			},
+			{
+				key: "defaultCommand",
+				label: "Command",
+				type: "string",
+				required: true
+			},
+			{
+				key: "defaultArgs",
+				label: "Arguments",
+				type: "stringArray",
+				required: true
+			},
+			{
+				key: "defaultEnvironment",
+				label: "Environment",
+				type: "json"
+			}
+		],
+		accountFields: [
+			{
+				key: "codexHome",
+				label: "Codex home override",
+				type: "path"
+			},
+			{
+				key: "personality",
+				label: "Personality",
+				type: "string"
+			},
+			{
+				key: "command",
+				label: "Command override",
+				type: "string"
+			},
+			{
+				key: "args",
+				label: "Arguments override",
+				type: "stringArray"
+			},
+			{
+				key: "environment",
+				label: "Environment",
+				type: "json"
+			}
+		],
+		runtimeFields: [
+			{
+				key: "model",
+				label: "Model",
+				type: "string"
+			},
+			{
+				key: "reasoningEffort",
+				label: "Reasoning",
+				type: "string"
+			},
+			{
+				key: "serviceTier",
+				label: "Service tier",
+				type: "string"
+			},
+			{
+				key: "permissionMode",
+				label: "Permission mode",
+				type: "string"
+			}
+		]
+	},
+	defaultSettings: defaultCodexSettings,
+	defaultAccountSettings: () => ({ personality: "pragmatic" }),
+	defaultRuntimeDefaults: () => ({
+		model: codexDefaultModel,
+		permissionMode: "askForApproval",
+		reasoningEffort: codexDefaultReasoningEffort,
+		serviceTier: codexDefaultServiceTier
+	}),
+	async prepareAccount(account) {
+		const codexHome = resolveAccountCodexHome(account);
+		ensureCodexHome(codexHome);
+		await syncCodexInstructionsToHome(codexHome);
+	},
+	async authenticate(account, mode = "browser") {
+		try {
+			if (mode === "local") {
+				await connectLocalCodexAccount();
+				runtimeService.stopRuntime(account.id);
+				return connectedAuthResponse(account.id, "Local Codex account is connected.", localCodexAuthState());
+			}
+			const runtime = runtimeForAccount(account);
+			if (hasAccountAuthFile(account)) {
+				runtimeService.stopRuntime(account.id);
+				return connectedAuthResponse(account.id, "Codex account is connected.");
+			}
+			const result = asJsonObject((await runtime.request("account/login/start", mode === "device" ? { type: "chatgptDeviceCode" } : {
+				type: "chatgpt",
+				codexStreamlinedLogin: true
+			}, 3e4)).result);
+			const responseMode = readString(result?.type) === "chatgptDeviceCode" ? "device" : mode;
+			const authUrl = readLoginAuthUrl(result, responseMode);
+			const loginId = readString(result?.loginId) ?? null;
+			const userCode = responseMode === "device" ? readString(result?.userCode) ?? readString(result?.user_code) ?? null : null;
+			return {
+				accountId: account.id,
+				status: authUrl ? "AUTHENTICATING" : "CONNECTED",
+				authMode: authUrl ? responseMode : null,
+				authUrl,
+				verificationUrl: responseMode === "device" ? authUrl : null,
+				userCode,
+				loginId,
+				message: authUrl ? responseMode === "device" ? "Open the verification URL and enter the device code to finish Codex authentication." : "Complete Codex authentication in the opened browser." : "Codex account is connected."
+			};
+		} catch (error) {
+			return {
+				accountId: account.id,
+				status: "ERROR",
+				authMode: mode,
+				authUrl: null,
+				verificationUrl: null,
+				userCode: null,
+				message: readErrorMessage$1(error)
+			};
+		}
+	},
+	async cancelAuthentication(account) {
+		runtimeService.stopRuntime(account.id);
+	},
+	async completeAuthentication(account, redirectUrl) {
+		const callbackUrl = parseLoopbackCallbackUrl(redirectUrl);
+		const response = await fetch(callbackUrl);
+		if (response.status >= 400) throw new Error(`Codex login callback returned HTTP ${response.status}.`);
+		if (hasAccountAuthFile(account)) {
+			runtimeService.stopRuntime(account.id);
+			return connectedAuthResponse(account.id, "Codex account is connected.");
+		}
+		return {
+			accountId: account.id,
+			status: "AUTHENTICATING",
+			authMode: readAuthMode(account.lastAuthMode),
+			authUrl: account.lastAuthUrl,
+			verificationUrl: account.lastAuthMode === "device" ? account.lastAuthUrl : null,
+			userCode: account.lastAuthUserCode,
+			message: "Callback accepted. Codex is still finishing authentication."
+		};
+	},
+	async listModels(account) {
+		try {
+			return normalizeModelList((await runtimeForAccount(account).request("model/list", {
+				includeHidden: false,
+				limit: 100
+			}, 3e4)).result);
+		} catch (error) {
+			await maybeMarkInvalidated(account.id, error);
+			throw error;
+		}
+	},
+	async readLimits(account) {
+		try {
+			return normalizeLimits((await runtimeForAccount(account).request("account/rateLimits/read", void 0, 3e4)).result);
+		} catch (error) {
+			await maybeMarkInvalidated(account.id, error);
+			throw error;
+		}
+	},
+	listChats(account) {
+		return listCodexChats(account);
+	},
+	loadChatMessages(account, externalThreadId) {
+		return loadCodexChatMessages(account, externalThreadId);
+	},
+	readChatStatus(account, externalThreadId) {
+		return readCodexChatStatus(account, externalThreadId);
+	},
+	readCachedChatStates(account, externalThreadIds) {
+		return readCodexStoredChatStates(account, externalThreadIds);
+	},
+	async forkThread(account, externalThreadId, request, workingDirectory) {
+		const response = await requestCodexRuntime(await prepareCodexThreadForLifecycleAction(account, externalThreadId, workingDirectory), "thread/fork", {
+			threadId: externalThreadId,
+			lastTurnId: request?.lastTurnId ?? null,
+			excludeTurns: true,
+			threadSource: "appServer"
+		}, 6e4);
+		const result = asJsonObject(response.result);
+		const thread = asJsonObject(result?.thread);
+		const nextThreadId = readString(thread?.id) ?? readString(result?.threadId) ?? readString(result?.thread_id);
+		if (!nextThreadId) throw new Error("Codex did not return a forked thread id.");
+		await syncAccountThreadToCanonical(nextThreadId, account);
+		return {
+			externalThreadId: nextThreadId,
+			title: readString(thread?.name) ?? readString(thread?.preview) ?? null,
+			workingDirectory: readString(result?.cwd) ?? readString(thread?.cwd) ?? null,
+			raw: jsonFromUnknown(response)
+		};
+	},
+	async archiveThread(account, externalThreadId, workingDirectory) {
+		return requestCodexOptional(await prepareCodexThreadForLifecycleAction(account, externalThreadId, workingDirectory), "thread/archive", { threadId: externalThreadId }, 3e4);
+	},
+	async deleteThread(account, externalThreadId) {
+		return requestCodexOptional(runtimeForAccount(account), "thread/delete", { threadId: externalThreadId }, 3e4);
+	},
+	async renameThread(account, externalThreadId, title, workingDirectory) {
+		return requestCodexOptional(await prepareCodexThreadForLifecycleAction(account, externalThreadId, workingDirectory), "thread/name/set", {
+			threadId: externalThreadId,
+			name: title
+		}, 3e4);
+	},
+	async compactThread(account, externalThreadId, _request, workingDirectory) {
+		return {
+			externalThreadId,
+			raw: jsonFromUnknown(await requestCodexRuntime(await prepareCodexThreadForLifecycleAction(account, externalThreadId, workingDirectory), "thread/compact/start", { threadId: externalThreadId }, 3e4))
+		};
+	},
+	async reviewThread(account, externalThreadId, request, workingDirectory) {
+		const response = await requestCodexRuntime(await prepareCodexThreadForLifecycleAction(account, externalThreadId, workingDirectory), "review/start", {
+			threadId: externalThreadId,
+			delivery: request?.delivery ?? "inline",
+			target: codexReviewTargetPayload(request)
+		}, 3e4);
+		const result = asJsonObject(response.result);
+		const turn = asJsonObject(result?.turn);
+		return {
+			externalThreadId: readString(result?.reviewThreadId) ?? readString(result?.review_thread_id) ?? externalThreadId,
+			turnId: readString(turn?.id) ?? readString(result?.turnId) ?? readString(result?.turn_id) ?? null,
+			raw: jsonFromUnknown(response)
+		};
+	},
+	async readUsage(account) {
+		return jsonFromUnknown((await requestCodexRuntime(runtimeForAccount(account), "account/usage/read", void 0, 3e4)).result);
+	},
+	async readConfig(account, workingDirectory) {
+		return jsonFromUnknown((await requestCodexRuntime(runtimeForAccount(account, workingDirectory), "config/read", {
+			cwd: workingDirectory ?? null,
+			includeLayers: true
+		}, 3e4)).result);
+	},
+	async listSkills(account, workingDirectory) {
+		return jsonFromUnknown((await requestCodexRuntime(runtimeForAccount(account, workingDirectory), "skills/list", {
+			cwds: workingDirectory ? [workingDirectory] : [],
+			forceReload: false
+		}, 3e4)).result);
+	},
+	async listHooks(account, workingDirectory) {
+		return jsonFromUnknown((await requestCodexRuntime(runtimeForAccount(account, workingDirectory), "hooks/list", { cwds: workingDirectory ? [workingDirectory] : [] }, 3e4)).result);
+	},
+	async listPlugins(account) {
+		return jsonFromUnknown((await requestCodexRuntime(runtimeForAccount(account), "plugin/list", {}, 3e4)).result);
+	},
+	async sendMessage(account, input) {
+		if (input.threadId) await hydrateKnownCodexThreadToAccount(input.threadId, account);
+		const runtime = runtimeForAccount(account, input.workingDirectory);
+		const threadId = await ensureCodexThread(runtime, input.threadId ?? null, input.workingDirectory, input.collaborationMode);
+		await input.onThreadReady?.(threadId);
+		const settings = await resolveCollaborationSettings(runtime, input.model ?? null, input.reasoningEffort ?? null, input.serviceTier ?? null);
+		if (input.goalObjective?.trim()) await setCodexThreadGoal(runtime, threadId, input.goalObjective);
+		const accessMode = codexAccessMode(input.permissionMode);
+		let turnId = null;
+		const livePlanContentByItemId = /* @__PURE__ */ new Map();
+		const completionAbort = new AbortController();
+		const unsubscribeLiveMessages = input.onMessage ? runtime.onEvent((message) => {
+			const resolvedRequestMessage = readCodexServerRequestResolvedMessage(message, threadId);
+			if (resolvedRequestMessage) {
+				try {
+					input.onMessage?.(resolvedRequestMessage);
+				} catch {}
+				return;
+			}
+			const serverRequestMessage = readCodexServerRequestMessage(message, threadId, turnId);
+			if (serverRequestMessage) {
+				try {
+					input.onMessage?.(serverRequestMessage);
+				} catch {}
+				return;
+			}
+			const planUpdateMessage = readCodexPlanUpdateMessage(message, threadId, turnId);
+			if (planUpdateMessage) {
+				try {
+					input.onMessage?.(planUpdateMessage);
+				} catch {}
+				return;
+			}
+			const liveMessage = readCodexLiveThreadItemMessage(message, threadId, turnId);
+			if (liveMessage) try {
+				input.onMessage?.(accumulateLivePlanMessage(liveMessage, livePlanContentByItemId));
+			} catch {}
+		}) : () => void 0;
+		const completion = runtime.waitForEvent((message) => isCodexTurnCompletedEvent(message, threadId, turnId), codexTurnCompletionTimeoutMs, completionAbort.signal);
+		let response = null;
+		try {
+			response = await runtime.request("turn/start", {
+				threadId,
+				cwd: input.workingDirectory,
+				input: codexInputItems(input.content, input.attachments ?? []),
+				approvalPolicy: accessMode.approvalPolicy,
+				collaborationMode: collaborationModePayload(input.collaborationMode, settings),
+				sandboxPolicy: accessMode.sandboxPolicy
+			}, 3e4);
+			const result = asJsonObject(response.result);
+			turnId = readString(asJsonObject(result?.turn)?.id) ?? readString(result?.turnId) ?? readString(result?.turn_id) ?? null;
+			if (turnId) await input.onTurnStarted?.(turnId);
+			await completion;
+		} catch (error) {
+			completionAbort.abort();
+			await completion.catch(() => void 0);
+			throw error;
+		} finally {
+			unsubscribeLiveMessages();
+		}
+		if (!response) throw new Error("Codex did not return a turn response.");
+		return {
+			threadId,
+			turnId,
+			raw: jsonFromUnknown(response)
+		};
+	},
+	respondToServerRequest(account, requestId, response) {
+		return runtimeForAccount(account).respondToServerRequest(requestId, response.result ?? serverRequestResultFromResponse(response));
+	},
+	async interrupt(account, threadId, turnId) {
+		const runtime = runtimeForAccount(account);
+		const activeTurnId = turnId ?? await readCodexActiveTurnId(runtime, threadId).catch(() => null);
+		try {
+			await runtime.request("turn/interrupt", {
+				threadId,
+				...activeTurnId ? { turnId: activeTurnId } : {}
+			}, 3e4);
+		} catch (error) {
+			runtimeService.stopRuntime(account.id);
+			if (activeTurnId) throw error;
+		}
+	},
+	async steerMessage(account, input) {
+		const response = await runtimeForAccount(account, input.workingDirectory).request("turn/steer", {
+			threadId: input.threadId,
+			input: codexInputItems(input.content, input.attachments ?? []),
+			expectedTurnId: input.turnId
+		}, 3e4);
+		const result = asJsonObject(response.result);
+		return {
+			turnId: readString(result?.turnId) ?? readString(result?.turn_id) ?? input.turnId,
+			raw: jsonFromUnknown(response)
+		};
+	},
+	isAccountConnected(account) {
+		return hasAccountAuthFile(account);
+	},
+	readAccountAlias(account) {
+		return readAuthEmailAlias(account);
+	},
+	async syncThreadFromAccount(threadId, account) {
+		return syncAccountThreadToCanonical(threadId, account);
+	},
+	async hydrateThreadForAccount(threadId, account) {
+		return hydrateCanonicalThreadToAccount(threadId, account);
+	},
+	async moveThreadToAccount(context) {
+		if (!context.fromAccount) return hydrateCanonicalThreadToAccount(context.threadId, context.toAccount);
+		return moveAccountThreadToAccount(context.threadId, context.fromAccount, context.toAccount);
+	},
+	async afterAccountSwitch(context) {
+		if (context.fromAccount && context.fromAccount.id !== context.toAccount.id && !sameFilesystemPath(resolveAccountCodexHome(context.fromAccount), resolveAccountCodexHome(context.toAccount))) await removeAccountThread(context.threadId, context.fromAccount);
+	},
+	stopAccountRuntime(accountId) {
+		runtimeService.stopRuntime(accountId);
+	}
+};
+function defaultCodexSettings() {
+	const codexBin = resolveCodexBin();
+	return {
+		accountsHome: join(resolveProviderDataHome("codex"), "accounts"),
+		historyHome: join(resolveProviderDataHome("codex"), "history"),
+		sharedChatHome: resolveHomePath("~/.codex"),
+		defaultCommand: process.execPath,
+		defaultArgs: [
+			codexBin,
+			"app-server",
+			"--enable",
+			"goals",
+			"--enable",
+			"collaboration_modes"
+		],
+		defaultEnvironment: {}
+	};
+}
+function runtimeForAccount(account, workingDirectory) {
+	return runtimeService.getRuntime(runtimeConfigForAccount(account, workingDirectory));
+}
+function runtimeConfigForAccount(account, workingDirectory) {
+	const providerSettings = mergedProviderSettings();
+	const settings = normalizeJsonObject(account.settings);
+	const runtimeDefaults = normalizeJsonObject(account.runtimeDefaults);
+	const defaultEnvironment = readStringRecord(providerSettings.defaultEnvironment);
+	const accountEnvironment = readStringRecord(settings.environment);
+	const args = readStringArray(settings.args) ?? readStringArray(providerSettings.defaultArgs) ?? [resolveCodexBin(), "app-server"];
+	return {
+		accountId: account.id,
+		args: codexArgsWithPersonality(args, readCodexPersonality(settings.personality)),
+		codexHome: resolveAccountCodexHome(account),
+		command: readString(settings.command) ?? readString(providerSettings.defaultCommand) ?? process.execPath,
+		environment: {
+			...defaultEnvironment,
+			...accountEnvironment
+		},
+		workingDirectory: workingDirectory ?? readString(runtimeDefaults.workingDirectory) ?? null
+	};
+}
+function mergedProviderSettings() {
+	return defaultCodexSettings();
+}
+function resolveAccountCodexHome(account) {
+	if (usesSharedCodexHome(account)) return resolveSharedCodexHome();
+	const explicitHome = readString(normalizeJsonObject(account.settings).codexHome);
+	if (explicitHome && !sameFilesystemPath(resolveHomePath(explicitHome), resolveSharedCodexHome())) return resolveHomePath(explicitHome);
+	return join(resolveHomePath(readString(mergedProviderSettings().accountsHome) ?? "~/.pockcode/providers/codex/accounts"), account.id);
+}
+function resolveCodexAccountHome(account) {
+	return resolveAccountCodexHome(account);
+}
+async function reloadCodexMcpServerConfig(account) {
+	await runtimeForAccount(account).request("config/mcpServer/reload", void 0, 3e4);
+}
+async function listCodexMcpServerStatuses(account) {
+	return readCodexMcpServerStatusList((await runtimeForAccount(account).request("mcpServerStatus/list", {
+		detail: "toolsAndAuthOnly",
+		limit: 200
+	}, 6e4)).result);
+}
+async function startCodexMcpOauthLogin(account, serverName, scopes) {
+	const params = { name: serverName };
+	if (scopes?.length) params.scopes = scopes;
+	const result = asJsonObject((await runtimeForAccount(account).request("mcpServer/oauth/login", params, 12e4)).result) ?? {};
+	const authorizationUrl = readString(result.authorizationUrl) ?? readString(result.authorization_url) ?? readString(result.authUrl) ?? readString(result.auth_url);
+	if (!authorizationUrl) throw new Error("Codex did not return an MCP authorization URL.");
+	return { authorizationUrl };
+}
+function readCodexMcpServerStatusList(result) {
+	if (Array.isArray(result)) return result;
+	const record = asJsonObject(result);
+	const statuses = record?.mcpServers ?? record?.servers ?? record?.data;
+	if (Array.isArray(statuses)) return statuses;
+	if (statuses && typeof statuses === "object" && !Array.isArray(statuses)) return Object.values(statuses);
+	return [];
+}
+function readCodexHistoryWatchPaths(account) {
+	const paths = [resolveSharedCodexHome(), resolveCanonicalHistoryHome()];
+	if (account) paths.push(resolveAccountCodexHome(account));
+	return [...new Set(paths)];
+}
+function resolveCanonicalHistoryHome() {
+	return resolveHomePath(readString(mergedProviderSettings().historyHome) ?? "~/.pockcode/providers/codex/history");
+}
+function resolveSharedCodexHome() {
+	return resolveHomePath(readString(mergedProviderSettings().sharedChatHome) ?? "~/.codex");
+}
+function ensureCodexHome(codexHome) {
+	mkdirSync(codexHome, {
+		recursive: true,
+		mode: 448
+	});
+	chmodSync(codexHome, 448);
+}
+async function readCodexInstructions() {
+	const homes = await readCodexInstructionHomes();
+	return {
+		instructions: await readLatestExistingCodexInstructions(homes) ?? "",
+		paths: homes.map(codexInstructionsPath)
+	};
+}
+async function updateCodexInstructions(instructions) {
+	const homes = await readCodexInstructionHomes();
+	const normalized = instructions.trimEnd();
+	await Promise.all(homes.map((home) => writeCodexInstructions(home, normalized)));
+	return {
+		instructions: normalized,
+		paths: homes.map(codexInstructionsPath)
+	};
+}
+async function syncCodexInstructionsToHome(codexHome) {
+	const instructions = await readLatestExistingCodexInstructions([resolveSharedCodexHome(), resolveCanonicalHistoryHome()]);
+	if (instructions === null) return;
+	await writeCodexInstructions(codexHome, instructions);
+}
+async function readCodexInstructionHomes() {
+	await ensureDatabase();
+	const accounts = await prisma.providerAccount.findMany({ where: { providerId: "codex" } });
+	return uniquePaths([
+		resolveSharedCodexHome(),
+		resolveCanonicalHistoryHome(),
+		...accounts.map(resolveAccountCodexHome)
+	]);
+}
+async function readLatestExistingCodexInstructions(homes) {
+	return (await Promise.all(homes.map(async (home, index) => {
+		const path = codexInstructionsPath(home);
+		const stats = await stat(path).catch(() => null);
+		if (!stats?.isFile()) return null;
+		const content = await readFile(path, "utf8").catch(() => null);
+		if (content === null) return null;
+		return {
+			content: content.trimEnd(),
+			index,
+			mtimeMs: stats.mtimeMs
+		};
+	}))).filter((file) => Boolean(file)).sort((left, right) => right.mtimeMs - left.mtimeMs || left.index - right.index)[0]?.content ?? null;
+}
+async function writeCodexInstructions(codexHome, instructions) {
+	await mkdir(codexHome, {
+		recursive: true,
+		mode: 448
+	});
+	await writeFile(codexInstructionsPath(codexHome), instructions ? `${instructions}\n` : "", "utf8");
+}
+function codexInstructionsPath(codexHome) {
+	return join(codexHome, codexInstructionsFileName);
+}
+function codexArgsWithPersonality(args, personality) {
+	if (args.some((arg) => arg.includes("personality"))) return args;
+	return [
+		...args,
+		"-c",
+		`personality="${personality}"`
+	];
+}
+function readCodexPersonality(value) {
+	return value === "friendly" ? "friendly" : "pragmatic";
+}
+function uniquePaths(paths) {
+	return [...new Set(paths.map((path) => resolve(path)))];
+}
+async function connectLocalCodexAccount() {
+	const authPath = join(resolveSharedCodexHome(), "auth.json");
+	if (!(await stat(authPath).catch(() => null))?.isFile()) throw new Error(`No local Codex auth found at ${authPath}.`);
+}
+async function syncAccountThreadToCanonical(threadId, account) {
+	return copyCodexThread(resolveAccountCodexHome(account), resolveCanonicalHistoryHome(), threadId);
+}
+async function hydrateCanonicalThreadToAccount(threadId, account) {
+	if (usesSharedCodexHome(account)) return true;
+	const target = resolveAccountCodexHome(account);
+	ensureCodexHome(target);
+	return copyCodexThread(resolveCanonicalHistoryHome(), target, threadId, { preserveExistingTarget: true });
+}
+async function hydrateKnownCodexThreadToAccount(threadId, account) {
+	if (await hydrateCanonicalThreadToAccount(threadId, account)) return true;
+	if (usesSharedCodexHome(account)) return true;
+	const target = resolveAccountCodexHome(account);
+	ensureCodexHome(target);
+	const copied = await copyCodexThread(resolveSharedCodexHome(), target, threadId, { preserveExistingTarget: true });
+	if (copied) await copyCodexThread(resolveSharedCodexHome(), resolveCanonicalHistoryHome(), threadId, { preserveExistingTarget: true });
+	return copied;
+}
+async function removeAccountThread(threadId, account) {
+	if (usesSharedCodexHome(account)) return true;
+	return removeCodexThread(resolveAccountCodexHome(account), threadId);
+}
+async function moveAccountThreadToAccount(threadId, fromAccount, toAccount) {
+	const source = resolveAccountCodexHome(fromAccount);
+	const target = resolveAccountCodexHome(toAccount);
+	if (sameFilesystemPath(source, target)) return true;
+	const copied = await copyCodexThread(source, target, threadId, { preserveExistingTarget: true }) || await hydrateCanonicalThreadToAccount(threadId, toAccount);
+	if (copied) {
+		await syncAccountThreadToCanonical(threadId, toAccount);
+		await removeAccountThread(threadId, fromAccount);
+	}
+	return copied;
+}
+async function listCodexChats(account) {
+	const appServerChats = await listCodexChatsFromAppServer(account).catch(() => null);
+	if (appServerChats) {
+		await refreshCodexStoredSummaries(account, appServerChats);
+		return appServerChats;
+	}
+	const codexHome = resolveAccountCodexHome(account);
+	const text = await readFile(join(codexHome, "session_index.jsonl"), "utf8").catch(() => "");
+	if (!text.trim()) return [];
+	const sessionFiles = await listCodexSessionFiles(codexHome);
+	const sessionFileById = new Map(sessionFiles.map((file) => [codexSessionIdFromPath(file), file]));
+	const rows = text.split(/\r?\n/u).map(parseJsonLine).map((row) => asJsonObject(row)).filter((row) => Boolean(row)).slice(-200).reverse();
+	const chats = [];
+	for (const row of rows) {
+		const externalThreadId = readString(row.threadId) ?? readString(row.thread_id) ?? readString(row.id);
+		if (!externalThreadId) continue;
+		const sessionFile = sessionFileById.get(externalThreadId);
+		const meta = sessionFile ? await readCodexSessionMeta(sessionFile) : {};
+		const summary = sessionFile ? await readCodexSessionSummary(sessionFile) : emptyCodexSessionSummary();
+		chats.push({
+			externalThreadId,
+			title: readString(row.thread_name) ?? readString(row.title) ?? "Untitled chat",
+			updatedAt: newestCodexTimestamp(summary.updatedAt, readIsoString(row.updatedAt) ?? readIsoString(row.updated_at) ?? readIsoString(row.lastSentAt) ?? readIsoString(row.last_sent_at) ?? null),
+			createdAt: readIsoString(meta.timestamp) ?? null,
+			status: summary.status,
+			workingDirectory: readString(meta.cwd) ?? null
+		});
+	}
+	return chats;
+}
+function accumulateLivePlanMessage(message, contentByItemId) {
+	if (message.kind !== "PLAN" || !message.itemId) return message;
+	if (message.status === "STREAMING") {
+		const content = `${contentByItemId.get(message.itemId) ?? ""}${message.content}`;
+		contentByItemId.set(message.itemId, content);
+		return {
+			...message,
+			content
+		};
+	}
+	contentByItemId.set(message.itemId, message.content);
+	return message;
+}
+async function loadCodexChatMessages(account, externalThreadId) {
+	const appServerResult = await loadCodexChatMessagesFromAppServer(account, externalThreadId, codexMessageReadTimeoutMs).catch(() => null);
+	if (appServerResult) {
+		const storedStatus = appServerResult.status === "RUNNING" ? null : await readCodexStoredChatStatus(account, externalThreadId);
+		if (appServerResult.status === "RUNNING" || storedStatus === "RUNNING") return mergeCodexMessages(appServerResult.messages, await loadCodexStoredChatMessages(account, externalThreadId));
+		return appServerResult.messages;
+	}
+	return loadCodexStoredChatMessages(account, externalThreadId);
+}
+async function readCodexChatStatus(account, externalThreadId) {
+	const appServerStatus = readCodexAppServerOpenTurnStatus(await readCodexAppServerThread(runtimeForAccount(account), externalThreadId).catch(() => null));
+	if (appServerStatus === "RUNNING") return "RUNNING";
+	const storedStatus = await readCodexStoredChatStatus(account, externalThreadId);
+	return storedStatus === "RUNNING" ? "RUNNING" : appServerStatus ?? storedStatus;
+}
+async function readCodexActiveTurnId(runtime, externalThreadId) {
+	return readCodexAppServerOpenTurnId(await readCodexAppServerThread(runtime, externalThreadId));
+}
+async function loadCodexStoredChatMessages(account, externalThreadId) {
+	const codexHome = resolveAccountCodexHome(account);
+	const sessionFile = await findCodexSessionFile(codexHome, externalThreadId);
+	return mergeCodexMessages(sessionFile ? await readCodexSessionMessages(sessionFile) : [], await readCodexLogMessages(codexHome, externalThreadId));
+}
+async function readCodexStoredChatStatus(account, externalThreadId) {
+	const sessionFile = await findCodexSessionFile(resolveAccountCodexHome(account), externalThreadId);
+	return sessionFile ? (await readCodexSessionSummary(sessionFile)).status : null;
+}
+async function readCodexStoredChatStates(account, externalThreadIds) {
+	const ids = new Set(externalThreadIds.map((id) => id.trim()).filter(Boolean));
+	const states = /* @__PURE__ */ new Map();
+	if (!ids.size) return states;
+	const sessionFileById = await findCodexSessionFiles(resolveAccountCodexHome(account), [...ids], { fallbackToFullScan: false });
+	for (const externalThreadId of ids) {
+		const sessionFile = sessionFileById.get(externalThreadId);
+		if (!sessionFile) continue;
+		const sessionStats = await stat(sessionFile).catch(() => null);
+		if (!sessionStats?.isFile()) continue;
+		if (Date.now() - sessionStats.mtimeMs >= codexStoredRunningFreshnessMs) {
+			states.set(externalThreadId, { updatedAt: sessionStats.mtime.toISOString() });
+			continue;
+		}
+		const summary = await readCodexSessionSummary(sessionFile);
+		states.set(externalThreadId, {
+			status: summary.status,
+			updatedAt: summary.updatedAt
+		});
+	}
+	return states;
+}
+async function refreshCodexStoredSummaries(account, chats) {
+	const candidates = chats;
+	if (!candidates.length) return;
+	const sessionFileById = await findCodexSessionFiles(resolveAccountCodexHome(account), candidates.map((chat) => chat.externalThreadId));
+	for (const chat of candidates) {
+		const sessionFile = sessionFileById.get(chat.externalThreadId);
+		if (!sessionFile) continue;
+		const summary = await readCodexSessionSummary(sessionFile);
+		chat.updatedAt = newestCodexTimestamp(summary.updatedAt, chat.updatedAt ?? null);
+		if (summary.status === "RUNNING" || !chat.status) chat.status = summary.status;
+	}
+}
+async function listCodexChatsFromAppServer(account) {
+	const runtime = runtimeForAccount(account);
+	const result = asJsonObject((await runtime.request("thread/list", {
+		archived: false,
+		limit: maxProviderChats,
+		modelProviders: [],
+		sortDirection: "desc",
+		sortKey: "updated_at",
+		sourceKinds: [
+			"cli",
+			"vscode",
+			"appServer",
+			"exec",
+			"unknown"
+		]
+	}, 3e4)).result);
+	if (!Array.isArray(result?.data)) return null;
+	const chats = result.data.map(readCodexAppServerChat).filter((chat) => Boolean(chat));
+	await refreshCodexAppServerLiveStatuses(runtime, chats);
+	return chats;
+}
+function readCodexAppServerChat(value) {
+	const thread = asJsonObject(value);
+	const externalThreadId = readString(thread?.id);
+	if (!thread || !externalThreadId) return null;
+	const title = readString(thread.name) ?? readString(thread.preview) ?? "Untitled chat";
+	return {
+		externalThreadId,
+		stats: null,
+		status: readCodexAppServerThreadStatus(thread.status),
+		title,
+		updatedAt: readCodexAppServerTimestamp(thread.recencyAt) ?? readCodexAppServerTimestamp(thread.updatedAt),
+		createdAt: readCodexAppServerTimestamp(thread.createdAt),
+		workingDirectory: readString(thread.cwd) ?? null
+	};
+}
+async function loadCodexChatMessagesFromAppServer(account, externalThreadId, timeoutMs = 3e4) {
+	const thread = await readCodexAppServerThread(runtimeForAccount(account), externalThreadId, timeoutMs);
+	if (!thread) return null;
+	return {
+		messages: readCodexAppServerThreadMessages(thread),
+		status: readCodexAppServerOpenTurnStatus(thread)
+	};
+}
+async function refreshCodexAppServerLiveStatuses(runtime, chats) {
+	const candidates = chats.slice(0, codexLiveStatusReadLimit);
+	for (const chat of candidates) {
+		const status = readCodexAppServerOpenTurnStatus(await readCodexAppServerThread(runtime, chat.externalThreadId).catch(() => null));
+		if (status) chat.status = status;
+	}
+}
+async function readCodexAppServerThread(runtime, externalThreadId, timeoutMs = 3e4) {
+	return asJsonObject(asJsonObject((await runtime.request("thread/read", {
+		threadId: externalThreadId,
+		includeTurns: true
+	}, timeoutMs)).result)?.thread) ?? null;
+}
+function readCodexAppServerThreadMessages(thread) {
+	if (!Array.isArray(thread.turns)) return [];
+	const messages = [];
+	for (const turnValue of thread.turns) {
+		const turn = asJsonObject(turnValue);
+		if (!turn || !Array.isArray(turn.items)) continue;
+		const turnId = readString(turn.id) ?? readString(turn.turnId) ?? readString(turn.turn_id) ?? null;
+		const startedAt = readCodexAppServerTimestamp(turn.startedAt);
+		const completedAt = readCodexAppServerTimestamp(turn.completedAt);
+		for (const itemValue of turn.items) {
+			const message = readCodexAppServerThreadItemMessage(itemValue, startedAt, completedAt);
+			if (message) messages.push(turnId && !message.turnId ? {
+				...message,
+				turnId
+			} : message);
+		}
+	}
+	return mergeCodexMessages(messages, []);
+}
+function readCodexAppServerThreadItemMessage(value, turnStartedAt, turnCompletedAt) {
+	const item = asJsonObject(value);
+	const type = readString(item?.type);
+	if (!item || !type) return null;
+	if (type === "userMessage") {
+		const content = readCodexAppServerUserMessageText(item.content);
+		if (!content || isCodexInjectedContextMessage(content)) return null;
+		return {
+			role: "USER",
+			content,
+			itemId: readString(item.id) ?? readString(item.clientId) ?? null,
+			createdAt: turnStartedAt
+		};
+	}
+	if (type === "agentMessage") {
+		const content = readString(item.text);
+		if (!content) return null;
+		return {
+			role: "ASSISTANT",
+			content,
+			itemId: readString(item.id) ?? null,
+			createdAt: turnCompletedAt ?? turnStartedAt
+		};
+	}
+	if (type === "reasoning") {
+		const content = formatCodexReasoning(item);
+		if (!content) return null;
+		return {
+			role: "ASSISTANT",
+			kind: "THINKING",
+			content,
+			itemId: readString(item.id) ?? null,
+			createdAt: turnStartedAt
+		};
+	}
+	if (isCodexPlanItemType(type)) return codexPlanItemMessage(item, turnStartedAt);
+	if (type === "commandExecution") return codexActionMessage(item, "COMMAND_EXECUTION", formatCodexCommandExecution(item), turnCompletedAt ?? turnStartedAt);
+	if (type === "fileChange") return codexActionMessage(item, "FILE_CHANGE", formatCodexFileChange(item), turnCompletedAt ?? turnStartedAt);
+	if (type === "mcpToolCall") return codexActionMessage(item, "TOOL_ACTIVITY", formatCodexMcpToolCall(item), turnCompletedAt ?? turnStartedAt);
+	if (type === "dynamicToolCall") {
+		const userInputMessage = readCodexUserInputPromptFromToolItem(item, turnStartedAt, turnCompletedAt);
+		if (userInputMessage) return userInputMessage;
+		return codexActionMessage(item, "TOOL_ACTIVITY", formatCodexDynamicToolCall(item), turnCompletedAt ?? turnStartedAt);
+	}
+	if (type === "webSearch") return codexActionMessage(item, "TOOL_ACTIVITY", formatCodexWebSearch(item), turnCompletedAt ?? turnStartedAt);
+	if (type === "collabAgentToolCall") return codexActionMessage(item, "SUBAGENT_ACTIVITY", formatCodexCollabAgentToolCall(item), turnCompletedAt ?? turnStartedAt);
+	if (type === "subAgentActivity") return codexActionMessage(item, "SUBAGENT_ACTIVITY", formatCodexSubAgentActivity(item), turnCompletedAt ?? turnStartedAt);
+	if (type === "enteredReviewMode" || type === "exitedReviewMode") return codexActionMessage(item, "REVIEW", formatCodexReviewMode(item), turnCompletedAt ?? turnStartedAt);
+	if (type === "warning") return codexActionMessage(item, "WARNING", formatCodexWarning(item), turnCompletedAt ?? turnStartedAt);
+	if (type === "contextCompaction") return codexActionMessage(item, "COMPACTION", formatCodexSimpleToolItem(item), turnCompletedAt ?? turnStartedAt);
+	if (type === "imageView" || type === "imageGeneration" || type === "sleep") return codexActionMessage(item, "TOOL_ACTIVITY", formatCodexSimpleToolItem(item), turnCompletedAt ?? turnStartedAt);
+	if (isCodexVisibleFallbackItem(type)) return codexActionMessage(item, "TOOL_ACTIVITY", formatCodexFallbackToolItem(item), turnCompletedAt ?? turnStartedAt);
+	return null;
+}
+function codexActionMessage(item, kind, content, createdAt) {
+	if (!content) return null;
+	return {
+		role: "TOOL",
+		kind,
+		status: codexItemMessageStatus(item.status),
+		content,
+		itemId: readString(item.id) ?? null,
+		createdAt
+	};
+}
+function readCodexUserInputPromptFromToolItem(item, turnStartedAt, turnCompletedAt) {
+	const tool = readString(item.tool) ?? readString(item.name);
+	if (!tool || !isCodexRequestUserInputName(tool)) return null;
+	const requestId = readString(item.requestId) ?? readString(item.request_id);
+	const payload = asJsonObject(item.arguments) ?? item;
+	return codexUserInputPromptMessage({
+		createdAt: turnStartedAt ?? turnCompletedAt,
+		itemId: readString(item.id) ?? requestId ?? null,
+		payload,
+		requestId: requestId ?? null,
+		status: readString(item.status)
+	});
+}
+function codexUserInputPromptMessage({ createdAt, itemId, payload, requestId, status }) {
+	return {
+		role: "TOOL",
+		kind: "USER_INPUT_PROMPT",
+		status: codexUserInputPromptStatus(status),
+		content: formatCodexUserInputPrompt(payload),
+		itemId,
+		createdAt,
+		metadata: { serverRequestMethod: "item/tool/requestUserInput" },
+		rawPayload: jsonFromUnknown(payload),
+		requestId
+	};
+}
+function formatCodexCommandExecution(item) {
+	const parts = [`Command${codexStatusSuffix(item.status)}`];
+	const command = readString(item.command);
+	const cwd = readString(item.cwd);
+	const actions = formatCodexCommandActions(item.commandActions);
+	const output = readString(item.aggregatedOutput);
+	const metadata = [
+		cwd ? `cwd: \`${cwd}\`` : null,
+		readNumber(item.exitCode) !== void 0 ? `exit: \`${readNumber(item.exitCode)}\`` : null,
+		readNumber(item.durationMs) !== void 0 ? `duration: \`${readNumber(item.durationMs)} ms\`` : null
+	].filter(Boolean);
+	const shouldShowCommand = !actions.length || actions.some((action) => action.type === "unknown");
+	if (command && shouldShowCommand) parts.push(fencedBlock("sh", command));
+	if (metadata.length) parts.push(metadata.join(" | "));
+	if (actions.length) parts.push(["Actions", ...actions.map((action) => `- ${action.label}`)].join("\n"));
+	if (output) parts.push(["Output", fencedBlock("text", output)].join("\n"));
+	return parts.join("\n\n");
+}
+function formatCodexFileChange(item) {
+	const parts = [`File change${codexStatusSuffix(item.status)}`];
+	const changes = Array.isArray(item.changes) ? item.changes : [];
+	for (const changeValue of changes) {
+		const change = asJsonObject(changeValue);
+		if (!change) continue;
+		const path = readString(change.path) ?? "unknown file";
+		const kind = readString(change.kind);
+		const diff = readString(change.diff);
+		const stats = diff ? codexDiffStats(diff) : {
+			additions: 0,
+			deletions: 0
+		};
+		parts.push(`\`${path}\`${kind ? ` ${kind}` : ""} +${stats.additions} -${stats.deletions}`);
+	}
+	return parts.join("\n\n");
+}
+function codexDiffStats(diff) {
+	let additions = 0;
+	let deletions = 0;
+	for (const line of diff.split(/\r?\n/u)) {
+		if (line.startsWith("+++") || line.startsWith("---")) continue;
+		if (line.startsWith("+")) additions += 1;
+		else if (line.startsWith("-")) deletions += 1;
+	}
+	return {
+		additions,
+		deletions
+	};
+}
+function formatCodexMcpToolCall(item) {
+	const parts = [`MCP tool ${[readString(item.server), readString(item.tool)].filter(Boolean).join("/") || "call"}${codexStatusSuffix(item.status)}`];
+	const errorMessage = readString(asJsonObject(item.error)?.message);
+	addJsonBlock(parts, "Arguments", item.arguments);
+	addJsonBlock(parts, "Result", item.result);
+	if (errorMessage) parts.push(`Error\n${fencedBlock("text", errorMessage)}`);
+	return parts.join("\n\n");
+}
+function formatCodexDynamicToolCall(item) {
+	const parts = [`Tool ${[readString(item.namespace), readString(item.tool)].filter(Boolean).join("/") || "call"}${codexStatusSuffix(item.status)}`];
+	const output = formatCodexDynamicToolOutput(item.contentItems);
+	addJsonBlock(parts, "Arguments", item.arguments);
+	if (output) parts.push(`Output\n${output}`);
+	return parts.join("\n\n");
+}
+function formatCodexUserInputPrompt(payload) {
+	const questionText = (Array.isArray(payload.questions) ? payload.questions.map((entry) => asJsonObject(entry)).filter((entry) => Boolean(entry)) : []).map((question) => readString(question.question) ?? readString(question.prompt) ?? readString(question.header)).filter((text) => Boolean(text));
+	if (questionText.length) return ["User input requested", ...questionText.map((text) => `- ${text}`)].join("\n");
+	return readString(payload.question) ?? readString(payload.prompt) ?? readString(payload.message) ?? "User input requested";
+}
+function formatCodexWebSearch(item) {
+	const query = readString(item.query);
+	const parts = [`Web search${codexStatusSuffix(item.status)}`];
+	if (query) parts.push(fencedBlock("text", query));
+	addJsonBlock(parts, "Action", item.action);
+	return parts.join("\n\n");
+}
+function formatCodexReasoning(item) {
+	return [readCodexTextLike(item.summary), readCodexTextLike(item.content)].filter(Boolean).join("\n\n").trim() || (readString(item.status) === "inProgress" ? "Thinking" : null);
+}
+function formatCodexCollabAgentToolCall(item) {
+	const tool = readString(item.tool);
+	const receivers = Array.isArray(item.receiverThreadIds) ? item.receiverThreadIds.map(readString).filter(Boolean) : [];
+	const parts = [`Subagent ${tool ?? "activity"}${codexStatusSuffix(item.status)}`];
+	const metadata = [
+		readString(item.senderThreadId) ? `from: \`${readString(item.senderThreadId)}\`` : null,
+		receivers.length ? `to: ${receivers.map((id) => `\`${id}\``).join(", ")}` : null,
+		readString(item.model) ? `model: \`${readString(item.model)}\`` : null,
+		readString(item.reasoningEffort) ? `reasoning: \`${readString(item.reasoningEffort)}\`` : null
+	].filter(Boolean);
+	if (metadata.length) parts.push(metadata.join(" | "));
+	const prompt = readString(item.prompt);
+	if (prompt) parts.push(fencedBlock("text", prompt));
+	addJsonBlock(parts, "Agents", item.agentsStates);
+	return parts.join("\n\n");
+}
+function formatCodexSubAgentActivity(item) {
+	const kind = readString(item.kind);
+	const path = readString(item.agentPath);
+	const threadId = readString(item.agentThreadId);
+	return [
+		`Subagent ${kind ? humanizeCodexItemType(kind).toLowerCase() : "activity"}`,
+		path ? `path: \`${path}\`` : null,
+		threadId ? `thread: \`${threadId}\`` : null
+	].filter(Boolean).join("\n\n");
+}
+function formatCodexReviewMode(item) {
+	const type = readString(item.type);
+	const review = readString(item.review);
+	const label = type === "enteredReviewMode" ? "Review started" : "Review completed";
+	return review ? `${label}\n\n${review}` : label;
+}
+function formatCodexWarning(item) {
+	return readString(item.message) ?? readString(item.text) ?? readString(item.warning) ?? formatCodexFallbackToolItem(item);
+}
+function formatCodexSimpleToolItem(item) {
+	const type = readString(item.type);
+	if (type === "imageView") return `Image viewed\n\n\`${readString(item.path) ?? "unknown path"}\``;
+	if (type === "imageGeneration") {
+		const parts = [`Image generation${codexStatusSuffix(item.status)}`];
+		const savedPath = readString(item.savedPath) ?? readString(item.saved_path);
+		const revisedPrompt = readString(item.revisedPrompt) ?? readString(item.revised_prompt);
+		if (savedPath) parts.push(`saved: \`${savedPath}\``);
+		if (revisedPrompt) parts.push(fencedBlock("text", revisedPrompt));
+		return parts.join("\n\n");
+	}
+	if (type === "sleep") return `Waited${readNumber(item.durationMs) !== void 0 ? ` \`${readNumber(item.durationMs)} ms\`` : ""}`;
+	if (type === "contextCompaction") return "Context compacted";
+	return null;
+}
+function formatCodexFallbackToolItem(item) {
+	const type = readString(item.type) ?? "tool";
+	const name = readString(item.tool) ?? readString(item.name);
+	const parts = [`${humanizeCodexItemType(type)}${name ? ` ${name}` : ""}${codexStatusSuffix(item.status)}`];
+	const metadata = [
+		readString(item.id) ? `id: \`${readString(item.id)}\`` : null,
+		readString(item.server) ? `server: \`${readString(item.server)}\`` : null,
+		readString(item.namespace) ? `namespace: \`${readString(item.namespace)}\`` : null
+	].filter(Boolean);
+	if (metadata.length) parts.push(metadata.join(" | "));
+	addJsonBlock(parts, "Details", sanitizeCodexToolDetails(item));
+	return parts.join("\n\n");
+}
+function isCodexVisibleFallbackItem(type) {
+	return type !== "hookPrompt";
+}
+function humanizeCodexItemType(type) {
+	return type.replace(/[_-]+/gu, " ").replace(/([a-z0-9])([A-Z])/gu, "$1 $2").replace(/\s+/gu, " ").trim().replace(/^./u, (letter) => letter.toUpperCase()) || "Tool";
+}
+function sanitizeCodexToolDetails(value, depth = 0) {
+	if (value === null || typeof value === "number" || typeof value === "boolean") return value;
+	if (typeof value === "string") return value.length > 1e3 ? `${value.slice(0, 1e3)}...` : value;
+	if (Array.isArray(value)) {
+		if (depth >= 3) return `[${value.length} items]`;
+		const items = value.slice(0, 20).map((item) => sanitizeCodexToolDetails(item, depth + 1));
+		return value.length > items.length ? [...items, `... ${value.length - items.length} more`] : items;
+	}
+	const object = asJsonObject(value);
+	if (!object) return String(value);
+	if (depth >= 3) return "{...}";
+	const details = {};
+	for (const [key, entry] of Object.entries(object)) details[key] = isCodexHeavyDetailKey(key) ? "[omitted]" : sanitizeCodexToolDetails(entry, depth + 1);
+	return details;
+}
+function isCodexHeavyDetailKey(key) {
+	return [
+		"aggregatedOutput",
+		"content",
+		"diff",
+		"encrypted_content",
+		"output",
+		"replacement_history",
+		"result",
+		"stderr",
+		"stdout",
+		"text",
+		"unified_diff"
+	].includes(key);
+}
+function formatCodexCommandActions(value) {
+	if (!Array.isArray(value)) return [];
+	return value.map((actionValue) => {
+		const action = asJsonObject(actionValue);
+		const type = readString(action?.type);
+		const command = readString(action?.command);
+		if (!action || !type) return null;
+		if (type === "read") return {
+			type,
+			label: `read ${readString(action.path) ?? readString(action.name) ?? command ?? "file"}`
+		};
+		if (type === "listFiles") return {
+			type,
+			label: `list ${readString(action.path) ?? command ?? "files"}`
+		};
+		if (type === "search") {
+			const query = readString(action.query);
+			const path = readString(action.path);
+			return {
+				type,
+				label: `search${query ? ` "${query}"` : ""}${path ? ` in ${path}` : ""}`
+			};
+		}
+		return {
+			type,
+			label: command ?? type
+		};
+	}).filter((action) => Boolean(action));
+}
+function formatCodexDynamicToolOutput(value) {
+	if (!Array.isArray(value)) return null;
+	const text = value.map((entryValue) => {
+		const entry = asJsonObject(entryValue);
+		if (readString(entry?.type) === "inputText") return readString(entry?.text) ?? "";
+		if (readString(entry?.type) === "inputImage") return readString(entry?.imageUrl) ?? readString(entry?.image_url) ?? "";
+		return "";
+	}).filter(Boolean).join("\n").trim();
+	return text ? fencedBlock("text", text) : null;
+}
+function addJsonBlock(parts, label, value) {
+	if (value === void 0 || value === null) return;
+	const block = formatJsonBlock(value);
+	if (block) parts.push(`${label}\n${block}`);
+}
+function formatJsonBlock(value) {
+	try {
+		const json = JSON.stringify(value, null, 2);
+		return json && json !== "null" ? fencedBlock("json", json) : null;
+	} catch {
+		return null;
+	}
+}
+function fencedBlock(language, value) {
+	return `~~~${language}\n${value.trim()}\n~~~`;
+}
+function codexStatusSuffix(value) {
+	const status = readString(value);
+	return status ? ` \`${status}\`` : "";
+}
+function codexItemMessageStatus(value) {
+	const status = readString(value);
+	if (status === "inProgress") return "STREAMING";
+	if (status === "failed" || status === "declined") return "FAILED";
+	return "COMPLETED";
+}
+function readCodexAppServerUserMessageText(value) {
+	if (typeof value === "string") return value.trim() || null;
+	if (!Array.isArray(value)) return null;
+	return value.map((input) => {
+		const inputObject = asJsonObject(input);
+		if (readString(inputObject?.type) !== "text") return "";
+		return readString(inputObject?.text) ?? "";
+	}).filter(Boolean).join("\n").trim() || null;
+}
+function readCodexTextLike(value) {
+	if (typeof value === "string") return value.trim() || null;
+	if (!Array.isArray(value)) return null;
+	return value.map((entry) => {
+		if (typeof entry === "string") return entry;
+		const object = asJsonObject(entry);
+		return readString(object?.text) ?? readString(object?.content) ?? "";
+	}).filter(Boolean).join("\n").trim() || null;
+}
+function readCodexAppServerTimestamp(value) {
+	if (typeof value === "number" && Number.isFinite(value)) return (/* @__PURE__ */ new Date(value * 1e3)).toISOString();
+	return readIsoString(value);
+}
+function readCodexAppServerThreadStatus(value) {
+	const type = readString(asJsonObject(value)?.type) ?? readString(value);
+	if (type === "active" || type === "running" || type === "inProgress" || type === "busy") return "RUNNING";
+	if (type === "idle" || type === "notLoaded" || type === "systemError" || type === "completed") return "IDLE";
+	return null;
+}
+function readCodexAppServerOpenTurnStatus(thread) {
+	if (!thread) return null;
+	const status = readCodexAppServerThreadStatus(thread.status);
+	const lastTurn = asJsonObject((Array.isArray(thread.turns) ? thread.turns : []).at(-1));
+	if (!lastTurn) return status;
+	if (readCodexAppServerTimestamp(lastTurn.completedAt)) return status === "RUNNING" && isFreshCodexThreadActivity(thread, lastTurn) ? "RUNNING" : "IDLE";
+	return isFreshCodexThreadActivity(thread, lastTurn) ? "RUNNING" : "IDLE";
+}
+function readCodexAppServerOpenTurnId(thread) {
+	if (!thread || readCodexAppServerOpenTurnStatus(thread) !== "RUNNING" || !Array.isArray(thread.turns)) return null;
+	for (const turnValue of [...thread.turns].reverse()) {
+		const turn = asJsonObject(turnValue);
+		if (!turn || readCodexAppServerTimestamp(turn.completedAt)) continue;
+		const turnId = readString(turn.id) ?? readString(turn.turnId) ?? readString(turn.turn_id);
+		if (turnId) return turnId;
+	}
+	return null;
+}
+function isFreshCodexThreadActivity(thread, turn) {
+	const updatedAt = newestCodexTimestamp(readCodexAppServerTimestamp(turn.updatedAt) ?? readCodexAppServerTimestamp(turn.startedAt) ?? null, readCodexAppServerTimestamp(thread.recencyAt) ?? readCodexAppServerTimestamp(thread.updatedAt) ?? null);
+	const updatedAtMs = updatedAt ? Date.parse(updatedAt) : NaN;
+	return Number.isFinite(updatedAtMs) && Date.now() - updatedAtMs < codexTurnCompletionTimeoutMs;
+}
+function isCodexTurnCompletedEvent(message, threadId, turnId) {
+	if (message.method !== "turn/completed") return false;
+	const params = asJsonObject(message.params);
+	if ((readString(params?.threadId) ?? readString(params?.thread_id)) !== threadId) return false;
+	const completedTurnId = readString(asJsonObject(params?.turn)?.id);
+	return !turnId || !completedTurnId || completedTurnId === turnId;
+}
+function readCodexLiveThreadItemMessage(message, threadId, turnId) {
+	const planDeltaMessage = readCodexPlanDeltaMessage(message, threadId, turnId);
+	if (planDeltaMessage) return planDeltaMessage;
+	const started = message.method === "item/started";
+	const completed = message.method === "item/completed";
+	if (!started && !completed) return null;
+	const params = asJsonObject(message.params);
+	if (!params || (readString(params.threadId) ?? readString(params.thread_id)) !== threadId) return null;
+	const eventTurnId = readString(params.turnId) ?? readString(params.turn_id);
+	if (turnId && eventTurnId && eventTurnId !== turnId) return null;
+	const item = asJsonObject(params.item);
+	if (!item) return null;
+	const timestamp = readCodexAppServerMillisTimestamp(started ? params.startedAtMs : params.completedAtMs) ?? (/* @__PURE__ */ new Date()).toISOString();
+	const providerMessage = readCodexAppServerThreadItemMessage(started && item.status === void 0 ? {
+		...item,
+		status: "inProgress"
+	} : item, timestamp, completed ? timestamp : null);
+	if (!providerMessage || !isCodexLiveActionMessage(providerMessage)) return null;
+	return providerMessage;
+}
+function readCodexPlanUpdateMessage(message, threadId, turnId) {
+	if (message.method !== "turn/plan/updated") return null;
+	const params = asJsonObject(message.params);
+	if (!params || (readString(params.threadId) ?? readString(params.thread_id)) !== threadId) return null;
+	const eventTurnId = readString(params.turnId) ?? readString(params.turn_id);
+	if (turnId && eventTurnId && eventTurnId !== turnId) return null;
+	return codexPlanUpdateMessage({
+		createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+		explanation: readString(params.explanation) ?? null,
+		itemId: eventTurnId ? `plan-update:${eventTurnId}` : `plan-update:${threadId}`,
+		status: "STREAMING",
+		steps: readCodexPlanSteps(params.plan),
+		turnId: eventTurnId ?? null
+	});
+}
+function readCodexPlanDeltaMessage(message, threadId, turnId) {
+	if (message.method !== "item/plan/delta") return null;
+	const params = asJsonObject(message.params);
+	if (!params || (readString(params.threadId) ?? readString(params.thread_id)) !== threadId) return null;
+	const eventTurnId = readString(params.turnId) ?? readString(params.turn_id);
+	if (turnId && eventTurnId && eventTurnId !== turnId) return null;
+	const itemId = readString(params.itemId) ?? readString(params.item_id);
+	const delta = readString(params.delta);
+	if (!itemId || !delta) return null;
+	return {
+		role: "ASSISTANT",
+		kind: "PLAN",
+		status: "STREAMING",
+		content: delta,
+		itemId,
+		createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+		turnId: eventTurnId ?? null
+	};
+}
+function codexPlanUpdateMessage({ createdAt, explanation, itemId, status, steps, turnId }) {
+	return {
+		role: "ASSISTANT",
+		kind: "PLAN",
+		status,
+		content: explanation?.trim() ?? "",
+		itemId,
+		createdAt,
+		turnId: turnId ?? null,
+		metadata: {
+			planPresentation: "update",
+			planSteps: jsonFromUnknown(steps)
+		}
+	};
+}
+function readCodexPlanSteps(value) {
+	if (!Array.isArray(value)) return [];
+	return value.map((entry) => {
+		const record = asJsonObject(entry);
+		const step = readString(record?.step);
+		const status = readCodexPlanStepStatus(record?.status);
+		return step ? {
+			step,
+			status
+		} : null;
+	}).filter((step) => Boolean(step));
+}
+function readCodexPlanStepStatus(value) {
+	const status = readString(value);
+	if (status === "completed" || status === "inProgress" || status === "pending") return status;
+	if (status === "in_progress") return "inProgress";
+	return "pending";
+}
+function readCodexServerRequestMessage(message, threadId, turnId) {
+	if (message.id === void 0 || message.id === null || !message.method || !isCodexServerRequestMethod(message.method)) return null;
+	const params = asJsonObject(message.params);
+	if (!params || (readString(params.threadId) ?? readString(params.thread_id)) !== threadId) return null;
+	const eventTurnId = readString(params.turnId) ?? readString(params.turn_id);
+	if (turnId && eventTurnId && eventTurnId !== turnId) return null;
+	const requestId = String(message.id);
+	const timestamp = readCodexAppServerMillisTimestamp(params.startedAtMs) ?? (/* @__PURE__ */ new Date()).toISOString();
+	return {
+		content: codexServerRequestContent(message.method, params),
+		createdAt: timestamp,
+		itemId: `request:${requestId}`,
+		kind: isCodexRequestUserInputMethod(message.method) ? "USER_INPUT_PROMPT" : "APPROVAL",
+		metadata: { serverRequestMethod: message.method },
+		rawPayload: jsonFromUnknown(params),
+		requestId,
+		role: "TOOL",
+		status: "PENDING",
+		turnId: eventTurnId ?? null
+	};
+}
+function readCodexServerRequestResolvedMessage(message, threadId) {
+	if (message.method !== "serverRequest/resolved") return null;
+	const params = asJsonObject(message.params);
+	if (!params || (readString(params.threadId) ?? readString(params.thread_id)) !== threadId) return null;
+	const requestId = readString(params.requestId) ?? readString(params.request_id);
+	if (!requestId) return null;
+	return {
+		content: "Request resolved",
+		createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+		itemId: `request:${requestId}`,
+		kind: "APPROVAL",
+		requestId,
+		role: "TOOL",
+		status: "COMPLETED"
+	};
+}
+function isCodexServerRequestMethod(method) {
+	return method === "item/commandExecution/requestApproval" || method === "item/fileChange/requestApproval" || method === "item/permissions/requestApproval" || isCodexRequestUserInputMethod(method) || normalizedCodexName(method).endsWith("requestapproval");
+}
+function codexServerRequestContent(method, params) {
+	const reason = readString(params.reason);
+	const normalized = normalizedCodexName(method);
+	if (normalized.includes("commandexecutionrequestapproval")) {
+		const command = readString(params.command);
+		const cwd = readString(params.cwd);
+		return [
+			"Command approval requested",
+			cwd ? `cwd: \`${cwd}\`` : "",
+			command ? `\n~~~sh\n${command}\n~~~` : "",
+			reason ? `\n${reason}` : ""
+		].filter(Boolean).join("\n");
+	}
+	if (normalized.includes("filechangerequestapproval")) return ["File change approval requested", reason].filter(Boolean).join("\n\n");
+	if (normalized.includes("permissionsrequestapproval")) {
+		const cwd = readString(params.cwd);
+		return [
+			"Permissions requested",
+			cwd ? `cwd: \`${cwd}\`` : "",
+			reason
+		].filter(Boolean).join("\n");
+	}
+	return formatCodexUserInputPrompt(params);
+}
+function serverRequestResultFromResponse(response) {
+	if (response.kind === "permissions") return {
+		permissions: {},
+		scope: "turn"
+	};
+	if (response.kind === "userInput") return { answers: {} };
+	return { decision: response.decision ?? "decline" };
+}
+function isCodexLiveActionMessage(message) {
+	return message.role === "TOOL" || message.kind === "THINKING" || message.kind === "PLAN" || message.kind === "APPROVAL" || message.kind === "USER_INPUT_PROMPT" || message.kind === "REVIEW" || message.kind === "WARNING" || message.kind === "COMPACTION" || message.kind === "SUBAGENT_ACTIVITY";
+}
+function readCodexAppServerMillisTimestamp(value) {
+	const timestamp = readNumber(value);
+	if (timestamp !== void 0) return new Date(timestamp).toISOString();
+	return readIsoString(value);
+}
+async function listCodexSessionFiles(codexHome) {
+	const roots = [join(codexHome, "sessions"), join(codexHome, "archived_sessions")];
+	const files = [];
+	for (const root of roots) await collectCodexSessionFiles(root, files);
+	return files;
+}
+async function collectCodexSessionFiles(directory, files, depth = 0) {
+	if (depth > 6) return;
+	const entries = await readdir(directory, { withFileTypes: true }).catch(() => []);
+	for (const entry of entries) {
+		const entryPath = join(directory, entry.name);
+		if (entry.isDirectory()) {
+			await collectCodexSessionFiles(entryPath, files, depth + 1);
+			continue;
+		}
+		if (entry.isFile() && entry.name.endsWith(".jsonl")) files.push(entryPath);
+	}
+}
+async function findCodexSessionFile(codexHome, externalThreadId) {
+	return (await findCodexSessionFiles(codexHome, [externalThreadId])).get(externalThreadId) ?? null;
+}
+function codexSessionIdFromPath(pathname) {
+	return pathname.match(/([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})\.jsonl$/iu)?.[1] ?? pathname;
+}
+async function findCodexSessionFiles(codexHome, externalThreadIds, options = {}) {
+	const remaining = new Set(externalThreadIds.map((id) => id.trim()).filter(Boolean));
+	const filesById = /* @__PURE__ */ new Map();
+	if (!remaining.size) return filesById;
+	const directories = /* @__PURE__ */ new Set();
+	for (const externalThreadId of remaining) for (const directory of codexSessionCandidateDirectories(codexHome, externalThreadId)) directories.add(directory);
+	for (const directory of directories) {
+		const entries = await readdir(directory, { withFileTypes: true }).catch(() => []);
+		for (const entry of entries) {
+			if (!entry.isFile() || !entry.name.endsWith(".jsonl")) continue;
+			const externalThreadId = codexSessionIdFromPath(entry.name);
+			if (!remaining.has(externalThreadId)) continue;
+			filesById.set(externalThreadId, join(directory, entry.name));
+			remaining.delete(externalThreadId);
+		}
+		if (!remaining.size) return filesById;
+	}
+	if (options.fallbackToFullScan === false) return filesById;
+	for (const file of await listCodexSessionFiles(codexHome)) {
+		const externalThreadId = codexSessionIdFromPath(file);
+		if (!remaining.has(externalThreadId)) continue;
+		filesById.set(externalThreadId, file);
+		remaining.delete(externalThreadId);
+		if (!remaining.size) break;
+	}
+	return filesById;
+}
+function codexSessionCandidateDirectories(codexHome, externalThreadId) {
+	const millis = codexUuidTimestampMillis(externalThreadId);
+	if (millis === null) return [];
+	const days = /* @__PURE__ */ new Set();
+	for (const offsetDays of [
+		-1,
+		0,
+		1
+	]) {
+		const date = new Date(millis + offsetDays * 24 * 60 * 60 * 1e3);
+		const year = date.getUTCFullYear().toString().padStart(4, "0");
+		const month = (date.getUTCMonth() + 1).toString().padStart(2, "0");
+		const day = date.getUTCDate().toString().padStart(2, "0");
+		days.add(join(year, month, day));
+	}
+	return [...days].flatMap((day) => [join(codexHome, "sessions", day), join(codexHome, "archived_sessions", day)]);
+}
+function codexUuidTimestampMillis(externalThreadId) {
+	const timestampHex = externalThreadId.replaceAll("-", "").slice(0, 12);
+	if (!timestampHex.match(/^[0-9a-f]{12}$/iu)) return null;
+	const millis = Number.parseInt(timestampHex, 16);
+	return Number.isFinite(millis) ? millis : null;
+}
+async function readCodexSessionMeta(sessionFile) {
+	const text = await readFile(sessionFile, "utf8").catch(() => "");
+	for (const line of text.split(/\r?\n/u)) {
+		const record = asJsonObject(parseJsonLine(line));
+		if (readString(record?.type) === "session_meta") return asJsonObject(record?.payload) ?? {};
+	}
+	return {};
+}
+function emptyCodexSessionSummary() {
+	return {
+		pendingCallIds: /* @__PURE__ */ new Set(),
+		status: null,
+		updatedAt: null
+	};
+}
+async function readCodexSessionSummary(sessionFile) {
+	return readCodexSessionTextSummary(await readCodexSessionSummaryText(sessionFile).catch(() => ""));
+}
+async function readCodexSessionSummaryText(sessionFile) {
+	const sessionStats = await stat(sessionFile).catch(() => null);
+	if (!sessionStats?.isFile()) return "";
+	if (sessionStats.size <= codexSessionSummaryTailBytes) return readFile(sessionFile, "utf8");
+	const length = Math.min(sessionStats.size, codexSessionSummaryTailBytes);
+	const buffer = Buffer.alloc(length);
+	const file = await open(sessionFile, "r");
+	try {
+		const result = await file.read(buffer, 0, length, sessionStats.size - length);
+		return buffer.subarray(0, result.bytesRead).toString("utf8");
+	} finally {
+		await file.close();
+	}
+}
+function readCodexSessionTextSummary(text) {
+	const pendingCallIds = /* @__PURE__ */ new Set();
+	let activeTurnFinished = false;
+	let activeTurnUpdatedAt = null;
+	let lastTurnId = null;
+	let sawRecord = false;
+	let updatedAt = null;
+	for (const line of text.split(/\r?\n/u)) {
+		const record = asJsonObject(parseJsonLine(line));
+		if (!record) continue;
+		sawRecord = true;
+		updatedAt = newestCodexTimestamp(readIsoString(record.timestamp), updatedAt);
+		const payload = asJsonObject(record.payload);
+		const payloadType = readString(payload?.type);
+		const recordType = readString(record.type);
+		const turnId = readCodexSessionRecordTurnId(record, payload);
+		if (turnId && turnId !== lastTurnId) {
+			lastTurnId = turnId;
+			pendingCallIds.clear();
+			activeTurnFinished = false;
+			activeTurnUpdatedAt = null;
+		}
+		if (turnId && turnId === lastTurnId) activeTurnUpdatedAt = newestCodexTimestamp(readIsoString(record.timestamp), activeTurnUpdatedAt);
+		if (recordType === "event_msg" && payloadType === "turn_aborted") {
+			const abortedTurnId = readString(payload?.turn_id) ?? readString(payload?.turnId);
+			if (!abortedTurnId || !lastTurnId || abortedTurnId === lastTurnId) {
+				pendingCallIds.clear();
+				activeTurnFinished = true;
+			}
+			continue;
+		}
+		if (recordType !== "response_item") continue;
+		if (payloadType === "message" && readString(payload?.phase) === "final_answer") {
+			pendingCallIds.clear();
+			activeTurnFinished = true;
+			continue;
+		}
+		if (payloadType === "function_call" || payloadType === "custom_tool_call") {
+			const callId = readCodexSessionCallId(payload);
+			if (callId) {
+				pendingCallIds.add(callId);
+				activeTurnFinished = false;
+			}
+			continue;
+		}
+		if (payloadType === "function_call_output" || payloadType === "custom_tool_call_output") {
+			const callId = readCodexSessionCallId(payload);
+			if (callId) if (isCodexSessionRunningToolOutput(payload)) {
+				pendingCallIds.add(callId);
+				activeTurnFinished = false;
+			} else pendingCallIds.delete(callId);
+		}
+	}
+	const activeTurnUpdatedAtMs = activeTurnUpdatedAt ? Date.parse(activeTurnUpdatedAt) : NaN;
+	const activeTurnFresh = Number.isFinite(activeTurnUpdatedAtMs) && Date.now() - activeTurnUpdatedAtMs < codexStoredRunningFreshnessMs;
+	const freshPendingCallIds = Number.isFinite(activeTurnUpdatedAtMs) && Date.now() - activeTurnUpdatedAtMs < codexTurnCompletionTimeoutMs ? pendingCallIds : /* @__PURE__ */ new Set();
+	return {
+		pendingCallIds: freshPendingCallIds,
+		status: freshPendingCallIds.size > 0 || !activeTurnFinished && activeTurnFresh ? "RUNNING" : sawRecord ? "IDLE" : null,
+		updatedAt
+	};
+}
+async function readCodexSessionMessages(sessionFile) {
+	const text = await readFile(sessionFile, "utf8").catch(() => "");
+	const summary = readCodexSessionTextSummary(text);
+	const outputByCallId = readCodexSessionFunctionOutputs(text);
+	const messages = [];
+	for (const line of text.split(/\r?\n/u)) {
+		const record = asJsonObject(parseJsonLine(line));
+		const message = readCodexSessionRecordMessage(record, asJsonObject(record?.payload), summary.pendingCallIds, outputByCallId);
+		if (message) messages.push(message);
+	}
+	return mergeCodexMessages(messages, []);
+}
+function readCodexSessionFunctionOutputs(text) {
+	const outputs = /* @__PURE__ */ new Map();
+	for (const line of text.split(/\r?\n/u)) {
+		const record = asJsonObject(parseJsonLine(line));
+		const payload = asJsonObject(record?.payload);
+		const recordType = readString(record?.type);
+		const payloadType = readString(payload?.type);
+		if (recordType === "event_msg" && payloadType === "exec_command_end") {
+			const callId = readCodexSessionCallId(payload);
+			const output = readCodexSessionExecCommandEndOutput(payload);
+			if (callId && output) outputs.set(callId, mergeCodexSessionFunctionOutput(outputs.get(callId), output));
+			continue;
+		}
+		if (recordType === "event_msg" && payloadType === "mcp_tool_call_end") {
+			const callId = readCodexSessionCallId(payload);
+			const output = readCodexSessionMcpToolEndOutput(payload);
+			if (callId && output) outputs.set(callId, mergeCodexSessionFunctionOutput(outputs.get(callId), output));
+			continue;
+		}
+		if (recordType !== "response_item" || payloadType !== "function_call_output" && payloadType !== "custom_tool_call_output") continue;
+		const callId = readCodexSessionCallId(payload);
+		const output = readCodexSessionFunctionOutput(payload);
+		if (!callId || !output) continue;
+		outputs.set(callId, mergeCodexSessionFunctionOutput(outputs.get(callId), output));
+	}
+	return outputs;
+}
+function mergeCodexSessionFunctionOutput(current, next) {
+	if (!current) return next;
+	const output = [current.output, next.output].filter(Boolean).join("\n").trim() || null;
+	return {
+		durationMs: next.durationMs ?? current.durationMs,
+		exitCode: next.exitCode ?? current.exitCode,
+		output
+	};
+}
+function readCodexSessionFunctionOutput(payload) {
+	const rawOutput = typeof payload?.output === "string" ? payload.output : "";
+	if (!rawOutput.trim()) return null;
+	const exitCodeMatch = rawOutput.match(/\bProcess exited with code (-?\d+)\b/u);
+	const exitCode = exitCodeMatch ? Number.parseInt(exitCodeMatch[1] ?? "", 10) : NaN;
+	const wallTimeMatch = rawOutput.match(/^Wall time:\s*([0-9.]+)\s*seconds$/mu);
+	const wallTimeSeconds = wallTimeMatch ? Number.parseFloat(wallTimeMatch[1] ?? "") : NaN;
+	const output = readCodexSessionOutputBody(rawOutput);
+	return {
+		durationMs: Number.isFinite(wallTimeSeconds) ? Math.round(wallTimeSeconds * 1e3) : null,
+		exitCode: Number.isFinite(exitCode) ? exitCode : null,
+		output: output?.trim() ? output.trim() : null
+	};
+}
+function readCodexSessionExecCommandEndOutput(payload) {
+	const output = readString(payload?.aggregated_output) ?? [readString(payload?.stdout), readString(payload?.stderr)].filter(Boolean).join("\n").trim() ?? null;
+	const exitCode = readNumber(payload?.exit_code) ?? readNumber(payload?.exitCode) ?? null;
+	const durationMs = readCodexDurationMs(payload?.duration) ?? readNumber(payload?.duration_ms) ?? readNumber(payload?.durationMs) ?? null;
+	if (!output && exitCode === null && durationMs === null) return null;
+	return {
+		durationMs,
+		exitCode,
+		output
+	};
+}
+function readCodexSessionMcpToolEndOutput(payload) {
+	const result = payload?.result === void 0 ? null : sanitizeCodexToolDetails(payload.result);
+	const output = result === null ? null : JSON.stringify(result, null, 2);
+	const durationMs = readCodexDurationMs(payload?.duration);
+	if (!output && durationMs === null) return null;
+	return {
+		durationMs,
+		exitCode: null,
+		output
+	};
+}
+function readCodexDurationMs(value) {
+	const duration = asJsonObject(value);
+	const seconds = readNumber(duration?.secs) ?? readNumber(duration?.seconds);
+	const nanos = readNumber(duration?.nanos) ?? readNumber(duration?.nanoseconds);
+	if (seconds === void 0 && nanos === void 0) return null;
+	return Math.round((seconds ?? 0) * 1e3 + (nanos ?? 0) / 1e6);
+}
+function readCodexSessionOutputBody(rawOutput) {
+	const markerIndex = rawOutput.indexOf("\nOutput:\n");
+	if (markerIndex >= 0) return rawOutput.slice(markerIndex + 9).trimEnd();
+	if (rawOutput.startsWith("Output:\n")) return rawOutput.slice(8).trimEnd();
+	return rawOutput.trim() || null;
+}
+async function readCodexLogMessages(codexHome, externalThreadId) {
+	const databasePath = join(codexHome, "logs_2.sqlite");
+	if (!(await stat(databasePath).catch(() => null))?.isFile()) return [];
+	const submissionRows = await readCodexLogRows(databasePath, `
+    select id, ts, ts_nanos, target, feedback_log_body, process_uuid
+    from logs
+    where thread_id = ${sqlString(externalThreadId)}
+      and target = 'codex_core::session::handlers'
+      and feedback_log_body like '%Submission sub=Submission%'
+    order by ts asc, ts_nanos asc, id asc
+    limit ${codexLogReadLimit}
+  `);
+	if (!submissionRows.length) return [];
+	const messages = [];
+	const turnIds = /* @__PURE__ */ new Set();
+	const processIds = /* @__PURE__ */ new Set();
+	let minTs = Number.POSITIVE_INFINITY;
+	for (const row of submissionRows) {
+		const body = row.feedback_log_body ?? "";
+		for (const turnId of extractCodexTurnIds(body)) turnIds.add(turnId);
+		const message = readCodexSubmissionMessage(row);
+		if (message) messages.push(message);
+		if (row.process_uuid) processIds.add(row.process_uuid);
+		if (typeof row.ts === "number" && row.ts < minTs) minTs = row.ts;
+	}
+	if (!turnIds.size || !processIds.size || !Number.isFinite(minTs)) return messages;
+	const turnPredicates = [...turnIds].map((turnId) => `feedback_log_body like ${sqlString(`%"turn_id":"${turnId}"%`)}`);
+	const assistantRows = await readCodexLogRows(databasePath, `
+    select id, ts, ts_nanos, target, feedback_log_body, process_uuid
+    from logs
+    where thread_id is null
+      and process_uuid in (${[...processIds].map(sqlString).join(", ")})
+      and ts >= ${Math.max(0, Math.floor(minTs) - 60)}
+      and feedback_log_body like 'Received message {"type":"response.output_item.done"%'
+      and (${turnPredicates.join(" or ")})
+    order by ts asc, ts_nanos asc, id asc
+    limit ${codexLogReadLimit}
+  `);
+	for (const row of assistantRows) {
+		const message = readCodexReceivedMessage(row);
+		if (message) messages.push(message);
+	}
+	return messages.sort(compareCodexMessages);
+}
+async function readCodexLogRows(databasePath, sql) {
+	return new Promise((resolve) => {
+		execFile("sqlite3", [
+			"-readonly",
+			"-json",
+			databasePath,
+			sql
+		], {
+			maxBuffer: 16 * 1024 * 1024,
+			timeout: 2e3
+		}, (error, stdout) => {
+			if (error || !stdout.trim()) {
+				resolve([]);
+				return;
+			}
+			const rows = parseJsonLine(stdout);
+			resolve(Array.isArray(rows) ? rows.map((row) => asJsonObject(row) ?? {}).filter(isCodexLogRow) : []);
+		});
+	});
+}
+function isCodexLogRow(row) {
+	return true;
+}
+function readCodexSubmissionMessage(row) {
+	const body = row.feedback_log_body ?? "";
+	const turnId = body.match(/Submission sub=Submission \{ id: "([0-9a-f-]{36})"/u)?.[1] ?? extractCodexTurnIds(body)[0];
+	const inputText = [...body.split("final_output_json_schema:")[0].matchAll(/Text \{ text: "((?:\\.|[^"\\])*)"/gu)].map((match) => unescapeCodexLogString(match[1])).filter(Boolean).join("\n").trim();
+	if (!inputText || isCodexInjectedContextMessage(inputText)) return null;
+	return {
+		role: "USER",
+		content: inputText,
+		itemId: turnId ? `${turnId}:user` : null,
+		turnId: turnId ?? null,
+		createdAt: codexLogRowDate(row)
+	};
+}
+function readCodexReceivedMessage(row) {
+	const body = row.feedback_log_body ?? "";
+	if (!body.startsWith("Received message ")) return null;
+	const event = asJsonObject(parseJsonLine(body.slice(17)));
+	if (readString(event?.type) !== "response.output_item.done") return null;
+	const item = asJsonObject(event?.item);
+	if (readString(item?.type) !== "message") return null;
+	const role = codexMessageRole(item?.role);
+	const content = readCodexMessageText(item?.content);
+	if (!role || !content) return null;
+	const turnId = readString(event?.turn_id) ?? readString(event?.turnId) ?? readString(item?.turn_id) ?? readString(item?.turnId) ?? extractCodexTurnIds(body)[0] ?? null;
+	return {
+		role,
+		content,
+		itemId: readString(item?.id) ?? null,
+		turnId,
+		createdAt: codexLogRowDate(row)
+	};
+}
+function extractCodexTurnIds(value) {
+	const ids = /* @__PURE__ */ new Set();
+	for (const match of value.matchAll(/Submission sub=Submission \{ id: "([0-9a-f-]{36})"/gu)) ids.add(match[1]);
+	for (const match of value.matchAll(/(?:submission\.id|turn\.id|turn_id)[=:]"?([0-9a-f-]{36})"?/gu)) ids.add(match[1]);
+	return [...ids];
+}
+function unescapeCodexLogString(value) {
+	try {
+		return JSON.parse(`"${value}"`);
+	} catch {
+		return value.replaceAll("\\n", "\n").replaceAll("\\r", "\r").replaceAll("\\t", "	").replaceAll("\\\"", "\"").replaceAll("\\\\", "\\");
+	}
+}
+function codexLogRowDate(row) {
+	if (typeof row.ts !== "number") return null;
+	const milliseconds = row.ts * 1e3 + Math.floor((typeof row.ts_nanos === "number" ? row.ts_nanos : 0) / 1e6);
+	return new Date(milliseconds).toISOString();
+}
+function mergeCodexMessages(sessionMessages, logMessages) {
+	const messages = [];
+	for (const message of [...sessionMessages, ...logMessages]) if (!messages.some((current) => sameCodexMessage(current, message))) messages.push(message);
+	return messages.sort(compareCodexMessages);
+}
+function sameCodexMessage(left, right) {
+	if (left.itemId && right.itemId && left.itemId === right.itemId) return true;
+	if (left.role !== right.role || normalizeCodexMessageText(left.content) !== normalizeCodexMessageText(right.content)) return false;
+	const leftTime = Date.parse(left.createdAt ?? "");
+	const rightTime = Date.parse(right.createdAt ?? "");
+	if (Number.isFinite(leftTime) && Number.isFinite(rightTime)) return Math.abs(leftTime - rightTime) < 6e4;
+	return !left.itemId || !right.itemId;
+}
+function normalizeCodexMessageText(value) {
+	return value.trim().replace(/\s+/gu, " ");
+}
+function compareCodexMessages(left, right) {
+	const leftTime = Date.parse(left.createdAt ?? "");
+	const rightTime = Date.parse(right.createdAt ?? "");
+	if (Number.isFinite(leftTime) && Number.isFinite(rightTime) && leftTime !== rightTime) return leftTime - rightTime;
+	if (Number.isFinite(leftTime) !== Number.isFinite(rightTime)) return Number.isFinite(leftTime) ? -1 : 1;
+	return 0;
+}
+function sqlString(value) {
+	return `'${value.replaceAll("'", "''")}'`;
+}
+function readCodexSessionRecordMessage(record, payload, pendingCallIds = /* @__PURE__ */ new Set(), outputByCallId = /* @__PURE__ */ new Map()) {
+	const recordType = readString(record?.type);
+	const payloadType = readString(payload?.type);
+	const createdAt = readIsoString(record?.timestamp) ?? null;
+	if (recordType === "compacted") return readCodexSessionCompactionMessage(payload, createdAt);
+	if (recordType === "response_item" && payloadType === "message") {
+		const role = codexMessageRole(payload?.role);
+		const content = readCodexMessageText(payload?.content);
+		if (!role || !content || role === "USER" && isCodexInjectedContextMessage(content)) return null;
+		return {
+			role,
+			content,
+			itemId: readString(payload?.id) ?? null,
+			createdAt
+		};
+	}
+	if (recordType === "response_item" && payloadType === "reasoning") return readCodexSessionReasoningMessage(payload, createdAt);
+	if (recordType === "response_item" && payloadType && isCodexPlanItemType(payloadType)) return codexPlanItemMessage(payload ?? {}, createdAt);
+	if (recordType === "event_msg" && payloadType === "user_message") {
+		const content = readString(payload?.message);
+		if (!content || isCodexInjectedContextMessage(content)) return null;
+		return {
+			role: "USER",
+			content,
+			itemId: readString(payload?.client_id) ?? null,
+			createdAt
+		};
+	}
+	if (recordType === "event_msg" && payloadType === "agent_message") {
+		const content = readString(payload?.message);
+		if (!content) return null;
+		return {
+			role: "ASSISTANT",
+			content,
+			itemId: null,
+			createdAt
+		};
+	}
+	if (recordType === "response_item" && (payloadType === "function_call" || payloadType === "custom_tool_call")) {
+		if (payloadType === "custom_tool_call" && readString(payload?.name) === "apply_patch") return null;
+		return readCodexSessionFunctionCallMessage(payload, createdAt, pendingCallIds, outputByCallId);
+	}
+	if (recordType === "response_item" && payloadType === "web_search_call") return readCodexSessionWebSearchMessage(payload, createdAt);
+	if (recordType === "response_item" && payloadType === "image_generation_call") return readCodexSessionImageGenerationMessage(payload, createdAt);
+	if (recordType === "event_msg" && payloadType === "patch_apply_end") return readCodexSessionPatchMessage(payload, createdAt);
+	if (recordType === "event_msg" && payloadType === "web_search_end") return readCodexSessionWebSearchMessage(payload, createdAt);
+	if (recordType === "event_msg" && payloadType === "image_generation_end") return readCodexSessionImageGenerationMessage(payload, createdAt);
+	if (recordType === "event_msg" && payloadType === "mcp_tool_call_end") return readCodexSessionMcpToolMessage(payload, createdAt);
+	if (recordType === "event_msg" && payloadType === "context_compacted") return readCodexSessionCompactionMessage(payload, createdAt);
+	if (recordType === "event_msg" && payloadType === "item_completed") return readCodexSessionCompletedItemMessage(payload, createdAt);
+	if (recordType === "event_msg" && payloadType === "error") return readCodexSessionErrorMessage(payload, createdAt);
+	if (recordType === "event_msg" && (payloadType === "turn_aborted" || payloadType === "thread_rolled_back")) return readCodexSessionThreadWarningMessage(payload, createdAt);
+	if (recordType === "response_item") return readCodexSessionFallbackToolMessage(payload, createdAt);
+	return null;
+}
+function readCodexSessionReasoningMessage(payload, createdAt) {
+	const content = formatCodexReasoning(payload ?? {});
+	if (!content) return null;
+	return {
+		role: "ASSISTANT",
+		kind: "THINKING",
+		content,
+		itemId: readString(payload?.id) ?? null,
+		createdAt
+	};
+}
+function readCodexSessionFunctionCallMessage(payload, createdAt, pendingCallIds = /* @__PURE__ */ new Set(), outputByCallId = /* @__PURE__ */ new Map()) {
+	const name = readString(payload?.name);
+	const callId = readCodexSessionCallId(payload);
+	const argumentsObject = readCodexSessionToolArguments(payload?.arguments);
+	const toolOutput = callId ? outputByCallId.get(callId) : void 0;
+	const status = callId && pendingCallIds.has(callId) ? "inProgress" : "completed";
+	if (name === "exec_command") {
+		const command = readString(argumentsObject?.cmd) ?? readString(argumentsObject?.command) ?? "command";
+		const item = {
+			type: "commandExecution",
+			id: callId ?? `command:${createdAt ?? command}`,
+			command,
+			cwd: readString(argumentsObject?.workdir) ?? readString(argumentsObject?.cwd) ?? "",
+			processId: null,
+			source: "agent",
+			status,
+			commandActions: inferCodexSessionCommandActions(command),
+			aggregatedOutput: toolOutput?.output ?? null,
+			exitCode: toolOutput?.exitCode ?? null,
+			durationMs: toolOutput?.durationMs ?? null
+		};
+		return codexActionMessage(item, "COMMAND_EXECUTION", formatCodexCommandExecution(item), createdAt);
+	}
+	if (name === "update_plan") return codexPlanUpdateMessage({
+		createdAt,
+		explanation: readString(argumentsObject?.explanation) ?? null,
+		itemId: callId ?? `plan-update:${createdAt ?? name}`,
+		status: status === "inProgress" ? "STREAMING" : "COMPLETED",
+		steps: readCodexPlanSteps(argumentsObject?.plan)
+	});
+	if (name && isCodexRequestUserInputName(name)) {
+		const payload = argumentsObject ?? {};
+		return codexUserInputPromptMessage({
+			createdAt,
+			itemId: callId ?? `tool:${createdAt ?? name}`,
+			payload,
+			requestId: null,
+			status: "completed"
+		});
+	}
+	if (!name) return null;
+	const item = {
+		type: "dynamicToolCall",
+		id: callId ?? `tool:${createdAt ?? name}`,
+		namespace: null,
+		tool: name,
+		arguments: argumentsObject ?? {},
+		status,
+		contentItems: toolOutput?.output ? [{
+			type: "inputText",
+			text: toolOutput.output
+		}] : null,
+		success: toolOutput?.exitCode === null || toolOutput?.exitCode === void 0 ? null : toolOutput.exitCode === 0,
+		durationMs: toolOutput?.durationMs ?? null
+	};
+	return codexActionMessage(item, "TOOL_ACTIVITY", formatCodexDynamicToolCall(item), createdAt);
+}
+function readCodexSessionPatchMessage(payload, createdAt) {
+	const changes = asJsonObject(payload?.changes);
+	if (!changes) return null;
+	const itemChanges = Object.entries(changes).map(([path, changeValue]) => {
+		const change = asJsonObject(changeValue);
+		return {
+			path,
+			kind: readString(change?.type) ?? "update",
+			diff: readString(change?.unified_diff) ?? ""
+		};
+	}).filter((change) => change.path);
+	if (!itemChanges.length) return null;
+	const item = {
+		type: "fileChange",
+		id: readString(payload?.call_id) ?? `patch:${createdAt ?? itemChanges[0]?.path ?? "unknown"}`,
+		changes: itemChanges,
+		status: readString(payload?.status) ?? (payload?.success === false ? "failed" : "completed")
+	};
+	return codexActionMessage(item, "FILE_CHANGE", formatCodexFileChange(item), createdAt);
+}
+function readCodexSessionWebSearchMessage(payload, createdAt) {
+	const item = {
+		type: "webSearch",
+		id: readString(payload?.call_id) ?? readString(payload?.id) ?? `web-search:${createdAt ?? "unknown"}`,
+		query: readString(payload?.query) ?? null,
+		action: payload?.action ?? null,
+		status: readString(payload?.status) ?? "completed"
+	};
+	return codexActionMessage(item, "TOOL_ACTIVITY", formatCodexWebSearch(item), createdAt);
+}
+function readCodexSessionImageGenerationMessage(payload, createdAt) {
+	const item = {
+		type: "imageGeneration",
+		id: readString(payload?.call_id) ?? readString(payload?.id) ?? `image-generation:${createdAt ?? "unknown"}`,
+		revisedPrompt: readString(payload?.revised_prompt) ?? readString(payload?.revisedPrompt) ?? null,
+		savedPath: readString(payload?.saved_path) ?? readString(payload?.savedPath) ?? null,
+		status: readString(payload?.status) ?? "completed"
+	};
+	return codexActionMessage(item, "TOOL_ACTIVITY", formatCodexSimpleToolItem(item), createdAt);
+}
+function readCodexSessionMcpToolMessage(payload, createdAt) {
+	const invocation = asJsonObject(payload?.invocation);
+	const item = {
+		type: "mcpToolCall",
+		id: readString(payload?.call_id) ?? `mcp:${createdAt ?? "unknown"}`,
+		server: readString(invocation?.server) ?? null,
+		tool: readString(invocation?.tool) ?? null,
+		arguments: invocation?.arguments ?? null,
+		result: payload?.result ?? null,
+		status: readString(payload?.status) ?? "completed"
+	};
+	return codexActionMessage(item, "TOOL_ACTIVITY", formatCodexMcpToolCall(item), createdAt);
+}
+function readCodexSessionCompactionMessage(payload, createdAt) {
+	const item = {
+		type: "contextCompaction",
+		id: readString(payload?.call_id) ?? readString(payload?.id) ?? `compaction:${createdAt ?? "unknown"}`,
+		status: readString(payload?.status) ?? "completed"
+	};
+	return codexActionMessage(item, "COMPACTION", formatCodexSimpleToolItem(item), createdAt);
+}
+function readCodexSessionCompletedItemMessage(payload, createdAt) {
+	const item = asJsonObject(payload?.item);
+	if (!isCodexPlanItemType(readString(item?.type))) return null;
+	return codexPlanItemMessage(item ?? {}, createdAt, readString(payload?.call_id) ?? null);
+}
+function isCodexPlanItemType(type) {
+	const normalized = (type ?? "").toLowerCase().replace(/[-_\s]+/gu, "");
+	return normalized === "plan" || normalized === "proposedplan";
+}
+function codexPlanItemMessage(item, createdAt, fallbackItemId = null) {
+	const steps = readCodexPlanItemSteps(item);
+	const explanation = readCodexPlanItemText(item);
+	const itemId = readString(item.id) ?? fallbackItemId;
+	if (steps.length) return codexPlanUpdateMessage({
+		createdAt,
+		explanation,
+		itemId,
+		status: "COMPLETED",
+		steps
+	});
+	const content = explanation ?? formatCodexFallbackToolItem(item);
+	if (!content) return null;
+	return {
+		role: "ASSISTANT",
+		kind: "PLAN",
+		content,
+		itemId,
+		createdAt
+	};
+}
+function readCodexPlanItemText(item) {
+	return readString(item.text) ?? readString(item.message) ?? readString(item.summary) ?? readCodexMessageText(item.content) ?? readString(item.plan) ?? null;
+}
+function readCodexPlanItemSteps(item) {
+	const directSteps = readCodexPlanSteps(item.plan);
+	if (directSteps.length) return directSteps;
+	const steps = readCodexPlanSteps(item.steps);
+	if (steps.length) return steps;
+	const plan = asJsonObject(item.plan);
+	return plan ? readCodexPlanSteps(plan.steps ?? plan.plan) : [];
+}
+function readCodexSessionErrorMessage(payload, createdAt) {
+	const content = readString(payload?.message) ?? "Codex error";
+	return {
+		role: "TOOL",
+		kind: "ERROR",
+		status: "FAILED",
+		content,
+		itemId: readString(payload?.call_id) ?? readString(payload?.id) ?? `error:${createdAt ?? content}`,
+		createdAt,
+		metadata: { codexErrorInfo: readString(payload?.codex_error_info) ?? null }
+	};
+}
+function readCodexSessionThreadWarningMessage(payload, createdAt) {
+	const label = readString(payload?.type) === "turn_aborted" ? "Turn aborted" : "Thread rolled back";
+	const count = readNumber(payload?.num_turns);
+	return {
+		role: "TOOL",
+		kind: "WARNING",
+		content: count === void 0 ? label : `${label}\n\nturns: \`${count}\``,
+		itemId: readString(payload?.turn_id) ?? readString(payload?.turnId) ?? `warning:${createdAt ?? label}`,
+		createdAt
+	};
+}
+function readCodexSessionFallbackToolMessage(payload, createdAt) {
+	const type = readString(payload?.type);
+	if (!payload || !type || !isCodexSessionVisibleFallbackItem(type)) return null;
+	const callId = readString(payload.call_id) ?? readString(payload.id);
+	const item = {
+		...payload,
+		id: callId ?? `tool:${createdAt ?? type}`,
+		status: readString(payload.status) ?? "completed"
+	};
+	return codexActionMessage(item, "TOOL_ACTIVITY", formatCodexFallbackToolItem(item), createdAt);
+}
+function isCodexSessionVisibleFallbackItem(type) {
+	return type !== "reasoning" && type !== "function_call_output" && type !== "custom_tool_call" && type !== "custom_tool_call_output";
+}
+function readCodexSessionToolArguments(value) {
+	if (typeof value !== "string") return asJsonObject(value) ?? null;
+	return asJsonObject(parseJsonLine(value)) ?? null;
+}
+function readCodexSessionCallId(payload) {
+	return readString(payload?.call_id) ?? readString(payload?.callId) ?? readString(payload?.id) ?? null;
+}
+function isCodexSessionRunningToolOutput(payload) {
+	const output = readString(payload?.output);
+	return Boolean(output?.match(/\bProcess running with session ID \d+\b/u));
+}
+function readCodexSessionRecordTurnId(record, payload) {
+	const metadata = asJsonObject(payload?.internal_chat_message_metadata_passthrough);
+	return readString(metadata?.turn_id) ?? readString(metadata?.turnId) ?? readString(payload?.turn_id) ?? readString(payload?.turnId) ?? readString(record?.turn_id) ?? readString(record?.turnId) ?? null;
+}
+function inferCodexSessionCommandActions(command) {
+	const trimmed = command.trim();
+	if (!trimmed) return [];
+	const executable = trimmed.match(/^([A-Za-z0-9_.-]+)/u)?.[1] ?? "";
+	if (executable === "rg" || executable === "grep") return [{
+		type: "search",
+		command: trimmed,
+		query: readShellSearchQuery(trimmed),
+		path: readShellPath(trimmed)
+	}];
+	if (executable === "find") return [{
+		type: "search",
+		command: trimmed,
+		path: readShellPath(trimmed)
+	}];
+	if (executable === "ls") return [{
+		type: "listFiles",
+		command: trimmed,
+		path: readShellPath(trimmed)
+	}];
+	if ([
+		"cat",
+		"head",
+		"tail",
+		"sed",
+		"nl",
+		"wc"
+	].includes(executable)) return [{
+		type: "read",
+		command: trimmed,
+		path: readShellPath(trimmed)
+	}];
+	return [{
+		type: "unknown",
+		command: trimmed
+	}];
+}
+function readShellSearchQuery(command) {
+	return readShellArguments(command).find((token) => !token.startsWith("-")) ?? null;
+}
+function readShellPath(command) {
+	return readShellArguments(command).filter((token) => !token.startsWith("-")).at(-1) ?? null;
+}
+function readShellArguments(command) {
+	return ((command.split(/\s+(?:\||&&|\|\||;)\s+/u)[0] ?? command).match(/"[^"]+"|'[^']+'|[^\s]+/gu) ?? []).slice(1).map((token) => token.replace(/^['"]|['"]$/gu, "")).filter(Boolean);
+}
+function readCodexMessageText(value) {
+	if (typeof value === "string") return value.trim() || null;
+	if (!Array.isArray(value)) return null;
+	return value.map((item) => {
+		const object = asJsonObject(item);
+		return readString(object?.text) ?? readString(object?.content) ?? "";
+	}).filter(Boolean).join("\n").trim() || null;
+}
+function isCodexInjectedContextMessage(content) {
+	const trimmed = content.trimStart();
+	return content.includes("<environment_context>") || content.includes("# AGENTS.md instructions") || trimmed.startsWith("<user_action>");
+}
+function codexMessageRole(value) {
+	if (value === "user") return "USER";
+	if (value === "assistant") return "ASSISTANT";
+	return null;
+}
+function parseJsonLine(line) {
+	if (!line.trim()) return null;
+	try {
+		return JSON.parse(line);
+	} catch {
+		return null;
+	}
+}
+function readIsoString(value) {
+	const raw = readString(value);
+	if (!raw) return null;
+	const date = new Date(raw);
+	return Number.isNaN(date.getTime()) ? null : date.toISOString();
+}
+function newestCodexTimestamp(candidate, current) {
+	if (!candidate) return current;
+	if (!current) return candidate;
+	const candidateTime = Date.parse(candidate);
+	const currentTime = Date.parse(current);
+	if (!Number.isFinite(candidateTime)) return current;
+	if (!Number.isFinite(currentTime)) return candidate;
+	return candidateTime > currentTime ? candidate : current;
+}
+async function copyCodexThread(source, target, threadId, options = {}) {
+	try {
+		if (sameFilesystemPath(source, target)) return true;
+		if (!(await stat(source).catch(() => null))?.isDirectory()) return false;
+		await mkdir(target, {
+			recursive: true,
+			mode: 448
+		});
+		const copiedIndex = await copyCodexThreadIndex(source, target, threadId, options);
+		const copiedSession = await copyCodexThreadSessionFiles(source, target, threadId, options);
+		await copyCodexStateFiles(source, target);
+		return copiedIndex || copiedSession;
+	} catch {
+		return false;
+	}
+}
+async function copyCodexThreadIndex(source, target, threadId, options = {}) {
+	const sourceLines = (await readFile(join(source, "session_index.jsonl"), "utf8").catch(() => "")).split(/\r?\n/u).filter((line) => codexIndexLineThreadId(line) === threadId).slice(-1);
+	if (!sourceLines.length) return false;
+	const targetIndex = join(target, "session_index.jsonl");
+	const currentTargetLines = (await readFile(targetIndex, "utf8").catch(() => "")).split(/\r?\n/u).filter((line) => line.trim());
+	if (options.preserveExistingTarget && currentTargetLines.some((line) => codexIndexLineThreadId(line) === threadId)) return true;
+	await writeFile(targetIndex, `${[...currentTargetLines.filter((line) => line.trim() && codexIndexLineThreadId(line) !== threadId), ...sourceLines].join("\n")}\n`);
+	return true;
+}
+async function copyCodexThreadSessionFiles(source, target, threadId, options = {}) {
+	const sessionFiles = (await listCodexSessionFiles(source)).filter((file) => codexSessionIdFromPath(file) === threadId);
+	let copied = false;
+	for (const sourceFile of sessionFiles) {
+		const targetFile = join(target, relative(source, sourceFile));
+		if ((options.preserveExistingTarget ? await stat(targetFile).catch(() => null) : null)?.isFile()) {
+			copied = true;
+			continue;
+		}
+		await mkdir(dirname(targetFile), {
+			recursive: true,
+			mode: 448
+		});
+		await copyFile(sourceFile, targetFile);
+		copied = true;
+	}
+	return copied;
+}
+async function removeCodexThread(codexHome, threadId) {
+	try {
+		await removeCodexThreadIndex(codexHome, threadId);
+		const sessionFiles = (await listCodexSessionFiles(codexHome)).filter((file) => codexSessionIdFromPath(file) === threadId);
+		for (const sessionFile of sessionFiles) await rm(sessionFile, { force: true });
+		return true;
+	} catch {
+		return false;
+	}
+}
+async function removeCodexThreadIndex(codexHome, threadId) {
+	const indexPath = join(codexHome, "session_index.jsonl");
+	const currentLines = (await readFile(indexPath, "utf8").catch(() => "")).split(/\r?\n/u).filter((line) => line.trim());
+	const nextLines = currentLines.filter((line) => codexIndexLineThreadId(line) !== threadId);
+	if (nextLines.length !== currentLines.length) await writeFile(indexPath, nextLines.length ? `${nextLines.join("\n")}\n` : "");
+}
+function codexIndexLineThreadId(line) {
+	const row = asJsonObject(parseJsonLine(line));
+	return readString(row?.threadId) ?? readString(row?.thread_id) ?? readString(row?.id) ?? null;
+}
+async function copyCodexStateFiles(source, target) {
+	for (const entry of await readdir(source).catch(() => [])) if (/^state_\d+\.sqlite(?:-(?:wal|shm))?$/u.test(entry)) await copyIfExists(join(source, entry), join(target, entry));
+}
+async function copyIfExists(source, target) {
+	if (sameFilesystemPath(source, target)) return;
+	if (!(await stat(source).catch(() => null))?.isFile()) return;
+	await mkdir(join(target, ".."), {
+		recursive: true,
+		mode: 448
+	});
+	await copyFile(source, target);
+}
+function hasAccountAuthFile(account) {
+	return Boolean(statSyncSafe(join(resolveAccountCodexHome(account), "auth.json"))?.isFile());
+}
+function readAuthEmailAlias(account) {
+	const token = readString(asJsonObject(readAuthJson(account)?.tokens)?.id_token);
+	if (!token) return null;
+	return readString(decodeJwtPayload(token)?.email)?.split("@")[0]?.trim() || null;
+}
+function readAuthJson(account) {
+	try {
+		return asJsonObject(JSON.parse(require("node:fs").readFileSync(join(resolveAccountCodexHome(account), "auth.json"), "utf8"))) ?? null;
+	} catch {
+		return null;
+	}
+}
+function usesSharedCodexHome(account) {
+	return readString(normalizeJsonObject(account.authState).codexHomeMode) === "shared";
+}
+function decodeJwtPayload(token) {
+	const [, payload] = token.split(".");
+	if (!payload) return null;
+	try {
+		return asJsonObject(JSON.parse(Buffer.from(payload, "base64url").toString("utf8"))) ?? null;
+	} catch {
+		return null;
+	}
+}
+function statSyncSafe(pathname) {
+	try {
+		return require("node:fs").statSync(pathname);
+	} catch {
+		return null;
+	}
+}
+function readLoginAuthUrl(result, mode) {
+	if (!result) return null;
+	if (mode === "device") return readString(result.verificationUrl) ?? readString(result.verification_uri) ?? readString(result.verification_uri_complete) ?? readString(result.authUrl) ?? null;
+	return readString(result.authUrl) ?? readString(result.url) ?? null;
+}
+function parseLoopbackCallbackUrl(value) {
+	const url = new URL(value);
+	if (url.protocol !== "http:" && url.protocol !== "https:") throw new Error("Callback URL must be HTTP or HTTPS.");
+	if (![
+		"127.0.0.1",
+		"localhost",
+		"[::1]",
+		"::1"
+	].includes(url.hostname)) throw new Error("Callback URL must point at localhost.");
+	return url.toString();
+}
+function readAuthMode(value) {
+	return value === "browser" || value === "device" || value === "local" ? value : null;
+}
+function sameFilesystemPath(left, right) {
+	return resolve(left) === resolve(right);
+}
+function connectedAuthResponse(accountId, message, authState) {
+	return {
+		accountId,
+		status: "CONNECTED",
+		authMode: null,
+		...authState === void 0 ? {} : { authState },
+		authUrl: null,
+		verificationUrl: null,
+		userCode: null,
+		message
+	};
+}
+function localCodexAuthState() {
+	return {
+		codexHome: resolveSharedCodexHome(),
+		codexHomeMode: "shared"
+	};
+}
+function normalizeModelList(value) {
+	const result = asJsonObject(value);
+	return {
+		data: mergeCodexModelOptions((Array.isArray(result?.data) ? result.data : []).map((row) => {
+			const object = asJsonObject(row) ?? {};
+			const id = readString(object.id) ?? readString(object.model) ?? "unknown";
+			const upgrade = readString(object.upgrade);
+			return {
+				id,
+				model: readString(object.model) ?? id,
+				displayName: readString(object.displayName) ?? readString(object.display_name) ?? id,
+				hidden: Boolean(object.hidden),
+				defaultReasoningEffort: readString(object.defaultReasoningEffort) ?? readString(object.default_reasoning_effort) ?? null,
+				defaultServiceTier: readString(object.defaultServiceTier) ?? readString(object.default_service_tier) ?? null,
+				inputModalities: readStringList(object.inputModalities) ?? readStringList(object.input_modalities) ?? [],
+				isDefault: readBooleanValue(object.isDefault) ?? readBooleanValue(object.is_default) ?? false,
+				serviceTiers: readModelServiceTiers(object.serviceTiers) ?? readModelServiceTiers(object.service_tiers) ?? [],
+				supportsPersonality: readBooleanValue(object.supportsPersonality) ?? readBooleanValue(object.supports_personality) ?? false,
+				supportedReasoningEfforts: readSupportedReasoningEfforts(object.supportedReasoningEfforts) ?? readSupportedReasoningEfforts(object.supported_reasoning_efforts) ?? [],
+				upgradeInfo: readModelUpgradeInfo(object.upgradeInfo) ?? readModelUpgradeInfo(object.upgrade_info) ?? (upgrade ? { upgrade } : null)
+			};
+		})),
+		nextCursor: readString(result?.nextCursor) ?? readString(result?.next_cursor) ?? null
+	};
+}
+function readSupportedReasoningEfforts(value) {
+	if (!Array.isArray(value)) return null;
+	const efforts = value.map((entry) => {
+		if (typeof entry === "string") return { reasoningEffort: entry };
+		const object = asJsonObject(entry);
+		const reasoningEffort = readString(object?.reasoningEffort) ?? readString(object?.reasoning_effort);
+		return reasoningEffort ? {
+			reasoningEffort,
+			description: readString(object?.description)
+		} : null;
+	}).filter((entry) => Boolean(entry));
+	return efforts.length ? efforts : null;
+}
+function readModelServiceTiers(value) {
+	if (!Array.isArray(value)) return null;
+	const tiers = value.map((entry) => {
+		const object = asJsonObject(entry);
+		const id = readString(object?.id);
+		if (!id) return null;
+		return {
+			id,
+			name: readString(object?.name) ?? id,
+			description: readString(object?.description) ?? ""
+		};
+	}).filter((entry) => Boolean(entry));
+	return tiers.length ? tiers : null;
+}
+function readModelUpgradeInfo(value) {
+	if (value === void 0 || value === null) return null;
+	const object = asJsonObject(value);
+	return object ? jsonFromUnknown(object) : null;
+}
+function mergeCodexModelOptions(options) {
+	const merged = /* @__PURE__ */ new Map();
+	for (const option of [...codexDefaultModelOptions, ...options]) {
+		const key = (option.model || option.id).trim().toLowerCase();
+		const existing = merged.get(key);
+		merged.set(key, existing ? mergeCodexModelOption(existing, option) : option);
+	}
+	return [...merged.values()];
+}
+function mergeCodexModelOption(fallback, option) {
+	return {
+		...fallback,
+		...option,
+		defaultReasoningEffort: option.defaultReasoningEffort ?? fallback.defaultReasoningEffort,
+		supportedReasoningEfforts: option.supportedReasoningEfforts?.length ? option.supportedReasoningEfforts : fallback.supportedReasoningEfforts
+	};
+}
+function normalizeLimits(value) {
+	const result = asJsonObject(value);
+	const snapshot = asJsonObject(result?.rateLimits) ?? asJsonObject(result?.rate_limits) ?? asJsonObject(result);
+	return {
+		rateLimits: snapshot ? {
+			limitId: readString(snapshot.limitId) ?? readString(snapshot.limit_id) ?? null,
+			limitName: readString(snapshot.limitName) ?? readString(snapshot.limit_name) ?? null,
+			planType: readString(snapshot.planType) ?? readString(snapshot.plan_type) ?? null,
+			primary: normalizeLimitWindow(snapshot.primary),
+			secondary: normalizeLimitWindow(snapshot.secondary),
+			rateLimitReachedType: readString(snapshot.rateLimitReachedType) ?? readString(snapshot.rate_limit_reached_type) ?? null
+		} : void 0,
+		raw: jsonFromUnknown(value)
+	};
+}
+function normalizeLimitWindow(value) {
+	const object = asJsonObject(value);
+	if (!object) return;
+	return {
+		usedPercent: readNumberLike(object.usedPercent) ?? readNumberLike(object.used_percent) ?? 0,
+		windowDurationMins: readNumberLike(object.windowDurationMins) ?? readNumberLike(object.window_duration_mins) ?? null,
+		resetsAt: readNumberLike(object.resetsAt) ?? readNumberLike(object.resets_at) ?? null
+	};
+}
+function readNumberLike(value) {
+	return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+async function ensureCodexThread(runtime, threadId, workingDirectory, collaborationMode) {
+	const result = asJsonObject((await runtime.request(threadId ? "thread/resume" : "thread/start", {
+		...threadId ? { threadId } : {},
+		cwd: workingDirectory,
+		collaborationMode: collaborationModePayload(collaborationMode, null)
+	}, 3e4)).result);
+	const nextThreadId = readString(asJsonObject(result?.thread)?.id) ?? readString(result?.threadId) ?? readString(result?.thread_id) ?? threadId;
+	if (!nextThreadId) throw new Error("Codex did not return a thread id.");
+	return nextThreadId;
+}
+async function prepareCodexThreadForLifecycleAction(account, externalThreadId, workingDirectory) {
+	const runtime = runtimeForAccount(account, workingDirectory);
+	try {
+		if (!await hydrateKnownCodexThreadToAccount(externalThreadId, account)) throw new Error(codexThreadNotFoundMessage(externalThreadId));
+		await ensureCodexThread(runtime, externalThreadId, workingDirectory ?? null, "default");
+		return runtime;
+	} catch (error) {
+		if (isCodexThreadNotFoundError(error)) throw new Error(codexThreadNotFoundMessage(externalThreadId));
+		throw error;
+	}
+}
+async function setCodexThreadGoal(runtime, threadId, objective) {
+	await runtime.request("thread/goal/set", {
+		threadId,
+		objective: objective.trim(),
+		status: "active"
+	}, 3e4);
+}
+async function requestCodexRuntime(runtime, method, params, timeoutMs = 3e4) {
+	try {
+		return await runtime.request(method, params, timeoutMs);
+	} catch (error) {
+		if (isUnsupportedCodexMethodError(error)) throw new Error(`Codex method ${method} is not supported by this Codex binary.`);
+		throw error;
+	}
+}
+async function requestCodexOptional(runtime, method, params, timeoutMs = 3e4) {
+	try {
+		await runtime.request(method, params, timeoutMs);
+		return true;
+	} catch (error) {
+		if (isUnsupportedCodexMethodError(error)) return false;
+		throw error;
+	}
+}
+function isUnsupportedCodexMethodError(error) {
+	const message = readErrorMessage$1(error).toLowerCase();
+	return message.includes("method not found") || message.includes("unknown method") || message.includes("unsupported method") || message.includes("-32601");
+}
+function isCodexRequestUserInputMethod(method) {
+	const normalized = normalizedCodexName(method);
+	return normalized === "itemtoolrequestuserinput" || normalized.endsWith("requestuserinput");
+}
+function isCodexRequestUserInputName(name) {
+	return normalizedCodexName(name) === "requestuserinput";
+}
+function normalizedCodexName(value) {
+	return value.toLowerCase().replace(/[^a-z0-9]/gu, "");
+}
+function codexUserInputPromptStatus(value) {
+	if (value === "completed") return "COMPLETED";
+	if (value === "failed" || value === "declined") return "FAILED";
+	return "PENDING";
+}
+function isCodexThreadNotFoundError(error) {
+	const message = readErrorMessage$1(error).toLowerCase();
+	return message.includes("thread not found") || message.includes("thread") && message.includes("not found");
+}
+function codexThreadNotFoundMessage(threadId) {
+	return `Codex could not find thread ${threadId} in the selected account home. The local chat points at a Codex thread that is missing from that account's history; switch back to the account that owns it or refresh/sync the chat history, then try again.`;
+}
+function codexReviewTargetPayload(request) {
+	const target = request?.target;
+	const instructions = request?.instructions?.trim();
+	if (target === "custom" || instructions) return {
+		type: "custom",
+		instructions: instructions || "Review the current changes."
+	};
+	const commitSha = request?.commitSha?.trim();
+	if (target === "commit" || commitSha) return {
+		type: "commit",
+		sha: commitSha || "HEAD",
+		title: request?.commitTitle?.trim() || null
+	};
+	const branch = request?.baseBranch?.trim();
+	if (target === "baseBranch" || branch) return {
+		type: "baseBranch",
+		branch: branch || "main"
+	};
+	return { type: "uncommittedChanges" };
+}
+function codexAccessMode(permissionMode) {
+	if (permissionMode === "fullAccess") return {
+		approvalPolicy: "never",
+		sandboxPolicy: { type: "dangerFullAccess" }
+	};
+	if (permissionMode === "askForApproval") return {
+		approvalPolicy: "on-request",
+		sandboxPolicy: null
+	};
+	return {
+		approvalPolicy: null,
+		sandboxPolicy: null
+	};
+}
+function codexInputItems(content, attachments) {
+	const attachmentText = codexAttachmentSummaryText(attachments);
+	const items = [{
+		type: "text",
+		text: [content.trim(), attachmentText].filter(Boolean).join("\n\n") || "Attached context",
+		text_elements: []
+	}];
+	for (const attachment of attachments) {
+		if (attachment.kind !== "image") continue;
+		if (attachment.dataUrl) items.push({
+			type: "image",
+			url: attachment.dataUrl
+		});
+		else if (attachment.path) items.push({
+			type: "localImage",
+			path: attachment.path
+		});
+	}
+	return items;
+}
+function codexAttachmentSummaryText(attachments) {
+	const lines = attachments.filter((attachment) => attachment.kind !== "image" || !attachment.dataUrl).map((attachment) => {
+		const path = attachment.path && attachment.path !== attachment.name ? ` (${attachment.path})` : "";
+		return `- ${attachment.kind}: ${attachment.name}${path}`;
+	});
+	return lines.length ? `Attached context:\n${lines.join("\n")}` : null;
+}
+async function resolveCollaborationSettings(runtime, model, reasoningEffort, serviceTier) {
+	const normalizedReasoningEffort = normalizeCodexReasoningEffort(reasoningEffort);
+	if (model) return {
+		model,
+		reasoningEffort: normalizedReasoningEffort,
+		serviceTier
+	};
+	try {
+		const configuredModel = readString(asJsonObject(asJsonObject((await runtime.request("config/read", {}, 3e4)).result)?.config)?.model);
+		if (configuredModel) return {
+			model: configuredModel,
+			reasoningEffort: normalizedReasoningEffort,
+			serviceTier
+		};
+	} catch {
+		return null;
+	}
+	return null;
+}
+function collaborationModePayload(collaborationMode, settings) {
+	const reasoningEffort = normalizeCodexReasoningEffort(settings?.reasoningEffort);
+	return {
+		mode: collaborationMode || "default",
+		...settings?.model ? { settings: {
+			model: settings.model,
+			reasoning_effort: reasoningEffort,
+			service_tier: settings.serviceTier ?? null
+		} } : {}
+	};
+}
+function normalizeCodexReasoningEffort(value) {
+	const normalized = value?.trim();
+	if (!normalized) return null;
+	if (normalized === "extraHigh" || normalized === "extra-high" || normalized === "extra_high") return "xhigh";
+	if (normalized === "fast") return "low";
+	if (normalized === "deep") return "high";
+	return normalized;
+}
+async function maybeMarkInvalidated(accountId, error) {
+	if (!isAuthInvalidatedError(error)) return;
+	invalidatedAccountIds.add(accountId);
+	runtimeService.stopRuntime(accountId);
+}
+function isAuthInvalidatedError(error) {
+	const message = readErrorMessage$1(error).toLowerCase();
+	return message.includes("token_invalidated") || message.includes("authentication token has been invalidated") || message.includes("401") && message.includes("unauthorized") && message.includes("invalidated");
+}
+function readStringArray(value) {
+	return Array.isArray(value) && value.every((entry) => typeof entry === "string") ? value : void 0;
+}
+function readStringList(value) {
+	return Array.isArray(value) && value.every((entry) => typeof entry === "string") ? value : null;
+}
+function readBooleanValue(value) {
+	return typeof value === "boolean" ? value : null;
+}
+function readStringRecord(value) {
+	const object = asJsonObject(value);
+	if (!object) return {};
+	return Object.fromEntries(Object.entries(object).filter((entry) => typeof entry[1] === "string"));
+}
+function jsonFromUnknown(value) {
+	return JSON.parse(JSON.stringify(value ?? null));
+}
+function resolveCodexBin() {
+	try {
+		return require.resolve("@openai/codex/bin/codex.js");
+	} catch {
+		return "codex";
+	}
+}
+function readErrorMessage$1(error) {
+	return error instanceof Error ? error.message : String(error ?? "Unknown error");
+}
+var CodexRuntime = class {
+	constructor(config) {
+		this.config = config;
+		this.stdoutBuffer = "";
+		this.pending = /* @__PURE__ */ new Map();
+		this.eventHandlers = /* @__PURE__ */ new Set();
+	}
+	request(method, params, timeoutMs = 3e4) {
+		return this.ensureStarted().then(() => this.requestStarted(method, params, timeoutMs));
+	}
+	respondToServerRequest(requestId, result) {
+		return this.ensureStarted().then(() => {
+			this.child?.stdin.write(`${JSON.stringify({
+				id: requestId,
+				result
+			})}\n`);
+		});
+	}
+	waitForEvent(predicate, timeoutMs = 12e4, signal) {
+		return new Promise((resolve, reject) => {
+			if (signal?.aborted) {
+				reject(/* @__PURE__ */ new Error("Codex event wait cancelled."));
+				return;
+			}
+			let unsubscribe = () => void 0;
+			const cleanup = () => {
+				clearTimeout(timeout);
+				signal?.removeEventListener("abort", abort);
+				unsubscribe();
+			};
+			const abort = () => {
+				cleanup();
+				reject(/* @__PURE__ */ new Error("Codex event wait cancelled."));
+			};
+			const timeout = setTimeout(() => {
+				cleanup();
+				reject(/* @__PURE__ */ new Error("Timed out waiting for Codex event."));
+			}, timeoutMs);
+			signal?.addEventListener("abort", abort, { once: true });
+			unsubscribe = this.onEvent((message) => {
+				if (!predicate(message)) return;
+				cleanup();
+				resolve(message);
+			});
+		});
+	}
+	onEvent(handler) {
+		this.eventHandlers.add(handler);
+		return () => this.eventHandlers.delete(handler);
+	}
+	shutdown() {
+		for (const waiter of this.pending.values()) {
+			clearTimeout(waiter.timeout);
+			waiter.reject(/* @__PURE__ */ new Error("Codex runtime stopped."));
+		}
+		this.pending.clear();
+		this.child?.kill("SIGTERM");
+		this.child = void 0;
+		this.initializePromise = void 0;
+	}
+	async ensureStarted() {
+		if (this.initializePromise) return this.initializePromise;
+		ensureCodexHome(this.config.codexHome);
+		this.child = spawn(this.config.command, this.config.args, {
+			cwd: this.config.workingDirectory ?? void 0,
+			env: {
+				...process.env,
+				...this.config.environment,
+				CODEX_HOME: this.config.codexHome
+			},
+			stdio: [
+				"pipe",
+				"pipe",
+				"pipe"
+			]
+		});
+		this.child.stdout.on("data", (chunk) => this.handleStdout(chunk));
+		this.child.stderr.on("data", (chunk) => {
+			const message = chunk.toString("utf8").trim();
+			if (message && isAuthInvalidatedError(message)) invalidatedAccountIds.add(this.config.accountId);
+		});
+		this.child.on("error", (error) => this.failAll(error));
+		this.child.on("close", (code) => {
+			this.failAll(/* @__PURE__ */ new Error(`Codex runtime exited with code ${code ?? "unknown"}.`));
+			this.child = void 0;
+			this.initializePromise = void 0;
+		});
+		this.initializePromise = this.initialize();
+		return this.initializePromise;
+	}
+	async initialize() {
+		await this.requestStarted("initialize", {
+			clientInfo: {
+				name: "pockcode",
+				title: "pockcode",
+				version: "0.1.0"
+			},
+			capabilities: { experimentalApi: true }
+		});
+		this.child?.stdin.write(`${JSON.stringify({ method: "initialized" })}\n`);
+	}
+	requestStarted(method, params, timeoutMs = 3e4) {
+		const id = `pockcode-${randomUUID()}`;
+		const payload = JSON.stringify(params === void 0 ? {
+			id,
+			method
+		} : {
+			id,
+			method,
+			params
+		});
+		return new Promise((resolve, reject) => {
+			const timeout = setTimeout(() => {
+				this.pending.delete(id);
+				reject(/* @__PURE__ */ new Error(`Codex request timed out: ${method}`));
+			}, timeoutMs);
+			this.pending.set(id, {
+				method,
+				reject,
+				resolve,
+				startedAt: Date.now(),
+				timeout
+			});
+			this.child?.stdin.write(`${payload}\n`);
+		});
+	}
+	handleStdout(chunk) {
+		this.stdoutBuffer += chunk.toString("utf8");
+		const lines = this.stdoutBuffer.split("\n");
+		this.stdoutBuffer = lines.pop() ?? "";
+		for (const line of lines) {
+			const trimmed = line.trim();
+			if (trimmed) this.handleLine(trimmed);
+		}
+	}
+	handleLine(line) {
+		let message;
+		try {
+			message = JSON.parse(line);
+		} catch {
+			return;
+		}
+		if (message.id === void 0 || message.id === null) {
+			for (const handler of this.eventHandlers) handler(message);
+			return;
+		}
+		const waiter = this.pending.get(String(message.id));
+		if (!waiter) {
+			if (message.method) for (const handler of this.eventHandlers) handler(message);
+			return;
+		}
+		clearTimeout(waiter.timeout);
+		this.pending.delete(String(message.id));
+		if (message.error) {
+			waiter.reject(new Error(message.error.message ?? "Codex request failed."));
+			return;
+		}
+		waiter.resolve(message);
+	}
+	failAll(error) {
+		for (const waiter of this.pending.values()) {
+			clearTimeout(waiter.timeout);
+			waiter.reject(error);
+		}
+		this.pending.clear();
+	}
+};
+var CodexRuntimeService = class {
+	constructor() {
+		this.runtimes = /* @__PURE__ */ new Map();
+	}
+	getRuntime(config) {
+		const existing = this.runtimes.get(config.accountId);
+		if (existing) return existing;
+		const runtime = new CodexRuntime(config);
+		this.runtimes.set(config.accountId, runtime);
+		return runtime;
+	}
+	stopRuntime(accountId) {
+		this.runtimes.get(accountId)?.shutdown();
+		this.runtimes.delete(accountId);
+	}
+};
+var runtimeService = new CodexRuntimeService();
+//#endregion
+//#region app/server/providers/registry.server.ts
+var adapters = new Map([[codexProviderAdapter.definition.id, codexProviderAdapter]]);
+function listProviderAdapters() {
+	return [...adapters.values()];
+}
+function getProviderAdapter(providerId) {
+	const adapter = adapters.get(providerId);
+	if (!adapter) throw new Error(`Unknown provider: ${providerId}`);
+	return adapter;
+}
+//#endregion
+//#region app/server/accounts.service.ts
+async function listAccounts() {
+	await ensureDatabase();
+	const accounts = await prisma.providerAccount.findMany({ orderBy: { createdAt: "asc" } });
+	return (await Promise.all(accounts.map(refreshAccountConnection))).map(serializeAccount);
+}
+async function createAccount(dto) {
+	await ensureDatabase();
+	const adapter = getProviderAdapter(dto.providerId);
+	const account = await prisma.providerAccount.create({ data: {
+		providerId: dto.providerId,
+		displayName: normalizedDisplayName(dto.displayName, adapter.definition.label),
+		settings: {
+			...adapter.defaultAccountSettings(),
+			...dto.settings ?? {}
+		},
+		runtimeDefaults: {
+			...adapter.defaultRuntimeDefaults(),
+			...dto.runtimeDefaults ?? {}
+		}
+	} });
+	await adapter.prepareAccount(account);
+	return serializeAccount(account);
+}
+async function getAccount(accountId) {
+	await ensureDatabase();
+	const account = await prisma.providerAccount.findUnique({ where: { id: accountId } });
+	if (!account) throw new HttpError(404, "Provider account not found.");
+	return refreshAccountConnection(account);
+}
+async function updateAccount(accountId, dto) {
+	const account = await getAccount(accountId);
+	const adapter = getProviderAdapter(account.providerId);
+	adapter.stopAccountRuntime(account.id);
+	const updated = await prisma.providerAccount.update({
+		where: { id: accountId },
+		data: {
+			displayName: dto.displayName,
+			settings: dto.settings === void 0 ? void 0 : dto.settings,
+			runtimeDefaults: dto.runtimeDefaults === void 0 ? void 0 : dto.runtimeDefaults
+		}
+	});
+	await adapter.prepareAccount(updated);
+	return serializeAccount(updated);
+}
+async function deleteAccount(accountId) {
+	const account = await getAccount(accountId);
+	getProviderAdapter(account.providerId).stopAccountRuntime(account.id);
+	await prisma.chat.updateMany({
+		where: { accountId },
+		data: { accountId: null }
+	});
+	await prisma.chatRun.updateMany({
+		where: { accountId },
+		data: { accountId: null }
+	});
+	await prisma.mcpServerInstallation.deleteMany({ where: { accountId } });
+	return serializeAccount(await prisma.providerAccount.delete({ where: { id: accountId } }));
+}
+async function authenticateAccount(accountId, mode = "browser") {
+	const account = await getAccount(accountId);
+	const adapter = getProviderAdapter(account.providerId);
+	await prisma.providerAccount.update({
+		where: { id: accountId },
+		data: {
+			status: "AUTHENTICATING",
+			lastAuthUrl: null,
+			lastAuthMode: mode,
+			lastAuthLoginId: null,
+			lastAuthUserCode: null,
+			lastError: null
+		}
+	});
+	const response = await adapter.authenticate(account, mode);
+	await prisma.providerAccount.update({
+		where: { id: accountId },
+		data: await accountAuthData(account, adapter, response)
+	});
+	return response;
+}
+async function listAccountModels(accountId) {
+	const account = await requireConnectedAccount(accountId);
+	return getProviderAdapter(account.providerId).listModels(account);
+}
+async function readConnectedAccountLimits() {
+	await ensureDatabase();
+	const accounts = await prisma.providerAccount.findMany({
+		orderBy: { createdAt: "asc" },
+		where: { status: "CONNECTED" }
+	});
+	const data = {};
+	const errors = {};
+	for (const account of accounts) try {
+		data[account.id] = await getProviderAdapter(account.providerId).readLimits(account);
+	} catch (error) {
+		errors[account.id] = error instanceof Error ? error.message : "Unable to load limits.";
+	}
+	return {
+		data,
+		...Object.keys(errors).length ? { errors } : {}
+	};
+}
+async function requireConnectedAccount(accountId) {
+	const account = await getAccount(accountId);
+	if (account.status !== "CONNECTED") throw new HttpError(400, "Authenticate the provider account before using it.");
+	return account;
+}
+function serializeAccount(account) {
+	return {
+		id: account.id,
+		providerId: account.providerId,
+		displayName: account.displayName,
+		status: account.status,
+		settings: account.settings,
+		runtimeDefaults: account.runtimeDefaults,
+		authState: account.authState ?? null,
+		lastAuthUrl: account.lastAuthUrl,
+		lastAuthMode: account.lastAuthMode === "browser" || account.lastAuthMode === "device" || account.lastAuthMode === "local" ? account.lastAuthMode : null,
+		lastAuthLoginId: account.lastAuthLoginId,
+		lastAuthUserCode: account.lastAuthUserCode,
+		lastError: account.lastError,
+		createdAt: account.createdAt.toISOString(),
+		updatedAt: account.updatedAt.toISOString()
+	};
+}
+async function refreshAccountConnection(account) {
+	const adapter = getProviderAdapter(account.providerId);
+	await adapter.prepareAccount(account);
+	if (!adapter.isAccountConnected || !await adapter.isAccountConnected(account)) return account;
+	if (account.status === "CONNECTED" && !usesDefaultDisplayName(account.displayName, adapter.definition.label)) return account;
+	return prisma.providerAccount.update({
+		where: { id: account.id },
+		data: {
+			displayName: await connectedDisplayName(account, adapter),
+			status: "CONNECTED",
+			lastAuthUrl: null,
+			lastAuthMode: null,
+			lastAuthLoginId: null,
+			lastAuthUserCode: null,
+			lastError: null
+		}
+	});
+}
+async function accountAuthData(account, adapter, response) {
+	const accountForResponse = response.authState === void 0 ? account : {
+		...account,
+		authState: response.authState
+	};
+	return {
+		...response.status === "CONNECTED" ? { displayName: await connectedDisplayName(accountForResponse, adapter) } : {},
+		...response.authState === void 0 ? {} : { authState: response.authState },
+		status: response.status,
+		lastAuthUrl: response.authUrl,
+		lastAuthMode: response.authMode,
+		lastAuthLoginId: response.loginId,
+		lastAuthUserCode: response.userCode,
+		lastError: response.status === "ERROR" ? response.message ?? "Authentication failed." : null
+	};
+}
+async function connectedDisplayName(account, adapter) {
+	if (!usesDefaultDisplayName(account.displayName, adapter.definition.label)) return;
+	return await adapter.readAccountAlias?.(account) ?? void 0;
+}
+function usesDefaultDisplayName(displayName, providerLabel) {
+	return displayName.trim() === normalizedDisplayName(void 0, providerLabel);
+}
+function normalizedDisplayName(displayName, providerLabel) {
+	return displayName?.trim() || `${providerLabel} account`;
+}
+//#endregion
+//#region app/server/chats.service.ts
+var providerChatsSyncPromise = null;
+var messageSnapshotsByChatId = /* @__PURE__ */ new Map();
+var messageSnapshotSeparator = "\0";
+var localRunGraceMs = 12e4;
+var recentInterruptSuppressMs = 1800 * 1e3;
+async function createChat(dto) {
+	await ensureDatabase();
+	const account = await requireConnectedAccount(dto.accountId);
+	const providerId = dto.providerId ?? account.providerId;
+	if (providerId !== account.providerId) throw new HttpError(400, "Chat provider must match the selected account provider.");
+	const chat = await prisma.chat.create({ data: {
+		providerId,
+		accountId: account.id,
+		autoRotateAccount: dto.autoRotateAccount ?? false,
+		title: normalizeTitle(dto.title) ?? "New chat",
+		workingDirectory: dto.workingDirectory,
+		model: nullableString(dto.model),
+		reasoningEffort: nullableString(dto.reasoningEffort),
+		serviceTier: nullableString(dto.serviceTier),
+		collaborationMode: nullableString(dto.collaborationMode) ?? "default",
+		permissionMode: nullableString(dto.permissionMode) ?? "default"
+	} });
+	publishProviderEvent({
+		threadId: chat.id,
+		type: "chat.updated",
+		payload: serializeChat(chat)
+	});
+	return serializeChat(chat);
+}
+async function listChats(workingDirectory) {
+	await ensureDatabase();
+	return (await overlayCachedChatStates(dedupeChatList(await prisma.chat.findMany({
+		orderBy: [{ lastActivityAt: "desc" }, { updatedAt: "desc" }],
+		where: {
+			status: { not: "ARCHIVED" },
+			...workingDirectory?.trim() ? { workingDirectory: workingDirectory.trim() } : {}
+		}
+	})))).map((chat) => serializeChat(chat));
+}
+async function getChat(chatId) {
+	await ensureDatabase();
+	const chat = await prisma.chat.findUnique({ where: { id: chatId } });
+	if (!chat) throw new HttpError(404, "Chat not found.");
+	return chat;
+}
+async function updateChat(chatId, dto) {
+	const chat = await getChat(chatId);
+	if (chat.status === "RUNNING" && hasBlockedRunningChatUpdate(dto)) throw new HttpError(400, "Wait for the current run to finish before changing chat runtime settings.");
+	const targetAccount = dto.accountId === void 0 || dto.accountId === chat.accountId ? null : dto.accountId === null ? null : await requireConnectedAccount(dto.accountId);
+	if (targetAccount && targetAccount.providerId !== chat.providerId) throw new HttpError(400, "Switching provider types for an existing chat is not supported.");
+	if (targetAccount && targetAccount.id !== chat.accountId && chat.externalThreadId) {
+		publishAccountSwitchProgress(chat.id, chat.accountId, targetAccount.id, "preparing");
+		try {
+			const fromAdapter = getProviderAdapter(chat.providerId);
+			const toAdapter = getProviderAdapter(targetAccount.providerId);
+			const fromAccount = chat.accountId ? await requireConnectedAccount(chat.accountId).catch(() => null) : null;
+			const threadId = chat.externalThreadId;
+			const context = {
+				threadId,
+				fromAccount,
+				toAccount: targetAccount
+			};
+			publishAccountSwitchProgress(chat.id, chat.accountId, targetAccount.id, "syncingSource");
+			if (!(fromAccount ? await fromAdapter.moveThreadToAccount?.(context) ?? false : false)) {
+				await fromAdapter.beforeAccountSwitch?.(context);
+				const synced = fromAccount ? await fromAdapter.syncThreadFromAccount(threadId, fromAccount) : true;
+				publishAccountSwitchProgress(chat.id, chat.accountId, targetAccount.id, "hydratingTarget");
+				const hydrated = await toAdapter.hydrateThreadForAccount(threadId, targetAccount);
+				if (!synced || !hydrated) throw new HttpError(500, "Unable to move chat history to the selected provider account.");
+				await fromAdapter.afterAccountSwitch?.(context);
+				if (fromAdapter !== toAdapter) await toAdapter.afterAccountSwitch?.(context);
+			}
+		} catch (error) {
+			publishAccountSwitchProgress(chat.id, chat.accountId, targetAccount.id, "failed", readErrorMessage(error));
+			throw error;
+		}
+	}
+	if (dto.title !== void 0 && chat.externalThreadId) {
+		const renameAccount = targetAccount ?? (chat.accountId ? await requireConnectedAccount(chat.accountId).catch(() => null) : null);
+		const nextTitle = normalizeTitle(dto.title) ?? "Untitled chat";
+		if (renameAccount) await getProviderAdapter(renameAccount.providerId).renameThread?.(renameAccount, chat.externalThreadId, nextTitle, chat.workingDirectory).catch(() => false);
+	}
+	const updated = await prisma.chat.update({
+		where: { id: chatId },
+		data: {
+			accountId: dto.accountId === void 0 ? void 0 : dto.accountId,
+			autoRotateAccount: dto.autoRotateAccount,
+			providerId: targetAccount ? targetAccount.providerId : void 0,
+			title: dto.title === void 0 ? void 0 : normalizeTitle(dto.title) ?? "Untitled chat",
+			workingDirectory: dto.workingDirectory,
+			model: dto.model === void 0 ? void 0 : nullableString(dto.model),
+			reasoningEffort: dto.reasoningEffort === void 0 ? void 0 : nullableString(dto.reasoningEffort),
+			serviceTier: dto.serviceTier === void 0 ? void 0 : nullableString(dto.serviceTier),
+			collaborationMode: dto.collaborationMode === void 0 ? void 0 : nullableString(dto.collaborationMode) ?? "default",
+			permissionMode: dto.permissionMode === void 0 ? void 0 : nullableString(dto.permissionMode) ?? "default"
+		}
+	});
+	if (targetAccount && updated.externalThreadId) await prisma.chat.updateMany({
+		where: {
+			externalThreadId: updated.externalThreadId,
+			id: { not: updated.id },
+			status: { not: "ARCHIVED" }
+		},
+		data: { status: "ARCHIVED" }
+	});
+	const response = serializeChat(updated);
+	publishProviderEvent({
+		threadId: updated.id,
+		type: "chat.updated",
+		payload: response
+	});
+	if (targetAccount && updated.externalThreadId) {
+		publishAccountSwitchProgress(updated.id, chat.accountId, targetAccount.id, "refreshingMessages");
+		await publishMessageDeltas(updated.id);
+		publishAccountSwitchProgress(updated.id, chat.accountId, targetAccount.id, "completed");
+	}
+	return response;
+}
+function hasBlockedRunningChatUpdate(dto) {
+	return dto.accountId !== void 0 || dto.autoRotateAccount !== void 0 || dto.collaborationMode !== void 0 || dto.model !== void 0 || dto.reasoningEffort !== void 0 || dto.serviceTier !== void 0 || dto.title !== void 0 || dto.workingDirectory !== void 0;
+}
+async function archiveChat(chatId) {
+	const chat = await getChat(chatId);
+	if (chat.accountId && chat.externalThreadId) {
+		const account = await requireConnectedAccount(chat.accountId).catch(() => null);
+		if (account) await getProviderAdapter(chat.providerId).archiveThread?.(account, chat.externalThreadId, chat.workingDirectory).catch(() => false);
+	}
+	const archived = await prisma.chat.update({
+		where: { id: chatId },
+		data: { status: "ARCHIVED" }
+	});
+	publishProviderEvent({
+		threadId: archived.id,
+		type: "chat.updated",
+		payload: serializeChat(archived)
+	});
+	return serializeChat(archived);
+}
+async function forkChat(chatId, request = {}) {
+	const { account, adapter, chat, externalThreadId } = await requireProviderBackedChat(chatId, "fork");
+	if (!adapter.forkThread) throw new HttpError(400, "This provider does not support forking chats.");
+	const forked = await adapter.forkThread(account, externalThreadId, request, chat.workingDirectory);
+	const created = await prisma.chat.create({ data: {
+		accountId: account.id,
+		autoRotateAccount: chat.autoRotateAccount,
+		collaborationMode: chat.collaborationMode,
+		externalThreadId: forked.externalThreadId,
+		lastActivityAt: /* @__PURE__ */ new Date(),
+		model: chat.model,
+		permissionMode: chat.permissionMode,
+		providerId: chat.providerId,
+		reasoningEffort: chat.reasoningEffort,
+		serviceTier: chat.serviceTier,
+		status: "IDLE",
+		title: normalizeTitle(forked.title) ?? `${chat.title} fork`,
+		workingDirectory: forked.workingDirectory ?? chat.workingDirectory
+	} });
+	const response = serializeChat(created);
+	publishProviderEvent({
+		threadId: created.id,
+		type: "chat.updated",
+		payload: response
+	});
+	await publishMessageDeltas(created.id);
+	return response;
+}
+async function compactChat(chatId, request = {}) {
+	const { account, adapter, chat, externalThreadId } = await requireProviderBackedChat(chatId, "compact");
+	if (!adapter.compactThread) throw new HttpError(400, "This provider does not support compacting chats.");
+	await adapter.compactThread(account, externalThreadId, request, chat.workingDirectory);
+	const updated = await prisma.chat.update({
+		where: { id: chat.id },
+		data: { lastActivityAt: /* @__PURE__ */ new Date() }
+	});
+	const response = serializeChat(updated);
+	publishProviderEvent({
+		threadId: updated.id,
+		type: "chat.updated",
+		payload: response
+	});
+	await publishMessageDeltas(updated.id);
+	return response;
+}
+async function reviewChat(chatId, request = {}) {
+	const { account, adapter, chat, externalThreadId } = await requireProviderBackedChat(chatId, "review");
+	if (!adapter.reviewThread) throw new HttpError(400, "This provider does not support review.");
+	await adapter.reviewThread(account, externalThreadId, request, chat.workingDirectory);
+	const updated = await prisma.chat.update({
+		where: { id: chat.id },
+		data: {
+			lastActivityAt: /* @__PURE__ */ new Date(),
+			status: "RUNNING"
+		}
+	});
+	const response = serializeChat(updated);
+	publishProviderEvent({
+		threadId: updated.id,
+		type: "chat.updated",
+		payload: response
+	});
+	await publishMessageDeltas(updated.id);
+	return response;
+}
+async function refreshChat(chatId) {
+	const chat = serializeChat(await getChat(chatId));
+	const messages = await readMessagePage(chatId);
+	rememberMessageSnapshot(chatId, messages.data);
+	return {
+		chat,
+		messages
+	};
+}
+async function listMessages(chatId, limit = 1e3) {
+	const page = await readMessagePage(chatId, limit);
+	rememberMessageSnapshot(chatId, page.data);
+	return page;
+}
+async function readMessagePage(chatId, limit = 1e3) {
+	const chat = await getChat(chatId);
+	const safeLimit = Math.min(Math.max(limit, 1), 1e3);
+	const providerMessages = await loadProviderMessages(chat);
+	const messages = [...providerMessages, ...await readRunPreviewMessages(chat, providerMessages)].slice(0, safeLimit);
+	return {
+		data: messages.map((message, index) => serializeProviderMessage(chat.id, message, index + 1)),
+		hasMoreBefore: false,
+		nextCursor: messages.length ? messages.length : null,
+		previousCursor: messages.length ? 1 : null
+	};
+}
+async function publishMessageDeltas(chatId) {
+	const page = await readMessagePage(chatId);
+	const previous = messageSnapshotsByChatId.get(chatId) ?? /* @__PURE__ */ new Map();
+	const next = messageSnapshotMap(page.data);
+	const removedIds = [...previous.keys()].filter((messageId) => !next.has(messageId));
+	const changedMessages = page.data.filter((message) => previous.get(message.id) !== next.get(message.id));
+	rememberMessageSnapshot(chatId, page.data);
+	for (const messageId of removedIds) publishProviderEvent({
+		threadId: chatId,
+		type: "message.deleted",
+		payload: {
+			chatId,
+			messageId
+		}
+	});
+	for (const message of changedMessages) publishMessageCreated(chatId, message);
+}
+function publishMessageCreated(chatId, message) {
+	rememberPublishedMessage(chatId, message);
+	publishProviderEvent({
+		threadId: chatId,
+		type: "message.created",
+		payload: message
+	});
+}
+function publishAccountSwitchProgress(chatId, fromAccountId, toAccountId, phase, error) {
+	publishProviderEvent({
+		threadId: chatId,
+		type: "chat.accountSwitch",
+		payload: {
+			chatId,
+			fromAccountId,
+			toAccountId,
+			phase,
+			error: error ?? null
+		}
+	});
+}
+function rememberMessageSnapshot(chatId, messages) {
+	messageSnapshotsByChatId.set(chatId, messageSnapshotMap(messages));
+}
+function rememberPublishedMessage(chatId, message) {
+	const snapshot = messageSnapshotsByChatId.get(chatId) ?? /* @__PURE__ */ new Map();
+	snapshot.set(message.id, messageSnapshot(message));
+	messageSnapshotsByChatId.set(chatId, snapshot);
+}
+function messageSnapshotMap(messages) {
+	return new Map(messages.map((message) => [message.id, messageSnapshot(message)]));
+}
+function messageSnapshot(message) {
+	return [
+		message.sequence,
+		message.itemId,
+		message.role,
+		message.kind,
+		message.status,
+		message.createdAt,
+		message.completedAt,
+		message.content
+	].join(messageSnapshotSeparator);
+}
+function knownMessageSequence(chatId, messageId) {
+	const snapshot = messageSnapshotsByChatId.get(chatId)?.get(messageId);
+	if (!snapshot) return null;
+	const sequence = Number.parseInt(snapshot.split(messageSnapshotSeparator, 1)[0] ?? "", 10);
+	return Number.isFinite(sequence) && sequence > 0 ? sequence : null;
+}
+function nextKnownMessageSequence(chatId) {
+	const snapshot = messageSnapshotsByChatId.get(chatId);
+	if (!snapshot?.size) return 1;
+	let maxSequence = 0;
+	for (const value of snapshot.values()) {
+		const sequence = Number.parseInt(value.split(messageSnapshotSeparator, 1)[0] ?? "", 10);
+		if (Number.isFinite(sequence)) maxSequence = Math.max(maxSequence, sequence);
+	}
+	return maxSequence + 1;
+}
+function nextMessageSequenceForChat(chat) {
+	if (messageSnapshotsByChatId.get(chat.id)?.size) return nextKnownMessageSequence(chat.id);
+	return 1;
+}
+async function overlayCachedChatStates(chats) {
+	const groups = /* @__PURE__ */ new Map();
+	for (const chat of chats) {
+		if (!chat.accountId || !chat.externalThreadId) continue;
+		const key = `${chat.providerId}:${chat.accountId}`;
+		const group = groups.get(key) ?? {
+			accountId: chat.accountId,
+			chats: [],
+			providerId: chat.providerId
+		};
+		group.chats.push(chat);
+		groups.set(key, group);
+	}
+	if (!groups.size) return chats;
+	const overlays = /* @__PURE__ */ new Map();
+	for (const group of groups.values()) {
+		const account = await requireConnectedAccount(group.accountId).catch(() => null);
+		if (!account) continue;
+		const adapter = getProviderAdapter(group.providerId);
+		if (!adapter.readCachedChatStates) continue;
+		const states = await adapter.readCachedChatStates(account, group.chats.map((chat) => chat.externalThreadId).filter((id) => Boolean(id))).catch(() => null);
+		if (!states?.size) continue;
+		for (const chat of group.chats) {
+			const state = chat.externalThreadId ? states.get(chat.externalThreadId) : null;
+			if (!state) continue;
+			let next = overlays.get(chat.id) ?? chat;
+			const updatedAt = parseProviderDate(state.updatedAt ?? null);
+			if (updatedAt && updatedAt.getTime() > next.lastActivityAt.getTime()) next = {
+				...next,
+				lastActivityAt: updatedAt
+			};
+			if (state.status === "RUNNING") {
+				if (await hasRecentInterruptRequest(chat.id) && !await hasActiveChatRun(chat.id, "RUNNING")) next = {
+					...next,
+					status: "IDLE"
+				};
+				else if (next.status !== "RUNNING") next = {
+					...next,
+					status: "RUNNING"
+				};
+			}
+			if (next !== chat) overlays.set(chat.id, next);
+		}
+	}
+	return chats.map((chat) => overlays.get(chat.id) ?? chat);
+}
+async function refreshChatStatusesForWorkspaces(workspacePaths) {
+	await ensureDatabase();
+	const paths = workspacePaths.map((path) => path.trim()).filter(Boolean);
+	if (!paths.length) return [];
+	const chats = await prisma.chat.findMany({
+		orderBy: [{ lastActivityAt: "desc" }, { updatedAt: "desc" }],
+		where: {
+			status: { not: "ARCHIVED" },
+			workingDirectory: { in: paths },
+			externalThreadId: { not: null },
+			accountId: { not: null }
+		}
+	});
+	const updatedChats = [];
+	for (const chat of chats) {
+		if (!chat.accountId || !chat.externalThreadId) continue;
+		const account = await requireConnectedAccount(chat.accountId).catch(() => null);
+		if (!account) continue;
+		const adapter = getProviderAdapter(chat.providerId);
+		let status = adapter.readChatStatus ? await adapter.readChatStatus(account, chat.externalThreadId).catch(() => null) : null;
+		const hasActiveRun = await hasActiveChatRun(chat.id, status);
+		if (status === "RUNNING" && !hasActiveRun && await hasRecentInterruptRequest(chat.id)) status = "IDLE";
+		if (status !== "RUNNING" && hasActiveRun) status = "RUNNING";
+		if (!status || status === chat.status) continue;
+		const updated = await prisma.chat.update({
+			where: { id: chat.id },
+			data: { status }
+		});
+		updatedChats.push(serializeChat(updated));
+	}
+	return updatedChats;
+}
+async function syncProviderChats() {
+	const stats = /* @__PURE__ */ new Map();
+	const accounts = await prisma.providerAccount.findMany({
+		orderBy: { createdAt: "asc" },
+		where: { status: "CONNECTED" }
+	});
+	for (const account of accounts) for (const [key, value] of await syncProviderAccountChats(account)) stats.set(key, value);
+	return stats;
+}
+async function syncProviderChatsOnce() {
+	if (!providerChatsSyncPromise) providerChatsSyncPromise = syncProviderChats().finally(() => {
+		providerChatsSyncPromise = null;
+	});
+	return providerChatsSyncPromise;
+}
+async function syncProviderAccountChats(account) {
+	const stats = /* @__PURE__ */ new Map();
+	const adapter = getProviderAdapter(account.providerId);
+	let providerChats;
+	try {
+		providerChats = await adapter.listChats(account);
+	} catch {
+		return stats;
+	}
+	for (const providerChat of dedupeProviderChatList(providerChats)) {
+		const externalThreadId = providerChat.externalThreadId.trim();
+		if (!externalThreadId) continue;
+		if (providerChat.stats && (providerChat.stats.additions > 0 || providerChat.stats.deletions > 0)) stats.set(providerChatStatsKey(account.id, externalThreadId), providerChat.stats);
+		const existing = await prisma.chat.findFirst({ where: {
+			accountId: account.id,
+			externalThreadId,
+			providerId: account.providerId
+		} });
+		const timestamp = parseProviderDate(providerChat.updatedAt) ?? /* @__PURE__ */ new Date();
+		const title = normalizeTitle(providerChat.title) ?? "Untitled chat";
+		const workingDirectory = nullableString(providerChat.workingDirectory);
+		const data = {
+			title,
+			workingDirectory,
+			lastActivityAt: timestamp
+		};
+		if (existing) {
+			if (providerChat.status && existing.status !== "ARCHIVED") {
+				const hasActiveRun = await hasActiveProviderThreadRun(account, externalThreadId);
+				data.status = providerChat.status === "RUNNING" && !hasActiveRun && await hasRecentInterruptRequest(existing.id) ? "IDLE" : providerChat.status === "RUNNING" || hasActiveRun ? "RUNNING" : providerChat.status;
+			}
+			await prisma.chat.updateMany({
+				where: {
+					accountId: account.id,
+					externalThreadId,
+					providerId: account.providerId,
+					status: { not: "ARCHIVED" }
+				},
+				data
+			});
+			continue;
+		}
+		await prisma.chat.create({ data: {
+			title,
+			workingDirectory,
+			lastActivityAt: timestamp,
+			accountId: account.id,
+			providerId: account.providerId,
+			externalThreadId,
+			status: providerChat.status ?? "IDLE"
+		} });
+	}
+	return stats;
+}
+function dedupeChatList(chats) {
+	const visible = [];
+	const indexByKey = /* @__PURE__ */ new Map();
+	for (const chat of chats) {
+		const key = chatListDedupeKey(chat);
+		if (!key) {
+			visible.push(chat);
+			continue;
+		}
+		const existingIndex = indexByKey.get(key);
+		if (existingIndex === void 0) {
+			indexByKey.set(key, visible.length);
+			visible.push(chat);
+			continue;
+		}
+		const existing = visible[existingIndex];
+		if (preferChatListItem(chat, existing)) visible[existingIndex] = chat;
+	}
+	return visible;
+}
+function chatListDedupeKey(chat) {
+	return chat.externalThreadId && chat.accountId ? `${chat.providerId}:${chat.accountId}:${chat.externalThreadId}` : null;
+}
+function preferChatListItem(candidate, current) {
+	if (candidate.status !== current.status) return candidate.status === "RUNNING";
+	if (candidate.lastActivityAt.getTime() !== current.lastActivityAt.getTime()) return candidate.lastActivityAt.getTime() > current.lastActivityAt.getTime();
+	return candidate.updatedAt.getTime() > current.updatedAt.getTime();
+}
+function dedupeProviderChatList(chats) {
+	const visible = [];
+	const indexByThreadId = /* @__PURE__ */ new Map();
+	for (const chat of chats) {
+		const externalThreadId = chat.externalThreadId.trim();
+		if (!externalThreadId) continue;
+		const existingIndex = indexByThreadId.get(externalThreadId);
+		if (existingIndex === void 0) {
+			indexByThreadId.set(externalThreadId, visible.length);
+			visible.push(chat);
+			continue;
+		}
+		const existing = visible[existingIndex];
+		if (preferProviderChatListItem(chat, existing)) visible[existingIndex] = chat;
+	}
+	return visible;
+}
+function preferProviderChatListItem(candidate, current) {
+	if (candidate.status !== current.status) return candidate.status === "RUNNING";
+	return (parseProviderDate(candidate.updatedAt)?.getTime() ?? 0) > (parseProviderDate(current.updatedAt)?.getTime() ?? 0);
+}
+async function loadProviderMessages(chat) {
+	if (!chat.accountId || !chat.externalThreadId) return [];
+	const account = await requireConnectedAccount(chat.accountId).catch(() => null);
+	if (!account) return [];
+	return getProviderAdapter(chat.providerId).loadChatMessages(account, chat.externalThreadId).catch(() => []);
+}
+async function hasActiveProviderThreadRun(account, externalThreadId) {
+	const run = await prisma.chatRun.findFirst({
+		select: { id: true },
+		where: {
+			status: { in: ["QUEUED", "RUNNING"] },
+			chat: {
+				accountId: account.id,
+				externalThreadId,
+				providerId: account.providerId
+			}
+		}
+	});
+	return Boolean(run);
+}
+async function hasRecentInterruptRequest(chatId) {
+	const run = await prisma.chatRun.findFirst({
+		select: { id: true },
+		where: {
+			chatId,
+			interruptRequestedAt: { gte: /* @__PURE__ */ new Date(Date.now() - recentInterruptSuppressMs) },
+			status: "CANCELLED"
+		}
+	});
+	return Boolean(run);
+}
+async function hasActiveChatRun(chatId, providerStatus) {
+	const runs = await prisma.chatRun.findMany({
+		select: {
+			createdAt: true,
+			externalTurnId: true,
+			id: true,
+			startedAt: true
+		},
+		where: {
+			chatId,
+			status: { in: ["QUEUED", "RUNNING"] }
+		}
+	});
+	if (!runs.length) return false;
+	if (providerStatus && providerStatus !== "RUNNING") {
+		const now = Date.now();
+		const freshLocalRuns = runs.filter((run) => !run.externalTurnId && now - (run.startedAt ?? run.createdAt).getTime() < localRunGraceMs);
+		const staleRunIds = runs.filter((run) => !freshLocalRuns.some((freshRun) => freshRun.id === run.id)).map((run) => run.id);
+		if (staleRunIds.length) await prisma.chatRun.updateMany({
+			where: { id: { in: staleRunIds } },
+			data: {
+				endedAt: /* @__PURE__ */ new Date(),
+				status: "CANCELLED"
+			}
+		});
+		return freshLocalRuns.length > 0;
+	}
+	return true;
+}
+async function hasRunningChatRunExcept(chatId, excludedRunId) {
+	const run = await prisma.chatRun.findFirst({
+		select: { id: true },
+		where: {
+			chatId,
+			id: { not: excludedRunId },
+			status: "RUNNING"
+		}
+	});
+	return Boolean(run);
+}
+async function executeMessage(chatId, dto) {
+	const chat = await getChat(chatId);
+	if (!dto.content.trim()) throw new HttpError(400, "Message content is required.");
+	const accountId = dto.accountId ?? chat.accountId;
+	if (!accountId) throw new HttpError(400, "Choose a provider account before sending messages.");
+	const account = await requireConnectedAccount(accountId);
+	if (account.providerId !== chat.providerId) throw new HttpError(400, "Message account provider must match the chat provider.");
+	if (!chat.workingDirectory) throw new HttpError(400, "Select a working directory before sending messages.");
+	if (chat.status === "RUNNING") return dto.delivery === "steer" ? steerActiveMessage(chat, account, dto) : queueMessage(chat, account, dto);
+	const now = /* @__PURE__ */ new Date();
+	const run = await prisma.chatRun.create({ data: {
+		chatId: chat.id,
+		providerId: chat.providerId,
+		accountId: account.id,
+		status: "QUEUED",
+		request: runRequestFromDto(dto)
+	} });
+	const previewSequence = await nextMessageSequenceForChat(chat);
+	const userMessage = serializeRunMessage(chat.id, run, "USER", dto.content, "COMPLETED", previewSequence);
+	const assistantMessage = serializeRunMessage(chat.id, run, "ASSISTANT", "Running", "STREAMING", previewSequence + 1);
+	const runningChat = await prisma.chat.update({
+		where: { id: chat.id },
+		data: {
+			status: "RUNNING",
+			accountId: account.id,
+			collaborationMode: nullableString(dto.collaborationMode) ?? chat.collaborationMode,
+			lastActivityAt: now,
+			permissionMode: nullableString(dto.permissionMode) ?? chat.permissionMode
+		}
+	});
+	publishMessageCreated(chat.id, userMessage);
+	publishMessageCreated(chat.id, assistantMessage);
+	publishProviderEvent({
+		threadId: chat.id,
+		type: "chat.updated",
+		payload: serializeChat(runningChat)
+	});
+	publishProviderEvent({
+		threadId: chat.id,
+		type: "run.status",
+		payload: {
+			runId: run.id,
+			status: "QUEUED"
+		}
+	});
+	runProviderTurn({
+		accountId: account.id,
+		attachments: dto.attachments ?? [],
+		chatId: chat.id,
+		content: dto.content,
+		goalObjective: dto.goalObjective ?? null,
+		model: readRunMetadataString(dto.metadata, "model"),
+		permissionMode: dto.permissionMode ?? null,
+		reasoningEffort: readRunMetadataString(dto.metadata, "reasoningEffort"),
+		runId: run.id,
+		requestedCollaborationMode: dto.collaborationMode ?? null,
+		serviceTier: readRunMetadataString(dto.metadata, "serviceTier")
+	}).catch((error) => {
+		console.error("Provider run failed.", error);
+	});
+	return {
+		message: userMessage,
+		assistantMessage,
+		runId: run.id,
+		status: "QUEUED"
+	};
+}
+async function respondToServerRequest(chatId, requestId, dto) {
+	const chat = await getChat(chatId);
+	const accountId = chat.accountId;
+	if (!accountId) throw new HttpError(400, "Choose a provider account before responding.");
+	const account = await requireConnectedAccount(accountId);
+	if (account.providerId !== chat.providerId) throw new HttpError(400, "Response account provider must match the chat provider.");
+	const responder = getProviderAdapter(chat.providerId).respondToServerRequest;
+	if (!responder) throw new HttpError(400, "This provider does not support server request responses.");
+	if (dto.kind === "userInput" && isCodexFunctionCallRequestId(requestId)) throw new HttpError(409, "This input prompt came from saved Codex history, not a live request. Refresh the chat or send a new message to continue.");
+	if (dto.kind === "userInput" && !await hasActiveChatRun(chat.id)) throw new HttpError(409, "This input request is no longer active. Refresh the chat or send a new message to continue.");
+	await responder(account, requestId, dto);
+	return null;
+}
+async function queueMessage(chat, account, dto) {
+	const run = await prisma.chatRun.create({ data: {
+		chatId: chat.id,
+		providerId: chat.providerId,
+		accountId: account.id,
+		status: "QUEUED",
+		request: runRequestFromDto(dto)
+	} });
+	const message = serializeRunMessage(chat.id, run, "USER", dto.content, "PENDING", await nextMessageSequenceForChat(chat));
+	const updatedChat = await prisma.chat.update({
+		where: { id: chat.id },
+		data: {
+			accountId: account.id,
+			collaborationMode: nullableString(dto.collaborationMode) ?? chat.collaborationMode,
+			lastActivityAt: /* @__PURE__ */ new Date(),
+			permissionMode: nullableString(dto.permissionMode) ?? chat.permissionMode,
+			status: "RUNNING"
+		}
+	});
+	publishMessageCreated(chat.id, message);
+	publishProviderEvent({
+		threadId: chat.id,
+		type: "chat.updated",
+		payload: serializeChat(updatedChat)
+	});
+	publishProviderEvent({
+		threadId: chat.id,
+		type: "run.status",
+		payload: {
+			runId: run.id,
+			status: "QUEUED"
+		}
+	});
+	return {
+		message,
+		assistantMessage: null,
+		runId: run.id,
+		status: "QUEUED"
+	};
+}
+async function steerActiveMessage(chat, account, dto) {
+	const run = await prisma.chatRun.create({ data: {
+		chatId: chat.id,
+		providerId: chat.providerId,
+		accountId: account.id,
+		status: "QUEUED",
+		request: runRequestFromDto(dto)
+	} });
+	let result;
+	try {
+		result = await steerQueuedRun(chat, run);
+	} catch (error) {
+		await prisma.chatRun.update({
+			where: { id: run.id },
+			data: {
+				endedAt: /* @__PURE__ */ new Date(),
+				status: "CANCELLED"
+			}
+		}).catch(() => void 0);
+		throw error;
+	}
+	if (!result.message) throw new HttpError(409, "Unable to steer the active turn.");
+	return {
+		message: result.message,
+		assistantMessage: null,
+		runId: run.id,
+		status: "RUNNING"
+	};
+}
+async function interruptChatRun(chatId) {
+	const chat = await getChat(chatId);
+	const run = await prisma.chatRun.findFirst({
+		orderBy: { createdAt: "desc" },
+		where: {
+			chatId,
+			status: "RUNNING"
+		}
+	});
+	const accountId = run?.accountId ?? chat.accountId;
+	const account = accountId ? await requireConnectedAccount(accountId).catch(() => null) : null;
+	const adapter = getProviderAdapter(chat.providerId);
+	const providerRunning = (account && chat.externalThreadId && adapter.readChatStatus ? await adapter.readChatStatus(account, chat.externalThreadId).catch(() => null) : null) === "RUNNING";
+	if (chat.status !== "RUNNING" && !run && !providerRunning) throw new HttpError(409, "There is no running task to stop.");
+	if (!run) {
+		if (account && chat.externalThreadId && providerRunning) {
+			await adapter.interrupt(account, chat.externalThreadId, null).catch(() => void 0);
+			const interruptedAt = /* @__PURE__ */ new Date();
+			await prisma.chatRun.create({ data: {
+				accountId: account.id,
+				chatId,
+				endedAt: interruptedAt,
+				interruptRequestedAt: interruptedAt,
+				providerId: chat.providerId,
+				request: {},
+				startedAt: interruptedAt,
+				status: "CANCELLED"
+			} });
+		}
+		publishProviderEvent({
+			threadId: chatId,
+			type: "chat.updated",
+			payload: serializeChat(await prisma.chat.update({
+				where: { id: chatId },
+				data: { status: "IDLE" }
+			}))
+		});
+		await publishMessageDeltas(chatId);
+		return {
+			chatId,
+			runId: null,
+			status: "CANCELLED",
+			message: providerRunning ? "Provider task cancelled." : "Marked stale run as cancelled."
+		};
+	}
+	if (account && chat.externalThreadId) await getProviderAdapter(chat.providerId).interrupt(account, chat.externalThreadId, run.externalTurnId).catch(() => void 0);
+	await prisma.chatRun.update({
+		where: { id: run.id },
+		data: {
+			status: "CANCELLED",
+			endedAt: /* @__PURE__ */ new Date(),
+			interruptRequestedAt: /* @__PURE__ */ new Date()
+		}
+	});
+	publishProviderEvent({
+		threadId: chatId,
+		type: "chat.updated",
+		payload: serializeChat(await prisma.chat.update({
+			where: { id: chatId },
+			data: { status: "IDLE" }
+		}))
+	});
+	await publishMessageDeltas(chatId);
+	publishProviderEvent({
+		threadId: chatId,
+		type: "run.status",
+		payload: {
+			runId: run.id,
+			status: "CANCELLED"
+		}
+	});
+	return {
+		chatId,
+		runId: run.id,
+		status: "CANCELLED",
+		message: "Task cancelled."
+	};
+}
+async function updateQueuedChatRun(chatId, runId, dto) {
+	const content = dto.content.trim();
+	if (!content) throw new HttpError(400, "Message content is required.");
+	const run = await requireQueuedRun(chatId, runId);
+	const request = readRunRequestRecord(run);
+	const updatedRun = await prisma.chatRun.update({
+		where: { id: run.id },
+		data: { request: {
+			...request,
+			content
+		} }
+	});
+	const message = serializeRunMessage(chatId, updatedRun, "USER", content, "PENDING", knownMessageSequence(chatId, runMessageId(updatedRun, "USER")) ?? nextKnownMessageSequence(chatId));
+	publishMessageCreated(chatId, message);
+	await publishMessageDeltas(chatId);
+	return {
+		chatId,
+		runId,
+		status: "QUEUED",
+		message
+	};
+}
+async function reorderQueuedChatRuns(chatId, dto) {
+	await getChat(chatId);
+	const queuedRuns = sortQueuedRuns(await prisma.chatRun.findMany({
+		orderBy: { createdAt: "asc" },
+		where: {
+			chatId,
+			status: "QUEUED"
+		}
+	}));
+	const queuedRunIds = new Set(queuedRuns.map((run) => run.id));
+	const requestedRunIds = dto.runIds.filter((runId, index, runIds) => runIds.indexOf(runId) === index);
+	if (requestedRunIds.find((runId) => !queuedRunIds.has(runId))) throw new HttpError(404, "Queued message not found.");
+	const orderedIds = [...requestedRunIds, ...queuedRuns.map((run) => run.id).filter((runId) => !requestedRunIds.includes(runId))];
+	const runById = new Map(queuedRuns.map((run) => [run.id, run]));
+	await prisma.$transaction(orderedIds.map((orderedRunId, index) => {
+		const run = runById.get(orderedRunId);
+		if (!run) throw new HttpError(404, "Queued message not found.");
+		const request = readRunRequestRecord(run);
+		const metadata = readRunRequestMetadata(request.metadata);
+		return prisma.chatRun.update({
+			where: { id: orderedRunId },
+			data: { request: {
+				...request,
+				metadata: {
+					...metadata,
+					queueOrder: index + 1
+				}
+			} }
+		});
+	}));
+	await publishMessageDeltas(chatId);
+	return {
+		chatId,
+		runIds: orderedIds
+	};
+}
+async function deleteQueuedChatRun(chatId, runId) {
+	const run = await requireQueuedRun(chatId, runId);
+	await prisma.chatRun.update({
+		where: { id: run.id },
+		data: {
+			status: "CANCELLED",
+			endedAt: /* @__PURE__ */ new Date()
+		}
+	});
+	await publishMessageDeltas(chatId);
+	publishProviderEvent({
+		threadId: chatId,
+		type: "run.status",
+		payload: {
+			runId,
+			status: "CANCELLED"
+		}
+	});
+	return {
+		chatId,
+		runId,
+		status: "CANCELLED",
+		message: null
+	};
+}
+async function steerQueuedChatRun(chatId, runId) {
+	return steerQueuedRun(await getChat(chatId), await requireQueuedRun(chatId, runId));
+}
+async function requireProviderBackedChat(chatId, action) {
+	const chat = await getChat(chatId);
+	if (!chat.externalThreadId) throw new HttpError(400, `Start this chat before using ${action}.`);
+	if (!chat.accountId) throw new HttpError(400, `Choose a provider account before using ${action}.`);
+	const account = await requireConnectedAccount(chat.accountId);
+	if (account.providerId !== chat.providerId) throw new HttpError(400, "Chat provider must match the selected account provider.");
+	return {
+		account,
+		adapter: getProviderAdapter(chat.providerId),
+		chat,
+		externalThreadId: chat.externalThreadId
+	};
+}
+async function requireQueuedRun(chatId, runId) {
+	const run = await prisma.chatRun.findFirst({ where: {
+		chatId,
+		id: runId,
+		status: "QUEUED"
+	} });
+	if (!run) throw new HttpError(404, "Queued message not found.");
+	return run;
+}
+async function steerQueuedRun(chat, queuedRun) {
+	if (!chat.workingDirectory) throw new HttpError(400, "Select a working directory before steering messages.");
+	const activeRun = await prisma.chatRun.findFirst({
+		orderBy: { startedAt: "desc" },
+		where: {
+			chatId: chat.id,
+			status: "RUNNING",
+			externalTurnId: { not: null }
+		}
+	});
+	if (!activeRun?.externalTurnId || !chat.externalThreadId) throw new HttpError(409, "There is no steerable active turn yet.");
+	const accountId = activeRun.accountId ?? queuedRun.accountId ?? chat.accountId;
+	if (!accountId) throw new HttpError(400, "Choose a provider account before steering messages.");
+	const account = await requireConnectedAccount(accountId);
+	const adapter = getProviderAdapter(chat.providerId);
+	if (!adapter.steerMessage) throw new HttpError(400, "This provider does not support steering.");
+	const request = readRunRequest(queuedRun);
+	const content = request.content;
+	await adapter.steerMessage(account, {
+		attachments: request.attachments,
+		content,
+		threadId: chat.externalThreadId,
+		turnId: activeRun.externalTurnId,
+		workingDirectory: chat.workingDirectory
+	});
+	const completedAt = /* @__PURE__ */ new Date();
+	const updatedRun = await prisma.chatRun.update({
+		where: { id: queuedRun.id },
+		data: {
+			endedAt: completedAt,
+			externalTurnId: activeRun.externalTurnId,
+			startedAt: completedAt,
+			status: "COMPLETED"
+		}
+	});
+	const messageId = runMessageId(updatedRun, "USER");
+	const sequence = knownMessageSequence(chat.id, messageId) ?? await nextMessageSequenceForChat(chat);
+	const message = serializeRunMessage(chat.id, updatedRun, "USER", content, "COMPLETED", sequence);
+	publishMessageCreated(chat.id, message);
+	await publishMessageDeltas(chat.id);
+	publishProviderEvent({
+		threadId: chat.id,
+		type: "run.status",
+		payload: {
+			runId: queuedRun.id,
+			status: "COMPLETED"
+		}
+	});
+	return {
+		chatId: chat.id,
+		runId: queuedRun.id,
+		status: "COMPLETED",
+		message
+	};
+}
+async function runProviderTurn({ accountId, attachments, chatId, content, goalObjective, model, permissionMode, reasoningEffort, requestedCollaborationMode, runId, serviceTier }) {
+	const [chat, account] = await Promise.all([getChat(chatId), requireConnectedAccount(accountId)]);
+	const adapter = getProviderAdapter(chat.providerId);
+	const startedAt = /* @__PURE__ */ new Date();
+	await prisma.chatRun.update({
+		where: { id: runId },
+		data: {
+			status: "RUNNING",
+			startedAt
+		}
+	});
+	publishProviderEvent({
+		threadId: chatId,
+		type: "run.status",
+		payload: {
+			runId,
+			status: "RUNNING"
+		}
+	});
+	try {
+		const liveMessageSequences = /* @__PURE__ */ new Map();
+		let nextLiveMessageSequence = nextKnownMessageSequence(chatId);
+		const result = await adapter.sendMessage(account, {
+			attachments,
+			collaborationMode: requestedCollaborationMode ?? chat.collaborationMode,
+			content,
+			goalObjective,
+			model: model ?? chat.model,
+			onMessage: (message) => {
+				const key = message.itemId ?? `${message.role}:${message.kind ?? "CHAT"}:${message.content}`;
+				let sequence = liveMessageSequences.get(key);
+				if (!sequence) {
+					sequence = nextLiveMessageSequence;
+					nextLiveMessageSequence += 1;
+					liveMessageSequences.set(key, sequence);
+				}
+				publishMessageCreated(chatId, serializeProviderMessage(chatId, {
+					...message,
+					runId
+				}, sequence));
+			},
+			onThreadReady: async (threadId) => {
+				publishProviderEvent({
+					threadId: chatId,
+					type: "chat.updated",
+					payload: serializeChat(await prisma.chat.update({
+						where: { id: chatId },
+						data: {
+							externalThreadId: threadId,
+							status: "RUNNING"
+						}
+					}))
+				});
+			},
+			onTurnStarted: async (turnId) => {
+				await prisma.chatRun.update({
+					where: { id: runId },
+					data: { externalTurnId: turnId }
+				});
+				publishProviderEvent({
+					threadId: chatId,
+					type: "run.status",
+					payload: {
+						runId,
+						status: "RUNNING",
+						turnId
+					}
+				});
+			},
+			permissionMode: permissionMode ?? chat.permissionMode,
+			reasoningEffort: reasoningEffort ?? chat.reasoningEffort,
+			serviceTier: serviceTier ?? chat.serviceTier,
+			threadId: chat.externalThreadId,
+			workingDirectory: chat.workingDirectory
+		});
+		const completedAt = /* @__PURE__ */ new Date();
+		const currentRun = await prisma.chatRun.findUnique({
+			where: { id: runId },
+			select: { status: true }
+		});
+		if (!currentRun || currentRun.status !== "RUNNING") {
+			const hasOtherRunningRun = await hasRunningChatRunExcept(chatId, runId);
+			const updatedChat = await prisma.chat.update({
+				where: { id: chatId },
+				data: {
+					externalThreadId: result.threadId,
+					lastActivityAt: completedAt,
+					status: hasOtherRunningRun ? "RUNNING" : "IDLE"
+				}
+			});
+			await adapter.syncThreadFromAccount(result.threadId, account);
+			publishProviderEvent({
+				threadId: chatId,
+				type: "chat.updated",
+				payload: serializeChat(updatedChat)
+			});
+			await publishMessageDeltas(chatId);
+			if (!hasOtherRunningRun) await startNextQueuedRun(chatId);
+			return;
+		}
+		const updatedChat = await prisma.chat.update({
+			where: { id: chatId },
+			data: {
+				externalThreadId: result.threadId,
+				lastActivityAt: completedAt,
+				status: "IDLE"
+			}
+		});
+		await prisma.chatRun.update({
+			where: { id: runId },
+			data: {
+				endedAt: completedAt,
+				externalTurnId: result.turnId,
+				status: "COMPLETED"
+			}
+		});
+		await adapter.syncThreadFromAccount(result.threadId, account);
+		publishProviderEvent({
+			threadId: chatId,
+			type: "chat.updated",
+			payload: serializeChat(updatedChat)
+		});
+		await publishMessageDeltas(chatId);
+		publishProviderEvent({
+			threadId: chatId,
+			type: "run.status",
+			payload: {
+				runId,
+				status: "COMPLETED"
+			}
+		});
+		await startNextQueuedRun(chatId);
+	} catch (error) {
+		const currentRun = await prisma.chatRun.findUnique({
+			where: { id: runId },
+			select: { status: true }
+		});
+		if (!currentRun || currentRun.status !== "RUNNING") {
+			const hasOtherRunningRun = await hasRunningChatRunExcept(chatId, runId);
+			if (!hasOtherRunningRun) {
+				const settledAt = /* @__PURE__ */ new Date();
+				publishProviderEvent({
+					threadId: chatId,
+					type: "chat.updated",
+					payload: serializeChat(await prisma.chat.update({
+						where: { id: chatId },
+						data: {
+							status: "IDLE",
+							lastActivityAt: settledAt
+						}
+					}))
+				});
+			}
+			await publishMessageDeltas(chatId);
+			if (!hasOtherRunningRun) await startNextQueuedRun(chatId);
+			return;
+		}
+		const message = error instanceof Error ? error.message : "Provider run failed.";
+		const failedAt = /* @__PURE__ */ new Date();
+		const updatedChat = await prisma.chat.update({
+			where: { id: chatId },
+			data: {
+				status: "IDLE",
+				lastActivityAt: failedAt
+			}
+		});
+		await prisma.chatRun.update({
+			where: { id: runId },
+			data: {
+				endedAt: failedAt,
+				error: message,
+				status: "FAILED"
+			}
+		});
+		publishProviderEvent({
+			threadId: chatId,
+			type: "chat.updated",
+			payload: serializeChat(updatedChat)
+		});
+		await publishMessageDeltas(chatId);
+		publishProviderEvent({
+			threadId: chatId,
+			type: "run.status",
+			payload: {
+				runId,
+				status: "FAILED",
+				error: message
+			}
+		});
+		await startNextQueuedRun(chatId);
+	}
+}
+async function startNextQueuedRun(chatId) {
+	if (await hasRunningChatRunExcept(chatId, "")) return false;
+	const queuedRun = sortQueuedRuns(await prisma.chatRun.findMany({
+		orderBy: { createdAt: "asc" },
+		where: {
+			chatId,
+			status: "QUEUED"
+		}
+	}))[0];
+	if (!queuedRun) return false;
+	const chat = await getChat(chatId);
+	const accountId = queuedRun.accountId ?? chat.accountId;
+	if (!accountId) {
+		await prisma.chatRun.update({
+			where: { id: queuedRun.id },
+			data: {
+				endedAt: /* @__PURE__ */ new Date(),
+				error: "Queued message has no provider account.",
+				status: "FAILED"
+			}
+		});
+		await publishMessageDeltas(chatId);
+		return startNextQueuedRun(chatId);
+	}
+	const request = readRunRequest(queuedRun);
+	publishProviderEvent({
+		threadId: chatId,
+		type: "chat.updated",
+		payload: serializeChat(await prisma.chat.update({
+			where: { id: chatId },
+			data: {
+				accountId,
+				collaborationMode: nullableString(request.collaborationMode) ?? chat.collaborationMode,
+				lastActivityAt: /* @__PURE__ */ new Date(),
+				permissionMode: nullableString(request.permissionMode) ?? chat.permissionMode,
+				status: "RUNNING"
+			}
+		}))
+	});
+	runProviderTurn({
+		accountId,
+		attachments: request.attachments,
+		chatId,
+		content: request.content,
+		goalObjective: request.goalObjective,
+		model: readRunMetadataString(request.metadata, "model"),
+		permissionMode: request.permissionMode,
+		reasoningEffort: readRunMetadataString(request.metadata, "reasoningEffort"),
+		requestedCollaborationMode: request.collaborationMode,
+		runId: queuedRun.id,
+		serviceTier: readRunMetadataString(request.metadata, "serviceTier")
+	}).catch((error) => {
+		console.error("Queued provider run failed.", error);
+	});
+	return true;
+}
+async function readRunPreviewMessages(chat, providerMessages) {
+	const runs = await prisma.chatRun.findMany({
+		orderBy: { createdAt: "asc" },
+		where: {
+			chatId: chat.id,
+			status: { in: [
+				"QUEUED",
+				"RUNNING",
+				"FAILED"
+			] }
+		}
+	});
+	const messages = [];
+	for (const run of sortRunPreviewRuns(runs)) {
+		const content = readRunRequestContent(run);
+		if (!content) continue;
+		const runUserIndex = findLastIndex(providerMessages, (message) => message.role === "USER" && message.content.trim() === content.trim());
+		const assistantAfterRunUser = runUserIndex >= 0 ? providerMessages.slice(runUserIndex + 1).some((message) => message.role === "ASSISTANT") : false;
+		if (runUserIndex < 0) messages.push({
+			id: `run:${run.id}:user`,
+			runId: run.id,
+			role: "USER",
+			content,
+			createdAt: run.createdAt.toISOString(),
+			status: run.status === "QUEUED" ? "PENDING" : "COMPLETED"
+		});
+		if (run.status !== "QUEUED" && !assistantAfterRunUser) {
+			const failed = run.status === "FAILED";
+			const timestamp = (run.endedAt ?? run.startedAt ?? run.createdAt).toISOString();
+			messages.push({
+				id: `run:${run.id}:assistant`,
+				runId: run.id,
+				role: "ASSISTANT",
+				content: failed ? run.error ?? "Provider run failed." : "Running",
+				createdAt: timestamp,
+				completedAt: failed ? timestamp : null,
+				kind: failed ? "ERROR" : "CHAT",
+				status: failed ? "FAILED" : "STREAMING"
+			});
+		}
+	}
+	return messages;
+}
+function readRunRequestContent(run) {
+	return readRunRequest(run).content || null;
+}
+function sortQueuedRuns(runs) {
+	return [...runs].sort(compareQueuedRuns);
+}
+function sortRunPreviewRuns(runs) {
+	return [...runs].sort((left, right) => {
+		if (left.status === "QUEUED" && right.status === "QUEUED") return compareQueuedRuns(left, right);
+		if (left.status === "QUEUED" || right.status === "QUEUED") return left.status === "QUEUED" ? 1 : -1;
+		return left.createdAt.getTime() - right.createdAt.getTime();
+	});
+}
+function compareQueuedRuns(left, right) {
+	const leftOrder = readQueuedRunOrder(left);
+	const rightOrder = readQueuedRunOrder(right);
+	if (leftOrder !== rightOrder) return leftOrder - rightOrder;
+	return left.createdAt.getTime() - right.createdAt.getTime();
+}
+function readQueuedRunOrder(run) {
+	const order = readRunRequestMetadata(readRunRequestRecord(run).metadata).queueOrder;
+	return typeof order === "number" && Number.isFinite(order) ? order : run.createdAt.getTime();
+}
+function runRequestFromDto(dto) {
+	return {
+		attachments: runRequestAttachments(dto.attachments),
+		collaborationMode: dto.collaborationMode ?? null,
+		content: dto.content,
+		goalObjective: dto.goalObjective ?? null,
+		metadata: dto.metadata ?? {},
+		permissionMode: dto.permissionMode ?? null
+	};
+}
+function runRequestAttachments(attachments) {
+	return (attachments ?? []).map((attachment) => ({
+		...attachment.dataUrl ? { dataUrl: attachment.dataUrl } : {},
+		kind: attachment.kind,
+		...attachment.mimeType ? { mimeType: attachment.mimeType } : {},
+		name: attachment.name,
+		...attachment.path ? { path: attachment.path } : {},
+		...attachment.size !== void 0 ? { size: attachment.size } : {}
+	}));
+}
+function readRunRequestRecord(run) {
+	return run.request && typeof run.request === "object" && !Array.isArray(run.request) ? run.request : {};
+}
+function readRunRequest(run) {
+	const request = readRunRequestRecord(run);
+	return {
+		attachments: readRunRequestAttachments(request.attachments),
+		collaborationMode: readRequestString(request.collaborationMode),
+		content: readRequestString(request.content) ?? "",
+		goalObjective: readRequestString(request.goalObjective),
+		metadata: readRunRequestMetadata(request.metadata),
+		permissionMode: readRequestString(request.permissionMode)
+	};
+}
+function readRunRequestMetadata(value) {
+	return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function readRunMetadataString(value, key) {
+	const field = readRunRequestMetadata(value)[key];
+	return typeof field === "string" && field.trim() ? field.trim() : null;
+}
+function readRunRequestAttachments(value) {
+	if (!Array.isArray(value)) return [];
+	const attachments = [];
+	for (const entry of value) {
+		if (!entry || typeof entry !== "object" || Array.isArray(entry)) continue;
+		const record = entry;
+		const kind = record.kind;
+		if (kind !== "file" && kind !== "folder" && kind !== "image") continue;
+		attachments.push({
+			dataUrl: readRequestString(record.dataUrl) ?? void 0,
+			kind,
+			mimeType: readRequestString(record.mimeType) ?? void 0,
+			name: readRequestString(record.name) ?? "attachment",
+			path: readRequestString(record.path) ?? void 0,
+			size: typeof record.size === "number" && Number.isFinite(record.size) ? record.size : void 0
+		});
+	}
+	return attachments;
+}
+function readRequestString(value) {
+	return typeof value === "string" && value.trim() ? value.trim() : null;
+}
+function findLastIndex(items, predicate) {
+	for (let index = items.length - 1; index >= 0; index -= 1) if (predicate(items[index])) return index;
+	return -1;
+}
+function serializeRunMessage(chatId, run, role, content, status, sequence) {
+	return serializeProviderMessage(chatId, {
+		id: runMessageId(run, role),
+		runId: run.id,
+		role,
+		content,
+		createdAt: run.createdAt.toISOString(),
+		completedAt: status === "COMPLETED" ? run.createdAt.toISOString() : null,
+		status
+	}, sequence);
+}
+function runMessageId(run, role) {
+	return `run:${run.id}:${role.toLowerCase()}`;
+}
+function isCodexFunctionCallRequestId(requestId) {
+	return /^call_[A-Za-z0-9_-]+$/u.test(requestId);
+}
+function serializeChat(chat, stats) {
+	return {
+		id: chat.id,
+		providerId: chat.providerId,
+		accountId: chat.accountId,
+		autoRotateAccount: chat.autoRotateAccount,
+		title: chat.title,
+		workingDirectory: chat.workingDirectory,
+		model: chat.model,
+		reasoningEffort: chat.reasoningEffort,
+		serviceTier: chat.serviceTier,
+		stats: stats ?? null,
+		collaborationMode: chat.collaborationMode,
+		permissionMode: chat.permissionMode,
+		status: chat.status,
+		externalThreadId: chat.externalThreadId,
+		lastActivityAt: chat.lastActivityAt.toISOString(),
+		createdAt: chat.createdAt.toISOString(),
+		updatedAt: chat.updatedAt.toISOString()
+	};
+}
+function providerChatStatsKey(accountId, externalThreadId) {
+	return `${accountId}:${externalThreadId}`;
+}
+function serializeProviderMessage(chatId, message, sequence) {
+	const createdAt = parseProviderDate(message.createdAt) ?? /* @__PURE__ */ new Date();
+	const status = message.status ?? "COMPLETED";
+	return {
+		id: message.id ?? `provider:${chatId}:${message.itemId ?? sequence}`,
+		chatId,
+		runId: message.runId,
+		sequence,
+		role: message.role,
+		kind: message.kind ?? "CHAT",
+		status,
+		turnId: message.turnId ?? null,
+		itemId: message.itemId,
+		requestId: message.requestId ?? null,
+		content: message.content,
+		metadata: message.metadata ?? null,
+		rawPayload: message.rawPayload ?? null,
+		createdAt: createdAt.toISOString(),
+		completedAt: message.completedAt ?? (status === "COMPLETED" || status === "FAILED" ? createdAt.toISOString() : null)
+	};
+}
+function nullableString(value) {
+	if (value === void 0) return;
+	return value?.trim() || null;
+}
+function normalizeTitle(value) {
+	return value?.trim() || null;
+}
+function parseProviderDate(value) {
+	if (!value) return null;
+	const date = new Date(value);
+	return Number.isNaN(date.getTime()) ? null : date;
+}
+function readErrorMessage(error) {
+	return error instanceof Error ? error.message : String(error ?? "Unknown error");
+}
+//#endregion
+export { listProviderAdapters as A, readNumber as B, createAccount as C, readConnectedAccountLimits as D, listAccounts as E, resolveCodexAccountHome as F, ensureDatabase as H, startCodexMcpOauthLogin as I, updateCodexInstructions as L, readCodexHistoryWatchPaths as M, readCodexInstructions as N, requireConnectedAccount as O, reloadCodexMcpServerConfig as P, asJsonObject as R, authenticateAccount as S, listAccountModels as T, prisma as U, readString as V, serializeChat as _, executeMessage as a, updateChat as b, interruptChatRun as c, publishMessageDeltas as d, refreshChat as f, reviewChat as g, respondToServerRequest as h, deleteQueuedChatRun as i, listCodexMcpServerStatuses as j, updateAccount as k, listChats as l, reorderQueuedChatRuns as m, compactChat as n, forkChat as o, refreshChatStatusesForWorkspaces as p, createChat as r, getChat as s, archiveChat as t, listMessages as u, steerQueuedChatRun as v, deleteAccount as w, updateQueuedChatRun as x, syncProviderChatsOnce as y, readBoolean as z };