codex-mobile-re 0.1.120 → 0.1.121

package/dist-cli/index.js

@@ -3,9 +3,9 @@
 // src/cli/index.ts
 import { createServer as createServer2 } from "http";
 import { chmodSync as chmodSync2, createWriteStream, existsSync as existsSync14, mkdirSync as mkdirSync2 } from "fs";
-import { readFile as readFile19, stat as stat18, writeFile as writeFile18 } from "fs/promises";
+import { readFile as readFile19, stat as stat19, writeFile as writeFile19 } from "fs/promises";
 import { homedir as homedir11, networkInterfaces } from "os";
-import { isAbsolute as isAbsolute13, join as join31, resolve as resolve8 } from "path";
+import { isAbsolute as isAbsolute13, join as join32, resolve as resolve8 } from "path";
 import { spawn as spawn9 } from "child_process";
 import { createInterface as createInterface2 } from "readline/promises";
 import { fileURLToPath as fileURLToPath2 } from "url";
@@ -341,16 +341,16 @@ function parseApprovalPolicy(value) {
 
 // src/server/httpServer.ts
 import { fileURLToPath } from "url";
-import { dirname as dirname12, extname as extname5, isAbsolute as isAbsolute12, join as join30 } from "path";
+import { dirname as dirname12, extname as extname5, isAbsolute as isAbsolute12, join as join31 } from "path";
 import { existsSync as existsSync13 } from "fs";
-import { writeFile as writeFile17, stat as stat17 } from "fs/promises";
+import { writeFile as writeFile18, stat as stat18 } from "fs/promises";
 import express from "express";
 
 // src/server/codexAppServerBridge.ts
 import { spawn as spawn8 } from "child_process";
 import { mkdtemp as mkdtemp4, readFile as readFile18 } from "fs/promises";
-import { tmpdir as tmpdir6 } from "os";
-import { isAbsolute as isAbsolute11, join as join28 } from "path";
+import { tmpdir as tmpdir7 } from "os";
+import { isAbsolute as isAbsolute11, join as join29 } from "path";
 
 // src/server/accountRoutes.ts
 import { spawn as spawn2 } from "child_process";
@@ -9920,7 +9920,7 @@ async function handleProjectHttpRequest(req, res, url, deps) {
 
 // src/server/bridge/threadRoutes.ts
 import { isAbsolute as isAbsolute5 } from "path";
-import { readFile as readFile10, stat as stat10 } from "fs/promises";
+import { readFile as readFile10, stat as stat11 } from "fs/promises";
 
 // src/server/bridge/session.ts
 import { mkdir as mkdir8, readFile as readFile9, rename as rename2, rm as rm6, stat as stat9, writeFile as writeFile8 } from "fs/promises";
@@ -10899,6 +10899,122 @@ async function mergeSessionCommandsIntoThreadResult(result) {
   }
 }
 
+// src/server/bridge/payloadSlimming.ts
+import { createHash as createHash2 } from "crypto";
+import { mkdir as mkdir9, stat as stat10, writeFile as writeFile9 } from "fs/promises";
+import { tmpdir as tmpdir5 } from "os";
+import { join as join19 } from "path";
+var COMMAND_OUTPUT_INLINE_LIMIT_BYTES = 16 * 1024;
+var COMMAND_OUTPUT_SPILL_MAX_BYTES = 8 * 1024 * 1024;
+var COMMAND_OUTPUT_SPILL_DIR_NAME = "codex-web-command-output";
+var SPILL_REF_PATTERN = /^[0-9a-f]{40}$/u;
+var HEAD_BYTES_RATIO = 0.6;
+function getCommandOutputSpillDir() {
+  return join19(tmpdir5(), COMMAND_OUTPUT_SPILL_DIR_NAME);
+}
+function resolveCommandOutputSpillPath(ref) {
+  const normalized = ref.trim().toLowerCase();
+  if (!SPILL_REF_PATTERN.test(normalized)) return null;
+  return join19(getCommandOutputSpillDir(), `${normalized}.txt`);
+}
+function truncateUtf8Middle(text, limitBytes) {
+  const buffer = Buffer.from(text, "utf8");
+  const headBytes = Math.floor(limitBytes * HEAD_BYTES_RATIO);
+  const tailBytes = Math.max(0, limitBytes - headBytes);
+  const head = buffer.subarray(0, headBytes).toString("utf8").replace(/\uFFFD+$/u, "");
+  const tail = buffer.subarray(Math.max(0, buffer.length - tailBytes)).toString("utf8").replace(/^\uFFFD+/u, "");
+  const keptBytes = Buffer.byteLength(head, "utf8") + Buffer.byteLength(tail, "utf8");
+  return {
+    text: `${head}
+\u2026
+${tail}`,
+    omittedBytes: Math.max(0, buffer.length - keptBytes)
+  };
+}
+async function spillCommandOutputToDisk(text) {
+  try {
+    const ref = createHash2("sha1").update(text, "utf8").digest("hex");
+    const spillDir = getCommandOutputSpillDir();
+    await mkdir9(spillDir, { recursive: true });
+    const filePath = join19(spillDir, `${ref}.txt`);
+    try {
+      await stat10(filePath);
+    } catch {
+      await writeFile9(filePath, text, "utf8");
+    }
+    return ref;
+  } catch {
+    return "";
+  }
+}
+function slimMcpToolCallItem(item) {
+  if (!("result" in item)) return null;
+  const next = { ...item };
+  delete next.result;
+  return next;
+}
+async function slimCommandExecutionItem(item) {
+  const output = item.aggregatedOutput;
+  if (typeof output !== "string" || output.length === 0) return null;
+  const totalBytes = Buffer.byteLength(output, "utf8");
+  if (totalBytes <= COMMAND_OUTPUT_INLINE_LIMIT_BYTES) return null;
+  const { text, omittedBytes } = truncateUtf8Middle(output, COMMAND_OUTPUT_INLINE_LIMIT_BYTES);
+  const ref = totalBytes <= COMMAND_OUTPUT_SPILL_MAX_BYTES ? await spillCommandOutputToDisk(output) : "";
+  return {
+    ...item,
+    aggregatedOutput: text,
+    aggregatedOutputSpill: { ref, totalBytes, omittedBytes }
+  };
+}
+async function slimThreadTurnsPayload(method, result) {
+  if (!THREAD_METHODS_WITH_TURNS.has(method)) return result;
+  const record = asRecord2(result);
+  const thread = asRecord2(record?.thread);
+  const turns = Array.isArray(thread?.turns) ? thread.turns : null;
+  if (!record || !thread || !turns || turns.length === 0) return result;
+  let changed = false;
+  const nextTurns = [];
+  for (const turn of turns) {
+    const turnRecord = asRecord2(turn);
+    const items = Array.isArray(turnRecord?.items) ? turnRecord.items : null;
+    if (!turnRecord || !items) {
+      nextTurns.push(turn);
+      continue;
+    }
+    let itemChanged = false;
+    const nextItems = [];
+    for (const item of items) {
+      const itemRecord = asRecord2(item);
+      if (!itemRecord) {
+        nextItems.push(item);
+        continue;
+      }
+      const itemType = itemRecord.type;
+      const slimmedItem = itemType === "mcpToolCall" ? slimMcpToolCallItem(itemRecord) : itemType === "commandExecution" ? await slimCommandExecutionItem(itemRecord) : null;
+      if (!slimmedItem) {
+        nextItems.push(item);
+        continue;
+      }
+      itemChanged = true;
+      nextItems.push(slimmedItem);
+    }
+    if (!itemChanged) {
+      nextTurns.push(turn);
+      continue;
+    }
+    changed = true;
+    nextTurns.push({ ...turnRecord, items: nextItems });
+  }
+  if (!changed) return result;
+  return {
+    ...record,
+    thread: {
+      ...thread,
+      turns: nextTurns
+    }
+  };
+}
+
 // src/server/bridge/threadRoutes.ts
 function readStreamTurnId(params) {
   const directTurnId = readNonEmptyString(params.turnId) || readNonEmptyString(params.turn_id);
@@ -11085,7 +11201,7 @@ function handleThreadHttpRequest(req, res, url, deps) {
         let sessionSize = 0;
         if (sessionPath && isAbsolute5(sessionPath)) {
           try {
-            const s = await stat10(sessionPath);
+            const s = await stat11(sessionPath);
             sessionSize = s.size;
           } catch {
           }
@@ -11163,6 +11279,22 @@ function handleThreadHttpRequest(req, res, url, deps) {
       return true;
     })();
   }
+  if (req.method === "GET" && url.pathname === "/codex-api/command-output") {
+    return (async () => {
+      const ref = url.searchParams.get("ref")?.trim() ?? "";
+      const spillPath = resolveCommandOutputSpillPath(ref);
+      if (!spillPath) {
+        setJson2(res, 400, { error: "Invalid command output reference." });
+        return true;
+      }
+      try {
+        setJson2(res, 200, { text: await readFile10(spillPath, "utf8") });
+      } catch {
+        setJson2(res, 404, { error: "Command output is no longer available." });
+      }
+      return true;
+    })();
+  }
   return Promise.resolve(false);
 }
 
@@ -11273,8 +11405,8 @@ async function runRpcResponsePipeline(deps, method, rpcResult) {
 }
 
 // src/server/bridge/telegramRoutes.ts
-import { join as join19 } from "path";
-import { readFile as readFile11, writeFile as writeFile9 } from "fs/promises";
+import { join as join20 } from "path";
+import { readFile as readFile11, writeFile as writeFile10 } from "fs/promises";
 function normalizeTelegramBridgeConfig(value) {
   const record = asRecord2(value);
   if (!record) return { botToken: "", chatIds: [], allowedUserIds: [] };
@@ -11297,7 +11429,7 @@ function normalizeTelegramBridgeConfig(value) {
   return { botToken, chatIds, allowedUserIds };
 }
 function getTelegramBridgeConfigPath() {
-  return join19(getCodexHomeDir2(), "telegram-bridge.json");
+  return join20(getCodexHomeDir2(), "telegram-bridge.json");
 }
 async function readTelegramBridgeConfig() {
   const telegramConfigPath = getTelegramBridgeConfigPath();
@@ -11312,7 +11444,7 @@ async function readTelegramBridgeConfig() {
 async function writeTelegramBridgeConfig(nextState) {
   const normalized = normalizeTelegramBridgeConfig(nextState);
   const telegramConfigPath = getTelegramBridgeConfigPath();
-  await writeFile9(telegramConfigPath, JSON.stringify({
+  await writeFile10(telegramConfigPath, JSON.stringify({
     botToken: normalized.botToken,
     chatIds: normalized.chatIds,
     allowedUserIds: normalized.allowedUserIds
@@ -11367,8 +11499,8 @@ async function handleTelegramHttpRequest(req, res, url, deps) {
 
 // src/server/bridge/threadPreferencesRoutes.ts
 import { createReadStream as createReadStream3 } from "fs";
-import { readFile as readFile12, stat as stat11, writeFile as writeFile10 } from "fs/promises";
-import { join as join20 } from "path";
+import { readFile as readFile12, stat as stat12, writeFile as writeFile11 } from "fs/promises";
+import { join as join21 } from "path";
 import { createInterface } from "readline";
 var MAX_THREAD_TITLES = 500;
 var MAX_REASONING_MESSAGES_PER_THREAD = 20;
@@ -11383,7 +11515,7 @@ var sessionIndexThreadTitleCacheState = {
   cache: EMPTY_THREAD_TITLE_CACHE
 };
 function getCodexSessionIndexPath() {
-  return join20(getCodexHomeDir2(), "session_index.jsonl");
+  return join21(getCodexHomeDir2(), "session_index.jsonl");
 }
 function normalizeThreadTitleCache(value) {
   const record = asRecord2(value);
@@ -11486,7 +11618,7 @@ async function writeThreadTitleCache(cache) {
     payload = {};
   }
   payload["thread-titles"] = cache;
-  await writeFile10(statePath, JSON.stringify(payload), "utf8");
+  await writeFile11(statePath, JSON.stringify(payload), "utf8");
 }
 async function readPinnedThreadIds() {
   const statePath = getCodexGlobalStatePath();
@@ -11508,7 +11640,7 @@ async function writePinnedThreadIds(threadIds) {
     payload = {};
   }
   payload[PINNED_THREAD_IDS_KEY] = normalizePinnedThreadIds(threadIds);
-  await writeFile10(statePath, JSON.stringify(payload), "utf8");
+  await writeFile11(statePath, JSON.stringify(payload), "utf8");
 }
 async function readThreadReasoningArchive() {
   const statePath = getCodexGlobalStatePath();
@@ -11535,7 +11667,7 @@ async function writeThreadReasoningArchive(archive) {
   } else {
     delete payload[THREAD_REASONING_KEY];
   }
-  await writeFile10(statePath, JSON.stringify(payload), "utf8");
+  await writeFile11(statePath, JSON.stringify(payload), "utf8");
 }
 async function mergeThreadReasoningArchive(threadId, messages) {
   const archive = await readThreadReasoningArchive();
@@ -11592,7 +11724,7 @@ async function writeThreadTurnDurations(next) {
   } else {
     delete payload[THREAD_TURN_DURATIONS_KEY];
   }
-  await writeFile10(statePath, JSON.stringify(payload), "utf8");
+  await writeFile11(statePath, JSON.stringify(payload), "utf8");
 }
 async function mergeThreadTurnDuration(threadId, turnId, durationMs) {
   const store = await readThreadTurnDurations();
@@ -11636,7 +11768,7 @@ async function writeFirstLaunchPluginsCardDismissed(dismissed) {
     payload = {};
   }
   payload[FIRST_LAUNCH_PLUGINS_CARD_DISMISSED_KEY] = dismissed === true;
-  await writeFile10(statePath, JSON.stringify(payload), "utf8");
+  await writeFile11(statePath, JSON.stringify(payload), "utf8");
 }
 function getSessionIndexFileSignature(stats) {
   return `${String(stats.mtimeMs)}:${String(stats.size)}`;
@@ -11678,7 +11810,7 @@ async function parseThreadTitlesFromSessionIndex(sessionIndexPath) {
 async function readThreadTitlesFromSessionIndex() {
   const sessionIndexPath = getCodexSessionIndexPath();
   try {
-    const stats = await stat11(sessionIndexPath);
+    const stats = await stat12(sessionIndexPath);
     const fileSignature = getSessionIndexFileSignature(stats);
     if (sessionIndexThreadTitleCacheState.fileSignature === fileSignature) {
       return sessionIndexThreadTitleCacheState.cache;
@@ -11859,14 +11991,14 @@ data: ${JSON.stringify({ ok: true })}
 // src/server/bridge/projectZip.ts
 import { randomUUID as randomUUID2 } from "crypto";
 import { existsSync as existsSync8 } from "fs";
-import { mkdir as mkdir9, readFile as readFile14, realpath as realpath3, utimes, writeFile as writeFile12 } from "fs/promises";
-import { basename as basename7, dirname as dirname6, extname as extname3, isAbsolute as isAbsolute7, join as join22, relative as relative3, resolve as resolve4, sep as sep3 } from "path";
+import { mkdir as mkdir10, readFile as readFile14, realpath as realpath3, utimes, writeFile as writeFile13 } from "fs/promises";
+import { basename as basename7, dirname as dirname6, extname as extname3, isAbsolute as isAbsolute7, join as join23, relative as relative3, resolve as resolve4, sep as sep3 } from "path";
 
 // src/server/bridge/importedSessions.ts
 import { spawnSync as spawnSync4 } from "child_process";
 import { existsSync as existsSync7 } from "fs";
 import { readdir as readdir8 } from "fs/promises";
-import { join as join21 } from "path";
+import { join as join22 } from "path";
 async function* walkFiles(root, current = root) {
   let entries;
   try {
@@ -11875,7 +12007,7 @@ async function* walkFiles(root, current = root) {
     return;
   }
   for (const entry of entries) {
-    const absolutePath = join21(current, entry.name);
+    const absolutePath = join22(current, entry.name);
     if (entry.isDirectory()) {
       yield* walkFiles(root, absolutePath);
     } else if (entry.isFile()) {
@@ -11908,7 +12040,7 @@ function readSessionMetaId(raw) {
   }
 }
 function getCurrentImportedSessionModelDefaults() {
-  const fmState = ensureDefaultFreeModeStateForMissingAuthSync(join21(getCodexHomeDir2(), FREE_MODE_STATE_FILE));
+  const fmState = ensureDefaultFreeModeStateForMissingAuthSync(join22(getCodexHomeDir2(), FREE_MODE_STATE_FILE));
   if (!fmState?.enabled) return null;
   if (fmState.provider === "opencode-zen") {
     return {
@@ -12038,7 +12170,7 @@ function sqlString(value) {
   return `'${value.replace(/'/g, "''")}'`;
 }
 function sqliteStateDbPath() {
-  return join21(getCodexHomeDir2(), "state_5.sqlite");
+  return join22(getCodexHomeDir2(), "state_5.sqlite");
 }
 function ensureImportedThreadsStateDbTable(stateDbPath) {
   const sql = `
@@ -12247,7 +12379,7 @@ function mergeImportedThreadsIntoThreadListResult(result) {
 }
 
 // src/server/bridge/workspaceRoots.ts
-import { readFile as readFile13, realpath as realpath2, rm as rm7, writeFile as writeFile11 } from "fs/promises";
+import { readFile as readFile13, realpath as realpath2, rm as rm7, writeFile as writeFile12 } from "fs/promises";
 import { isAbsolute as isAbsolute6 } from "path";
 function normalizeRemoteProjects(value) {
   if (!Array.isArray(value)) return [];
@@ -12370,7 +12502,7 @@ async function writeWorkspaceRootsState(nextState) {
   payload["electron-workspace-root-labels"] = normalizeStringRecord(state.labels);
   payload["active-workspace-roots"] = normalizeStringArray(state.active);
   payload["project-order"] = normalizeStringArray(state.projectOrder);
-  await writeFile11(statePath, JSON.stringify(payload), "utf8");
+  await writeFile12(statePath, JSON.stringify(payload), "utf8");
 }
 var workspaceRootsMutation = Promise.resolve();
 function queueWorkspaceRootsMutation(mutation) {
@@ -12431,8 +12563,8 @@ async function collectProjectChatZipEntries(projectRoot) {
   const exportedTitles = {};
   const exportedThreads = {};
   const roots = [
-    { disk: join22(codexHome, "sessions"), zip: ".codex-project/chats/sessions" },
-    { disk: join22(codexHome, "archived_sessions"), zip: ".codex-project/chats/archived_sessions" }
+    { disk: join23(codexHome, "sessions"), zip: ".codex-project/chats/sessions" },
+    { disk: join23(codexHome, "archived_sessions"), zip: ".codex-project/chats/archived_sessions" }
   ];
   const entries = [{
     path: ".codex-project/manifest.json",
@@ -12527,14 +12659,14 @@ async function importProjectZip(buffer, destinationParent) {
     }
   }
   const parent = await realpath3(destinationParent);
-  let projectPath = join22(parent, projectName);
+  let projectPath = join23(parent, projectName);
   for (let index = 2; existsSync8(projectPath); index += 1) {
-    projectPath = join22(parent, `${projectName}-${index}`);
+    projectPath = join23(parent, `${projectName}-${index}`);
   }
-  await mkdir9(projectPath, { recursive: true });
+  await mkdir10(projectPath, { recursive: true });
   let importedSessions = 0;
   const importedSessionRecords = [];
-  const importedSessionsRoot = join22(getCodexHomeDir2(), "sessions");
+  const importedSessionsRoot = join23(getCodexHomeDir2(), "sessions");
   const chatEntries = entries.filter((entry) => entry.path.startsWith(".codex-project/chats/") && !entry.isDirectory && extname3(entry.path) === ".jsonl").map((entry) => {
     const importedMetadata = importedThreadMetadata.get(entry.path);
     const sourceSessionRaw = entry.data.toString("utf8");
@@ -12544,10 +12676,10 @@ async function importProjectZip(buffer, destinationParent) {
   }).sort((first, second) => second.updatedAtMs - first.updatedAtMs);
   for (const [index, chatEntry] of chatEntries.entries()) {
     const importedThreadId = randomUUID2();
-    const target = join22(importedSessionsRoot, "imported", `${String(index + 1).padStart(6, "0")}-${importedThreadId}.jsonl`);
-    await mkdir9(dirname6(target), { recursive: true });
+    const target = join23(importedSessionsRoot, "imported", `${String(index + 1).padStart(6, "0")}-${importedThreadId}.jsonl`);
+    await mkdir10(dirname6(target), { recursive: true });
     const importedSessionRaw = rewriteImportedSession(chatEntry.sourceSessionRaw, projectPath, importedThreadId);
-    await writeFile12(target, importedSessionRaw, "utf8");
+    await writeFile13(target, importedSessionRaw, "utf8");
     const importedRecord = readImportedSessionRecord(importedSessionRaw, target, projectPath, importedThreadId, chatEntry.importedMetadata?.title ?? "");
     if (chatEntry.updatedAtMs > 0) {
       importedRecord.updatedAtMs = chatEntry.updatedAtMs;
@@ -12568,13 +12700,13 @@ async function importProjectZip(buffer, destinationParent) {
     if (entry.path.startsWith(".codex-project/chats/")) {
       continue;
     }
-    const target = join22(projectPath, entry.path);
+    const target = join23(projectPath, entry.path);
     if (!isSameOrDescendantPath(target, projectPath)) throw new Error("Project ZIP contains an unsafe path");
     if (entry.isDirectory) {
-      await mkdir9(target, { recursive: true });
+      await mkdir10(target, { recursive: true });
     } else {
-      await mkdir9(dirname6(target), { recursive: true });
-      await writeFile12(target, entry.data);
+      await mkdir10(dirname6(target), { recursive: true });
+      await writeFile13(target, entry.data);
     }
   }
   await persistWorkspaceRoot(projectPath, projectName);
@@ -12582,7 +12714,7 @@ async function importProjectZip(buffer, destinationParent) {
 }
 
 // src/server/bridge/threadQueueState.ts
-import { readFile as readFile15, writeFile as writeFile13 } from "fs/promises";
+import { readFile as readFile15, writeFile as writeFile14 } from "fs/promises";
 var THREAD_QUEUE_STATE_KEY = "thread-queue-state";
 function normalizeStoredQueuedMessage(value) {
   const record = asRecord2(value);
@@ -12662,7 +12794,7 @@ async function writeThreadQueueStateUnlocked(nextState) {
   } else {
     delete payload[THREAD_QUEUE_STATE_KEY];
   }
-  await writeFile13(statePath, JSON.stringify(payload), "utf8");
+  await writeFile14(statePath, JSON.stringify(payload), "utf8");
 }
 async function withThreadQueueStateUpdate(update) {
   const run = threadQueueMutationChain.then(async () => {
@@ -12938,10 +13070,10 @@ function isTurnCompletedNotification(notification) {
 
 // src/server/bridge/approvalPolicy.ts
 import { existsSync as existsSync9, readFileSync as readFileSync5 } from "fs";
-import { mkdir as mkdir10, readFile as readFile16, writeFile as writeFile14 } from "fs/promises";
-import { dirname as dirname7, join as join23 } from "path";
+import { mkdir as mkdir11, readFile as readFile16, writeFile as writeFile15 } from "fs/promises";
+import { dirname as dirname7, join as join24 } from "path";
 function getCodexConfigPath() {
-  return join23(getCodexHomeDir2(), "config.toml");
+  return join24(getCodexHomeDir2(), "config.toml");
 }
 async function resolveEffectiveApprovalPolicy() {
   const envPolicy = parseApprovalPolicy(process.env.CODEXUI_APPROVAL_POLICY ?? "");
@@ -12970,10 +13102,10 @@ function readApprovalPolicyFromConfigFile() {
 var APPROVAL_POLICY_ASSIGNMENT = /^approval_policy\s*=/u;
 async function writeApprovalPolicyToConfigFile(policy) {
   const configPath = getCodexConfigPath();
-  await mkdir10(dirname7(configPath), { recursive: true });
+  await mkdir11(dirname7(configPath), { recursive: true });
   const policyLine = `approval_policy = "${policy}"`;
   if (!existsSync9(configPath)) {
-    await writeFile14(configPath, `${policyLine}
+    await writeFile15(configPath, `${policyLine}
 `, "utf8");
     return;
   }
@@ -12985,14 +13117,14 @@ async function writeApprovalPolicyToConfigFile(policy) {
 ${body}
 ` : `${policyLine}
 `;
-  await writeFile14(configPath, nextContent, "utf8");
+  await writeFile15(configPath, nextContent, "utf8");
 }
 
 // src/server/bridge/inlineImages.ts
-import { createHash as createHash2 } from "crypto";
-import { mkdir as mkdir11, stat as stat12, writeFile as writeFile15 } from "fs/promises";
-import { tmpdir as tmpdir5 } from "os";
-import { join as join24 } from "path";
+import { createHash as createHash3 } from "crypto";
+import { mkdir as mkdir12, stat as stat13, writeFile as writeFile16 } from "fs/promises";
+import { tmpdir as tmpdir6 } from "os";
+import { join as join25 } from "path";
 var THREAD_METHODS_WITH_TURNS2 = /* @__PURE__ */ new Set(["thread/read", "thread/resume", "thread/fork", "thread/rollback", "thread/revert"]);
 function isInlineDataUrl(value) {
   return /^data:/iu.test(value.trim());
@@ -13081,16 +13213,16 @@ async function persistInlineDataUrlToLocalFile(dataUrl, baseName) {
     return null;
   }
   if (bytes.length === 0) return null;
-  const hash = createHash2("sha1").update(bytes).digest("hex");
+  const hash = createHash3("sha1").update(bytes).digest("hex");
   const ext = extensionFromMimeType(mimeType);
-  const mediaDir = join24(tmpdir5(), "codex-web-inline-media");
-  await mkdir11(mediaDir, { recursive: true });
+  const mediaDir = join25(tmpdir6(), "codex-web-inline-media");
+  await mkdir12(mediaDir, { recursive: true });
   const fileName = `${baseName}-${hash}${ext}`;
-  const filePath = join24(mediaDir, fileName);
+  const filePath = join25(mediaDir, fileName);
   try {
-    await stat12(filePath);
+    await stat13(filePath);
   } catch {
-    await writeFile15(filePath, bytes);
+    await writeFile16(filePath, bytes);
   }
   return filePath;
 }
@@ -13222,10 +13354,11 @@ async function sanitizeInlinePayloadDeep(value, context) {
 }
 async function sanitizeThreadTurnsInlinePayloads(method, result) {
   if (!THREAD_METHODS_WITH_TURNS2.has(method)) return result;
-  const record = asRecord2(result);
+  const slimmed = await slimThreadTurnsPayload(method, result);
+  const record = asRecord2(slimmed);
   const thread = asRecord2(record?.thread);
   const turns = Array.isArray(thread?.turns) ? thread.turns : null;
-  if (!record || !thread || !turns || turns.length === 0) return result;
+  if (!record || !thread || !turns || turns.length === 0) return slimmed;
   let changed = false;
   const nextTurns = [];
   for (let turnIndex = 0; turnIndex < turns.length; turnIndex += 1) {
@@ -13269,7 +13402,7 @@ async function sanitizeThreadTurnsInlinePayloads(method, result) {
       items: nextItems
     });
   }
-  if (!changed) return result;
+  if (!changed) return slimmed;
   return {
     ...record,
     thread: {
@@ -13279,6 +13412,70 @@ async function sanitizeThreadTurnsInlinePayloads(method, result) {
   };
 }
 
+// src/server/bridge/threadReadCache.ts
+var THREAD_READ_RESULT_CACHE_TTL_MS = 2e4;
+var THREAD_READ_RESULT_CACHE_MAX_ENTRIES = 6;
+var THREAD_READ_INVALIDATING_METHOD_PATTERN = /^(?:turn\/|thread\/(?:start|fork|rollback|revert|resume|archive|unarchive|delete|compact|name\/))/u;
+function threadReadInvalidatesCache(method) {
+  return THREAD_READ_INVALIDATING_METHOD_PATTERN.test(method);
+}
+function buildThreadReadCacheKey(params) {
+  const parts = [];
+  for (const key of Object.keys(params).sort()) {
+    if (key === "threadId") continue;
+    const value = params[key];
+    if (value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+      parts.push(`${key}=${String(value)}`);
+      continue;
+    }
+    return "";
+  }
+  return parts.join("&");
+}
+var ThreadReadResultCache = class {
+  constructor() {
+    this.entries = /* @__PURE__ */ new Map();
+  }
+  get size() {
+    return this.entries.size;
+  }
+  get(threadId, params) {
+    if (!threadId || !params) return null;
+    const cacheKey = buildThreadReadCacheKey(params);
+    if (!cacheKey) return null;
+    const mapKey = `${threadId}\0${cacheKey}`;
+    const entry = this.entries.get(mapKey);
+    if (!entry) return null;
+    if (entry.expiresAt <= Date.now()) {
+      this.entries.delete(mapKey);
+      return null;
+    }
+    return entry.result;
+  }
+  set(threadId, params, result, now = Date.now()) {
+    if (!threadId || !params) return;
+    const cacheKey = buildThreadReadCacheKey(params);
+    if (!cacheKey) return;
+    const mapKey = `${threadId}\0${cacheKey}`;
+    this.entries.delete(mapKey);
+    this.entries.set(mapKey, { threadId, result, expiresAt: now + THREAD_READ_RESULT_CACHE_TTL_MS });
+    while (this.entries.size > THREAD_READ_RESULT_CACHE_MAX_ENTRIES) {
+      const oldestKey = this.entries.keys().next();
+      if (oldestKey.done) break;
+      this.entries.delete(oldestKey.value);
+    }
+  }
+  invalidate(threadId) {
+    if (!threadId) {
+      this.entries.clear();
+      return;
+    }
+    for (const [mapKey, entry] of this.entries) {
+      if (entry.threadId === threadId) this.entries.delete(mapKey);
+    }
+  }
+};
+
 // src/server/bridge/apiPerfLogging.ts
 import { readFileSync as readFileSync6 } from "fs";
 var API_PERF_LOGGING_ENV_KEY = "CODEXUI_API_PERF_LOGGING";
@@ -13354,12 +13551,12 @@ function getChunkByteLength(chunk, encoding) {
 }
 
 // src/server/bridge/terminal.ts
-import { readdir as readdir9, readFile as readFile17, stat as stat13 } from "fs/promises";
-import { isAbsolute as isAbsolute8, join as join25, resolve as resolve5 } from "path";
+import { readdir as readdir9, readFile as readFile17, stat as stat14 } from "fs/promises";
+import { isAbsolute as isAbsolute8, join as join26, resolve as resolve5 } from "path";
 import { existsSync as existsSync10 } from "fs";
 async function listTerminalQuickCommands(cwd) {
   const normalizedCwd = isAbsolute8(cwd) ? cwd : resolve5(cwd);
-  const info = await stat13(normalizedCwd);
+  const info = await stat14(normalizedCwd);
   if (!info.isDirectory()) {
     throw new Error("Terminal cwd is not a directory");
   }
@@ -13378,7 +13575,7 @@ async function listTerminalQuickCommands(cwd) {
 }
 async function addPackageJsonCommands(cwd, addCommand) {
   try {
-    const raw = await readFile17(join25(cwd, "package.json"), "utf8");
+    const raw = await readFile17(join26(cwd, "package.json"), "utf8");
     const parsed = JSON.parse(raw);
     const record = asRecord2(parsed);
     const scripts = asRecord2(record?.scripts);
@@ -13397,7 +13594,7 @@ async function addPackageJsonCommands(cwd, addCommand) {
   }
 }
 async function addMakefileCommands(cwd, addCommand) {
-  const makefilePath = existsSync10(join25(cwd, "Makefile")) ? join25(cwd, "Makefile") : existsSync10(join25(cwd, "makefile")) ? join25(cwd, "makefile") : "";
+  const makefilePath = existsSync10(join26(cwd, "Makefile")) ? join26(cwd, "Makefile") : existsSync10(join26(cwd, "makefile")) ? join26(cwd, "makefile") : "";
   if (!makefilePath) return;
   try {
     const raw = await readFile17(makefilePath, "utf8");
@@ -13420,7 +13617,7 @@ async function addRootScriptCommands(cwd, addCommand) {
   await addScriptFileCommands(cwd, ".", addCommand);
 }
 async function addScriptsDirectoryCommands(cwd, addCommand) {
-  await addScriptFileCommands(join25(cwd, "scripts"), "./scripts", addCommand);
+  await addScriptFileCommands(join26(cwd, "scripts"), "./scripts", addCommand);
 }
 async function addScriptFileCommands(directory, commandPrefix, addCommand) {
   try {
@@ -13439,9 +13636,9 @@ async function addScriptFileCommands(directory, commandPrefix, addCommand) {
   }
 }
 function resolvePackageManager(cwd) {
-  if (existsSync10(join25(cwd, "pnpm-lock.yaml"))) return "pnpm";
-  if (existsSync10(join25(cwd, "yarn.lock"))) return "yarn";
-  if (existsSync10(join25(cwd, "bun.lock")) || existsSync10(join25(cwd, "bun.lockb"))) return "bun";
+  if (existsSync10(join26(cwd, "pnpm-lock.yaml"))) return "pnpm";
+  if (existsSync10(join26(cwd, "yarn.lock"))) return "yarn";
+  if (existsSync10(join26(cwd, "bun.lock")) || existsSync10(join26(cwd, "bun.lockb"))) return "bun";
   return "npm";
 }
 function formatPackageScriptCommand(packageManager, scriptName) {
@@ -13454,13 +13651,13 @@ function formatPackageScriptCommand(packageManager, scriptName) {
 
 // src/server/bridge/routes.ts
 import { randomBytes as randomBytes5 } from "crypto";
-import { stat as stat15, mkdir as mkdir13 } from "fs/promises";
-import { basename as basename8, dirname as dirname9, isAbsolute as isAbsolute10, join as join27, resolve as resolve6 } from "path";
+import { stat as stat16, mkdir as mkdir14 } from "fs/promises";
+import { basename as basename8, dirname as dirname9, isAbsolute as isAbsolute10, join as join28, resolve as resolve6 } from "path";
 
 // src/server/bridge/git.ts
 import { existsSync as existsSync11 } from "fs";
-import { mkdir as mkdir12, rename as rename3, rm as rm8, stat as stat14, writeFile as writeFile16 } from "fs/promises";
-import { dirname as dirname8, isAbsolute as isAbsolute9, join as join26 } from "path";
+import { mkdir as mkdir13, rename as rename3, rm as rm8, stat as stat15, writeFile as writeFile17 } from "fs/promises";
+import { dirname as dirname8, isAbsolute as isAbsolute9, join as join27 } from "path";
 function isMissingHeadError2(error) {
   const message = getErrorMessage2(error, "").toLowerCase();
   return message.includes("not a valid object name: 'head'") || message.includes("not a valid object name: head") || message.includes("invalid reference: head");
@@ -13470,11 +13667,11 @@ function isNotGitRepositoryError2(error) {
   return message.includes("not a git repository") || message.includes("fatal: not a git repository");
 }
 async function ensureRepoHasInitialCommit(repoRoot) {
-  const agentsPath = join26(repoRoot, "AGENTS.md");
+  const agentsPath = join27(repoRoot, "AGENTS.md");
   try {
-    await stat14(agentsPath);
+    await stat15(agentsPath);
   } catch {
-    await writeFile16(agentsPath, "", "utf8");
+    await writeFile17(agentsPath, "", "utf8");
   }
   await runCommand("git", ["add", "AGENTS.md"], { cwd: repoRoot });
   await runCommand(
@@ -13505,7 +13702,7 @@ function isSafeGitRelativePath2(filePath) {
   return Boolean(filePath) && !isAbsolute9(filePath) && !filePath.split("/").includes("..");
 }
 function resolveGitRelativePath(repoRoot, filePath) {
-  return join26(repoRoot, ...filePath.split("/"));
+  return join27(repoRoot, ...filePath.split("/"));
 }
 function gitPathsConflict(left, right) {
   return left === right || left.startsWith(`${right}/`) || right.startsWith(`${left}/`);
@@ -13525,7 +13722,7 @@ async function rollbackPreservedUntrackedFiles(entries) {
   for (const entry of entries.slice().reverse()) {
     try {
       if (existsSync11(entry.backupPath) && !existsSync11(entry.sourcePath)) {
-        await mkdir12(dirname8(entry.sourcePath), { recursive: true });
+        await mkdir13(dirname8(entry.sourcePath), { recursive: true });
         await rename3(entry.backupPath, entry.sourcePath);
       }
     } catch {
@@ -13540,12 +13737,12 @@ async function preserveUntrackedFilesForGitTarget(repoRoot, targetRef) {
   const targetPaths = splitGitPathList2(targetTreeRaw);
   const conflictingUntrackedPaths = splitGitPathList2(untrackedRaw).filter((filePath) => isSafeGitRelativePath2(filePath) && targetPaths.some((targetPath) => gitPathsConflict(filePath, targetPath)));
   if (conflictingUntrackedPaths.length === 0) return [];
-  const backupRoot = join26(repoRoot, HEADER_GIT_UNTRACKED_BACKUP_DIR, (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-"));
+  const backupRoot = join27(repoRoot, HEADER_GIT_UNTRACKED_BACKUP_DIR, (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-"));
   const movedFiles = [];
   for (const filePath of conflictingUntrackedPaths) {
     const sourcePath = resolveGitRelativePath(repoRoot, filePath);
-    const backupPath = join26(backupRoot, ...filePath.split("/"));
-    await mkdir12(dirname8(backupPath), { recursive: true });
+    const backupPath = join27(backupRoot, ...filePath.split("/"));
+    await mkdir13(dirname8(backupPath), { recursive: true });
     await rename3(sourcePath, backupPath);
     movedFiles.push({ filePath, sourcePath, backupPath });
     await removeEmptyGitRelativeParents(repoRoot, filePath);
@@ -13704,7 +13901,7 @@ async function handleGitWorktreeHttpRequest(req, res, url, deps) {
     }
     const sourceCwd = isAbsolute10(rawSourceCwd) ? rawSourceCwd : resolve6(rawSourceCwd);
     try {
-      const sourceInfo = await stat15(sourceCwd);
+      const sourceInfo = await stat16(sourceCwd);
       if (!sourceInfo.isDirectory()) {
         setJson2(res, 400, { error: "sourceCwd is not a directory" });
         return true;
@@ -13723,21 +13920,21 @@ async function handleGitWorktreeHttpRequest(req, res, url, deps) {
         gitRoot = await runCommandCapture("git", ["rev-parse", "--show-toplevel"], { cwd: sourceCwd });
       }
       const repoName = basename8(gitRoot) || "repo";
-      const worktreesRoot = join27(getCodexHomeDir2(), "worktrees");
-      await mkdir13(worktreesRoot, { recursive: true });
+      const worktreesRoot = join28(getCodexHomeDir2(), "worktrees");
+      await mkdir14(worktreesRoot, { recursive: true });
       let worktreeId = "";
       let worktreeParent = "";
       let worktreeCwd = "";
       for (let attempt = 0; attempt < 12; attempt += 1) {
         const candidate = randomBytes5(2).toString("hex");
-        const parent = join27(worktreesRoot, candidate);
+        const parent = join28(worktreesRoot, candidate);
         try {
-          await stat15(parent);
+          await stat16(parent);
           continue;
         } catch {
           worktreeId = candidate;
           worktreeParent = parent;
-          worktreeCwd = join27(parent, repoName);
+          worktreeCwd = join28(parent, repoName);
           break;
         }
       }
@@ -13745,7 +13942,7 @@ async function handleGitWorktreeHttpRequest(req, res, url, deps) {
         throw new Error("Failed to allocate a unique worktree id");
       }
       const startPoint = baseBranch || "HEAD";
-      await mkdir13(worktreeParent, { recursive: true });
+      await mkdir14(worktreeParent, { recursive: true });
       try {
         await runCommand("git", ["worktree", "add", "--detach", worktreeCwd, startPoint], { cwd: gitRoot });
       } catch (error) {
@@ -13789,7 +13986,7 @@ async function handleGitWorktreeHttpRequest(req, res, url, deps) {
     }
     const sourceCwd = isAbsolute10(rawSourceCwd) ? rawSourceCwd : resolve6(rawSourceCwd);
     try {
-      const sourceInfo = await stat15(sourceCwd);
+      const sourceInfo = await stat16(sourceCwd);
       if (!sourceInfo.isDirectory()) {
         setJson2(res, 400, { error: "sourceCwd is not a directory" });
         return true;
@@ -13807,9 +14004,9 @@ async function handleGitWorktreeHttpRequest(req, res, url, deps) {
         await runCommand("git", ["init"], { cwd: sourceCwd });
         gitRoot = await runCommandCapture("git", ["rev-parse", "--show-toplevel"], { cwd: sourceCwd });
       }
-      const worktreeCwd = join27(dirname9(gitRoot), rawWorktreeName);
+      const worktreeCwd = join28(dirname9(gitRoot), rawWorktreeName);
       try {
-        await stat15(worktreeCwd);
+        await stat16(worktreeCwd);
         setJson2(res, 409, { error: "Worktree folder already exists" });
         return true;
       } catch {
@@ -13848,7 +14045,7 @@ async function handleGitWorktreeHttpRequest(req, res, url, deps) {
     }
     const sourceCwd = isAbsolute10(rawSourceCwd) ? rawSourceCwd : resolve6(rawSourceCwd);
     try {
-      const sourceInfo = await stat15(sourceCwd);
+      const sourceInfo = await stat16(sourceCwd);
       if (!sourceInfo.isDirectory()) {
         setJson2(res, 400, { error: "sourceCwd is not a directory" });
         return true;
@@ -13903,7 +14100,7 @@ async function handleGitWorktreeHttpRequest(req, res, url, deps) {
     }
     const cwd = isAbsolute10(rawCwd) ? rawCwd : resolve6(rawCwd);
     try {
-      const cwdInfo = await stat15(cwd);
+      const cwdInfo = await stat16(cwd);
       if (!cwdInfo.isDirectory()) {
         setJson2(res, 400, { error: "cwd is not a directory" });
         return true;
@@ -13979,7 +14176,7 @@ async function handleGitWorktreeHttpRequest(req, res, url, deps) {
     }
     const cwd = isAbsolute10(rawCwd) ? rawCwd : resolve6(rawCwd);
     try {
-      const cwdInfo = await stat15(cwd);
+      const cwdInfo = await stat16(cwd);
       if (!cwdInfo.isDirectory()) {
         setJson2(res, 400, { error: "cwd is not a directory" });
         return true;
@@ -14029,7 +14226,7 @@ async function handleGitWorktreeHttpRequest(req, res, url, deps) {
     }
     const cwd = isAbsolute10(rawCwd) ? rawCwd : resolve6(rawCwd);
     try {
-      const cwdInfo = await stat15(cwd);
+      const cwdInfo = await stat16(cwd);
       if (!cwdInfo.isDirectory()) {
         setJson2(res, 400, { error: "cwd is not a directory" });
         return true;
@@ -14251,6 +14448,7 @@ var AppServerProcess = class {
     this.lastThreadReadSnapshotByThreadId = /* @__PURE__ */ new Map();
     this.threadTurnPageReadCacheByThreadId = /* @__PURE__ */ new Map();
     this.threadTurnPageReadPromiseByThreadId = /* @__PURE__ */ new Map();
+    this.threadReadResultCache = new ThreadReadResultCache();
     this.capturedItemsByThreadId = /* @__PURE__ */ new Map();
     this.liveStateCache = /* @__PURE__ */ new Map();
     this.chatgptAuthRefreshPromise = null;
@@ -14268,7 +14466,7 @@ var AppServerProcess = class {
     let extraEnv = {};
     const serverPort = parseInt(process.env.CODEXUI_SERVER_PORT ?? "", 10) || void 0;
     args.push(...getProviderCompatibilityConfigArgs(serverPort));
-    const statePath = join28(getCodexHomeDir2(), FREE_MODE_STATE_FILE);
+    const statePath = join29(getCodexHomeDir2(), FREE_MODE_STATE_FILE);
     try {
       const state = ensureDefaultFreeModeStateForMissingAuthSync(statePath);
       if (state) {
@@ -14331,6 +14529,7 @@ var AppServerProcess = class {
       this.initialized = false;
       this.initializePromise = null;
       this.readBuffer = "";
+      this.invalidateThreadReadResultCache();
     });
   }
   sendLine(payload) {
@@ -14376,6 +14575,7 @@ var AppServerProcess = class {
     if (nThreadId) {
       this.invalidateLiveStateCache(nThreadId);
       this.threadTurnPageReadCacheByThreadId.delete(nThreadId);
+      this.invalidateThreadReadResultCache(nThreadId);
     }
     for (const listener of this.notificationListeners) {
       listener(notification);
@@ -14450,6 +14650,20 @@ var AppServerProcess = class {
   cacheLiveState(threadId, data, turnCount, sessionSize) {
     this.liveStateCache.set(threadId, { data, turnCount, sessionSize });
   }
+  /**
+   * Cache a post-pipeline `thread/read` result. Called by the RPC handler with
+   * exactly what was sent to the client, so a hit skips the app-server call, the
+   * 10-turn trim, the session-log command merge and the payload slimming.
+   */
+  cacheThreadReadResult(threadId, params, result) {
+    this.threadReadResultCache.set(threadId, asRecord2(params), result);
+  }
+  getCachedThreadReadResult(threadId, params) {
+    return this.threadReadResultCache.get(threadId, asRecord2(params));
+  }
+  invalidateThreadReadResultCache(threadId) {
+    this.threadReadResultCache.invalidate(threadId);
+  }
   getCachedLiveState(threadId, turnCount, sessionSize) {
     const cached = this.liveStateCache.get(threadId);
     if (!cached) return null;
@@ -14645,9 +14859,45 @@ var AppServerProcess = class {
   }
   async rpc(method, params) {
     this.disposeIfConfigChanged();
+    if (threadReadInvalidatesCache(method)) {
+      const paramsRecord = asRecord2(params);
+      const threadId = readNonEmptyString(paramsRecord?.threadId);
+      this.invalidateThreadReadResultCache(threadId || void 0);
+    }
     await this.ensureInitialized();
     return this.call(method, params);
   }
+  /**
+   * Spawn + initialize the app-server ahead of the first user request.
+   *
+   * Measured cold start: the first page load fires ~20 startup RPCs that all
+   * queue behind one just-spawned app-server (head-of-line blocking —
+   * free-mode/status 2619ms, meta/methods 1306ms, thread/queue-state 1287ms), so
+   * `thread/list` costs 934ms cold vs 63ms warm.
+   *
+   * Honest scope of the win (measured 2026-09-11, dev server): the frontend's
+   * burst arrives ~1-3s after the Vite dev server reports ready, while
+   * `ensureInitialized()` here needs ~2.1s. So warm-up only *overlaps* part of
+   * the init — the first request still waits for the remainder (observed first
+   * GET 1401ms, meta/methods 2118ms). It does not remove the cold start from
+   * first paint; it removes it from every *later* load, and it is what makes the
+   * warm path (all endpoints <=70ms) reachable without an artificial first
+   * request. Treat this as queue-shifting, not as a first-paint fix.
+   *
+   * Side effect to be aware of: this spawns the app-server eagerly whenever the
+   * bridge is created (dev server and packaged `createServer` alike) instead of
+   * lazily on the first request.
+   *
+   * Best-effort: a failure here must not break the bridge, because the next
+   * request retries through the normal ensureInitialized path.
+   */
+  async warmUp() {
+    try {
+      this.disposeIfConfigChanged();
+      await this.ensureInitialized();
+    } catch {
+    }
+  }
   onNotification(listener) {
     this.notificationListeners.add(listener);
     return () => {
@@ -14688,6 +14938,7 @@ var AppServerProcess = class {
     this.initializePromise = null;
     this.activeConfigSignature = "";
     this.readBuffer = "";
+    this.invalidateThreadReadResultCache();
     const failure = new Error("codex app-server stopped");
     for (const request of this.pending.values()) {
       request.reject(failure);
@@ -14995,9 +15246,9 @@ var MethodCatalog = class {
     if (this.methodCache) {
       return this.methodCache;
     }
-    const outDir = await mkdtemp4(join28(tmpdir6(), "codex-web-local-schema-"));
+    const outDir = await mkdtemp4(join29(tmpdir7(), "codex-web-local-schema-"));
     await this.runGenerateSchemaCommand(outDir);
-    const clientRequestPath = join28(outDir, "ClientRequest.json");
+    const clientRequestPath = join29(outDir, "ClientRequest.json");
     const raw = await readFile18(clientRequestPath, "utf8");
     const parsed = JSON.parse(raw);
     const methods = this.extractMethodsFromClientRequest(parsed);
@@ -15008,9 +15259,9 @@ var MethodCatalog = class {
     if (this.notificationCache) {
       return this.notificationCache;
     }
-    const outDir = await mkdtemp4(join28(tmpdir6(), "codex-web-local-schema-"));
+    const outDir = await mkdtemp4(join29(tmpdir7(), "codex-web-local-schema-"));
     await this.runGenerateSchemaCommand(outDir);
-    const serverNotificationPath = join28(outDir, "ServerNotification.json");
+    const serverNotificationPath = join29(outDir, "ServerNotification.json");
     const raw = await readFile18(serverNotificationPath, "utf8");
     const parsed = JSON.parse(raw);
     const methods = this.extractMethodsFromServerNotification(parsed);
@@ -15019,7 +15270,7 @@ var MethodCatalog = class {
   }
 };
 var SHARED_BRIDGE_KEY = "__codexRemoteSharedBridge__";
-var SHARED_BRIDGE_VERSION = "experimental-api-v2";
+var SHARED_BRIDGE_VERSION = "experimental-api-v3";
 function getSharedBridgeState() {
   const globalScope = globalThis;
   const existing = globalScope[SHARED_BRIDGE_KEY];
@@ -15068,6 +15319,7 @@ function createCodexBridgeMiddleware() {
     }
     return threadSearchIndexPromise;
   }
+  void appServer.warmUp();
   void initializeSkillsSyncOnStartup(appServer);
   void readTelegramBridgeConfig().then((config) => {
     if (!config.botToken) return;
@@ -15128,7 +15380,7 @@ function createCodexBridgeMiddleware() {
           setJson(res, 403, { error: "Zen proxy is only available from localhost" });
           return;
         }
-        const statePath = join28(getCodexHomeDir2(), FREE_MODE_STATE_FILE);
+        const statePath = join29(getCodexHomeDir2(), FREE_MODE_STATE_FILE);
         let bearerToken = "";
         let wireApi = "responses";
         try {
@@ -15143,7 +15395,7 @@ function createCodexBridgeMiddleware() {
         return;
       }
       if (url.pathname === "/codex-api/openrouter-proxy/v1/responses" && req.method === "POST") {
-        const statePath = join28(getCodexHomeDir2(), FREE_MODE_STATE_FILE);
+        const statePath = join29(getCodexHomeDir2(), FREE_MODE_STATE_FILE);
         let bearerToken = "";
         let wireApi = "responses";
         try {
@@ -15156,7 +15408,7 @@ function createCodexBridgeMiddleware() {
         return;
       }
       if (url.pathname === "/codex-api/custom-proxy/v1/responses" && req.method === "POST") {
-        const statePath = join28(getCodexHomeDir2(), FREE_MODE_STATE_FILE);
+        const statePath = join29(getCodexHomeDir2(), FREE_MODE_STATE_FILE);
         let bearerToken = "";
         let wireApi = "responses";
         let baseUrl = "";
@@ -15310,6 +15562,14 @@ function createCodexBridgeMiddleware() {
           setJson(res, 200, { result: null });
           return;
         }
+        const cacheableThreadReadId = body.method === "thread/read" ? readNonEmptyString(asRecord2(body.params)?.threadId) : "";
+        if (cacheableThreadReadId) {
+          const cachedThreadRead = appServer.getCachedThreadReadResult(cacheableThreadReadId, body.params ?? null);
+          if (cachedThreadRead !== null) {
+            setJson(res, 200, { result: cachedThreadRead });
+            return;
+          }
+        }
         let rpcResult;
         try {
           rpcResult = await callRpcWithArchiveRecovery(appServer, body.method, body.params ?? null);
@@ -15354,6 +15614,9 @@ function createCodexBridgeMiddleware() {
           sanitizeThreadTurnsInlinePayloads,
           mergeImportedThreadsIntoThreadListResult
         }, body.method, rpcResult);
+        if (cacheableThreadReadId) {
+          appServer.cacheThreadReadResult(cacheableThreadReadId, body.params ?? null, pipelineResult);
+        }
         setJson(res, 200, { result: pipelineResult });
         return;
       }
@@ -15373,7 +15636,7 @@ function createCodexBridgeMiddleware() {
           const action = readNonEmptyString(body?.action) === "redo" ? "redo" : "undo";
           const scope = readNonEmptyString(body?.scope) === "single_turn" ? "single_turn" : "turn_and_later";
           const patchIds = Array.isArray(body?.patchIds) ? new Set(body.patchIds.filter((value) => typeof value === "string" && value.length > 0)) : void 0;
-          const filePaths = Array.isArray(body?.filePaths) ? new Set(body.filePaths.filter((value) => typeof value === "string" && value.length > 0).map((value) => isAbsolute11(value) ? value : join28(cwd, value))) : void 0;
+          const filePaths = Array.isArray(body?.filePaths) ? new Set(body.filePaths.filter((value) => typeof value === "string" && value.length > 0).map((value) => isAbsolute11(value) ? value : join29(cwd, value))) : void 0;
           if (!threadId || !turnId || !cwd) {
             setJson(res, 400, { error: "Missing threadId, turnId, or cwd" });
             return;
@@ -15459,7 +15722,7 @@ function createCodexBridgeMiddleware() {
           const requestedProvider = url.searchParams.get("provider")?.trim() ?? "";
           if (requestedProvider) {
             const normalizedRequestedProvider = requestedProvider.replace(/_/g, "-");
-            const fmState2 = ensureDefaultFreeModeStateForMissingAuthSync(join28(getCodexHomeDir2(), FREE_MODE_STATE_FILE));
+            const fmState2 = ensureDefaultFreeModeStateForMissingAuthSync(join29(getCodexHomeDir2(), FREE_MODE_STATE_FILE));
             if (fmState2?.enabled && normalizedRequestedProvider === CUSTOM_RUNTIME_PROVIDER_ID.replace(/_/g, "-") && fmState2.provider === "custom" && fmState2.customBaseUrl) {
               setJson(res, 200, {
                 data: await fetchCustomEndpointModelIds(fmState2.customBaseUrl, fmState2.apiKey ?? ""),
@@ -15489,7 +15752,7 @@ function createCodexBridgeMiddleware() {
             });
             return;
           }
-          const fmState = ensureDefaultFreeModeStateForMissingAuthSync(join28(getCodexHomeDir2(), FREE_MODE_STATE_FILE));
+          const fmState = ensureDefaultFreeModeStateForMissingAuthSync(join29(getCodexHomeDir2(), FREE_MODE_STATE_FILE));
           if (fmState?.enabled) {
             if (fmState.provider === "opencode-zen") {
               try {
@@ -15664,7 +15927,7 @@ function createCodexBridgeMiddleware() {
 import { randomBytes as randomBytes6, timingSafeEqual } from "crypto";
 import { existsSync as existsSync12, mkdirSync, readFileSync as readFileSync7, renameSync, writeFileSync as writeFileSync2 } from "fs";
 import { homedir as homedir10 } from "os";
-import { dirname as dirname11, join as join29 } from "path";
+import { dirname as dirname11, join as join30 } from "path";
 var TOKEN_COOKIE = "portal_session";
 var SESSION_TTL_MS = 30 * 24 * 60 * 60 * 1e3;
 var SESSION_STORE_FILE = "webui-auth-sessions.json";
@@ -15718,10 +15981,10 @@ function isTrustedTailscaleRemote(remote) {
 }
 function getCodexHomeDir6() {
   const codexHome = process.env.CODEX_HOME?.trim();
-  return codexHome && codexHome.length > 0 ? codexHome : join29(homedir10(), ".codex");
+  return codexHome && codexHome.length > 0 ? codexHome : join30(homedir10(), ".codex");
 }
 function getSessionStorePath() {
-  return join29(getCodexHomeDir6(), SESSION_STORE_FILE);
+  return join30(getCodexHomeDir6(), SESSION_STORE_FILE);
 }
 function readPersistedSessions() {
   const sessionStorePath = getSessionStorePath();
@@ -15903,8 +16166,8 @@ function createAuthSession(password) {
 // src/server/httpServer.ts
 import { WebSocketServer } from "ws";
 var __dirname = dirname12(fileURLToPath(import.meta.url));
-var distDir = join30(__dirname, "..", "dist");
-var spaEntryFile = join30(distDir, "index.html");
+var distDir = join31(__dirname, "..", "dist");
+var spaEntryFile = join31(distDir, "index.html");
 var IMAGE_CONTENT_TYPES = {
   ".avif": "image/avif",
   ".bmp": "image/bmp",
@@ -16008,7 +16271,7 @@ function createServer(options = {}) {
       return;
     }
     try {
-      const fileStat = await stat17(localPath);
+      const fileStat = await stat18(localPath);
       if (!fileStat.isDirectory()) {
         res.status(400).json({ error: "Expected directory path." });
         return;
@@ -16027,7 +16290,7 @@ function createServer(options = {}) {
       return;
     }
     try {
-      const fileStat = await stat17(localPath);
+      const fileStat = await stat18(localPath);
       if (!fileStat.isDirectory()) {
         res.status(400).json({ error: "Expected directory path." });
         return;
@@ -16046,7 +16309,7 @@ function createServer(options = {}) {
       return;
     }
     try {
-      const fileStat = await stat17(localPath);
+      const fileStat = await stat18(localPath);
       if (!fileStat.isFile()) {
         res.status(400).json({ error: "Expected file path." });
         return;
@@ -16066,7 +16329,7 @@ function createServer(options = {}) {
       return;
     }
     try {
-      const fileStat = await stat17(localPath);
+      const fileStat = await stat18(localPath);
       res.setHeader("Cache-Control", "private, no-store");
       if (fileStat.isDirectory()) {
         const html = await createDirectoryListingHtml(localPath, { newProjectName });
@@ -16089,7 +16352,7 @@ function createServer(options = {}) {
       return;
     }
     try {
-      const fileStat = await stat17(localPath);
+      const fileStat = await stat18(localPath);
       if (!fileStat.isFile()) {
         res.status(400).json({ error: "Expected file path." });
         return;
@@ -16113,7 +16376,7 @@ function createServer(options = {}) {
     }
     const body = typeof req.body === "string" ? req.body : "";
     try {
-      await writeFile17(localPath, body, "utf8");
+      await writeFile18(localPath, body, "utf8");
       res.status(200).json({ ok: true });
     } catch {
       res.status(404).json({ error: "File not found." });
@@ -16192,10 +16455,10 @@ var program = new Command().name("codex-mobile-re").description("Web interface f
 var __dirname2 = dirname13(fileURLToPath2(import.meta.url));
 var hasPromptedCloudflaredInstall = false;
 function getCodexHomePath() {
-  return process.env.CODEX_HOME?.trim() || join31(homedir11(), ".codex");
+  return process.env.CODEX_HOME?.trim() || join32(homedir11(), ".codex");
 }
 function getCloudflaredPromptMarkerPath() {
-  return join31(getCodexHomePath(), ".cloudflared-install-prompted");
+  return join32(getCodexHomePath(), ".cloudflared-install-prompted");
 }
 function hasPromptedCloudflaredInstallPersisted() {
   return existsSync14(getCloudflaredPromptMarkerPath());
@@ -16203,12 +16466,12 @@ function hasPromptedCloudflaredInstallPersisted() {
 async function persistCloudflaredInstallPrompted() {
   const codexHome = getCodexHomePath();
   mkdirSync2(codexHome, { recursive: true });
-  await writeFile18(getCloudflaredPromptMarkerPath(), `${Date.now()}
+  await writeFile19(getCloudflaredPromptMarkerPath(), `${Date.now()}
 `, "utf8");
 }
 async function readCliVersion() {
   try {
-    const packageJsonPath = join31(__dirname2, "..", "package.json");
+    const packageJsonPath = join32(__dirname2, "..", "package.json");
     const raw = await readFile19(packageJsonPath, "utf8");
     const parsed = JSON.parse(raw);
     return typeof parsed.version === "string" ? parsed.version : "unknown";
@@ -16233,7 +16496,7 @@ function resolveCloudflaredCommand() {
   if (canRunCommand("cloudflared", ["--version"])) {
     return "cloudflared";
   }
-  const localCandidate = join31(homedir11(), ".local", "bin", "cloudflared");
+  const localCandidate = join32(homedir11(), ".local", "bin", "cloudflared");
   if (existsSync14(localCandidate) && canRunCommand(localCandidate, ["--version"])) {
     return localCandidate;
   }
@@ -16287,9 +16550,9 @@ async function ensureCloudflaredInstalledLinux() {
   if (!mappedArch) {
     throw new Error(`cloudflared auto-install is not supported for Linux architecture: ${process.arch}`);
   }
-  const userBinDir = join31(homedir11(), ".local", "bin");
+  const userBinDir = join32(homedir11(), ".local", "bin");
   mkdirSync2(userBinDir, { recursive: true });
-  const destination = join31(userBinDir, "cloudflared");
+  const destination = join32(userBinDir, "cloudflared");
   const downloadUrl = `https://github.com/cloudflare/cloudflared/releases/latest/download/cloudflared-linux-${mappedArch}`;
   console.log("\ncloudflared not found. Installing to ~/.local/bin...\n");
   await downloadFile(downloadUrl, destination);
@@ -16340,7 +16603,7 @@ async function resolveCloudflaredForTunnel() {
 }
 function hasCodexAuth() {
   const codexHome = getCodexHomePath();
-  return existsSync14(join31(codexHome, "auth.json"));
+  return existsSync14(join32(codexHome, "auth.json"));
 }
 function ensureCodexInstalled() {
   let codexCommand = resolveCodexCommand();
@@ -16396,13 +16659,13 @@ function resolvePassword(input) {
   return { password: generatePassword(), generated: true };
 }
 function getGeneratedPasswordPath() {
-  return join31(getCodexHomePath(), "codexui-password");
+  return join32(getCodexHomePath(), "codexui-password");
 }
 async function persistGeneratedPassword(password) {
   const codexHome = getCodexHomePath();
   mkdirSync2(codexHome, { recursive: true });
   const passwordPath = getGeneratedPasswordPath();
-  await writeFile18(passwordPath, `${password}
+  await writeFile19(passwordPath, `${password}
 `, { encoding: "utf8", mode: 384 });
   chmodSync2(passwordPath, 384);
   return passwordPath;
@@ -16541,7 +16804,7 @@ function listenWithFallback(server, startPort) {
 }
 function getCodexGlobalStatePath2() {
   const codexHome = getCodexHomePath();
-  return join31(codexHome, ".codex-global-state.json");
+  return join32(codexHome, ".codex-global-state.json");
 }
 function normalizeUniqueStrings(value) {
   if (!Array.isArray(value)) return [];
@@ -16558,7 +16821,7 @@ async function persistLaunchProject(projectPath) {
   const trimmed = projectPath.trim();
   if (!trimmed) return;
   const normalizedPath = isAbsolute13(trimmed) ? trimmed : resolve8(trimmed);
-  const directoryInfo = await stat18(normalizedPath);
+  const directoryInfo = await stat19(normalizedPath);
   if (!directoryInfo.isDirectory()) {
     throw new Error(`Not a directory: ${normalizedPath}`);
   }
@@ -16583,7 +16846,7 @@ async function persistLaunchProject(projectPath) {
     normalizedPath,
     ...activeRoots.filter((value) => value !== normalizedPath)
   ];
-  await writeFile18(statePath, JSON.stringify(payload), "utf8");
+  await writeFile19(statePath, JSON.stringify(payload), "utf8");
 }
 async function addProjectOnly(projectPath) {
   const trimmed = projectPath.trim();