test(server): isolate timeline fetch responsiveness from runner work (#8197)

* test(server): isolate timeline fetch responsiveness from runner work

Measure the existing cold tail workload in a separate process after fixture collection. Keep the 50ms gate and row assertions, and reproduce unrelated callback CPU contaminating the old measurement.

* test(server): keep timeline probe private and exercise overlapping CPU

---------

Co-authored-by: paseo-bot[bot] <266920839+paseo-bot[bot]@users.noreply.github.com>

docs/unistyles.md

@@ -358,6 +358,14 @@ export to `src`, but browser and Electron Metro resolve its `browser` export to
 `lib/module`; CommonJS consumers use `lib/commonjs`. A source-only patch leaves
 Electron running the old code.
 
+The adaptive-theme patch keeps `colorScheme` reads off the media-query lists
+owned by Unistyles' change listeners. Chromium defers their events while a window
+is hidden; reading `matches` on those same lists can consume the pending change.
+CSS variables then follow the OS theme while `withUnistyles` props retain the old
+colors. Keep this patch until upstream reads the scheme through separate lists.
+The desktop browser E2E checks both transition directions in an isolated Electron
+process, because Playwright's focus emulation prevents real hidden-page behavior.
+
 Register every dependency patch in `scripts/postinstall-patches.mjs`. A file in
 `patches/` is inert unless that script knows which installed package activates
 it.

packages/desktop/e2e/appearance-theme.electron.mjs

@@ -0,0 +1,158 @@
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import electronPath from "electron";
+import { build } from "esbuild";
+
+export async function runAdaptiveThemeRegression(artifactDir) {
+  const { outputFiles } = await build({
+    stdin: {
+      resolveDir: fileURLToPath(new URL("../../app", import.meta.url)),
+      contents: `
+        import { createElement } from "react";
+        import { createRoot } from "react-dom/client";
+        import { StyleSheet, UnistylesRuntime, withUnistyles } from "react-native-unistyles";
+        StyleSheet.configure({
+          themes: {
+            dark: { foreground: "#fafafa", background: "#181b1a" },
+            light: { foreground: "#1a1a1e", background: "#ffffff" },
+          },
+          settings: { adaptiveThemes: true },
+        });
+        const Message = withUnistyles(({ color }) =>
+          createElement("p", { style: { color } }, "Theme-reactive message"));
+        createRoot(document.getElementById("root")).render(createElement(Message, {
+          style: { margin: 0 },
+          uniProps: theme => ({ color: theme.foreground }),
+        }));
+        window.readThemeForTest = () => UnistylesRuntime.themeName;
+      `,
+    },
+    bundle: true,
+    write: false,
+    format: "iife",
+    platform: "browser",
+    alias: { "react-native": "react-native-web" },
+    define: { __DEV__: "false" },
+    resolveExtensions: [".web.js", ".js", ".json"],
+  });
+  const directory = await fs.mkdtemp(path.join(os.tmpdir(), "paseo-adaptive-theme-"));
+  try {
+    await fs.writeFile(path.join(directory, "renderer.js"), outputFiles[0].text);
+    await fs.writeFile(path.join(directory, "main.cjs"), `(${electronRegression.toString()})()`);
+    // A separate process avoids Playwright's focus emulation, which keeps hidden pages visible.
+    const env = { ...process.env };
+    delete env.ELECTRON_RUN_AS_NODE;
+    const args = [
+      ...(process.platform === "linux" ? ["--no-sandbox"] : []),
+      path.join(directory, "main.cjs"),
+      artifactDir,
+    ];
+    const command = process.platform === "linux" ? "xvfb-run" : electronPath;
+    const commandArgs =
+      process.platform === "linux"
+        ? ["-a", "--server-args=-screen 0 1280x800x24", electronPath, ...args]
+        : args;
+    await promisify(execFile)(command, commandArgs, {
+      env,
+      timeout: 30_000,
+    });
+    return JSON.parse(await fs.readFile(path.join(artifactDir, "adaptive-theme.json"), "utf8"));
+  } finally {
+    await fs.rm(directory, { recursive: true, force: true });
+  }
+}
+
+async function electronRegression() {
+  const { app, BrowserWindow, nativeTheme } = require("electron");
+  const assert = require("node:assert/strict");
+  const files = require("node:fs");
+  const paths = require("node:path");
+  const { setTimeout: delay } = require("node:timers/promises");
+  app.setPath("userData", paths.join(__dirname, "profile"));
+  app.on("window-all-closed", () => {});
+  // Electron keeps Linux's --no-sandbox in argv; the artifact directory is always last.
+  const artifactDir = process.argv.at(-1);
+  let window;
+  const observations = [];
+  const colors = {
+    dark: { foreground: "rgb(250, 250, 250)", background: "rgb(24, 27, 26)" },
+    light: { foreground: "rgb(26, 26, 30)", background: "rgb(255, 255, 255)" },
+  };
+  async function read(expression) {
+    return window.webContents.executeJavaScript(expression);
+  }
+  async function expectValue(expression, expected) {
+    let actual;
+    for (let attempt = 0; attempt < 50; attempt++) {
+      actual = await read(expression);
+      if (actual === expected) return;
+      await delay(50);
+    }
+    assert.equal(actual, expected, expression);
+  }
+  try {
+    await app.whenReady();
+    if (process.platform === "darwin") {
+      app.setActivationPolicy("accessory");
+      app.dock.hide();
+    }
+    for (const [from, to] of [
+      ["dark", "light"],
+      ["light", "dark"],
+    ]) {
+      nativeTheme.themeSource = from;
+      window = new BrowserWindow({ width: 600, height: 200, show: false, skipTaskbar: true });
+      await window.loadURL(
+        "data:text/html," +
+          encodeURIComponent(`<!doctype html>
+        <style>body { background: var(--background); } p { font: 20px system-ui; }</style>
+        <div id="root"></div>`),
+      );
+      await read(files.readFileSync(paths.join(__dirname, "renderer.js"), "utf8"));
+      window.showInactive();
+      const foreground =
+        "document.querySelector('p') && getComputedStyle(document.querySelector('p')).color";
+      const background = "getComputedStyle(document.body).backgroundColor";
+      await expectValue(foreground, colors[from].foreground);
+      await expectValue(background, colors[from].background);
+      window.hide();
+      await expectValue("document.visibilityState", "hidden");
+      nativeTheme.themeSource = to;
+      await expectValue(`matchMedia('(prefers-color-scheme: ${to})').matches`, true);
+      // Reading the public runtime while hidden must not consume the pending theme notification.
+      assert.equal(await read("window.readThemeForTest()"), to);
+      window.showInactive();
+      await expectValue("document.visibilityState", "visible");
+      await expectValue(background, colors[to].background);
+      try {
+        await expectValue(foreground, colors[to].foreground);
+      } finally {
+        files.writeFileSync(
+          paths.join(artifactDir, `theme-${from}-to-${to}.png`),
+          (await window.webContents.capturePage()).toPNG(),
+        );
+      }
+      observations.push({
+        from,
+        to,
+        foreground: await read(foreground),
+        background: await read(background),
+      });
+      window.destroy();
+      window = undefined;
+    }
+    files.writeFileSync(
+      paths.join(artifactDir, "adaptive-theme.json"),
+      JSON.stringify(observations, null, 2),
+    );
+    app.exit(0);
+  } catch (error) {
+    console.error(error);
+    window?.destroy();
+    app.exit(1);
+  }
+}

packages/desktop/e2e/browser-tabs.e2e.mjs

@@ -14,6 +14,7 @@ import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/
 import { chromium } from "playwright";
 import { hideDeveloperToasts } from "../../app/e2e/support/developer-ui.mjs";
 import { runAppearanceFontSizeRegression } from "./appearance-font-size.electron.mjs";
+import { runAdaptiveThemeRegression } from "./appearance-theme.electron.mjs";
 import { runSettingsScrollRegression } from "./settings-scroll.electron.mjs";
 import { runSettingsMemoryRegression } from "./settings-memory.electron.mjs";
 
@@ -1241,6 +1242,7 @@ async function main() {
       return;
     }
 
+    const adaptiveTheme = await runAdaptiveThemeRegression(artifactDir);
     await runAppearanceFontSizeRegression(page);
 
     const callerAgentId = await createCallerAgent(daemonPort);
@@ -1265,7 +1267,12 @@ async function main() {
       artifactDir,
     });
     const pluginLinks = await checkPluginLinks();
-    writeJson(path.join(artifactDir, "result.json"), { ...report, settingsMemory, pluginLinks });
+    writeJson(path.join(artifactDir, "result.json"), {
+      ...report,
+      settingsMemory,
+      pluginLinks,
+      adaptiveTheme,
+    });
     console.log(
       `Browser desktop browser E2E passed: WebContents ${report.originalWebContentsId} remained ${report.finalWebContentsId}; viewport, inactive capture, focus continuity, list, snapshot, click, local-page selectors passed.`,
     );

packages/server/scripts/reproduce-codex-history-string-limit.mts

@@ -1,108 +0,0 @@
-// Opt-in diagnostic for #3905. Run from the repository root:
-// node --import tsx packages/server/scripts/reproduce-codex-history-string-limit.mts 520 [legacy|paginated]
-// Requires Codex 0.148+ on PATH and approximately 2 GiB of available memory.
-// `paginated` migrates the synthetic rollout with `codex migrate-rollouts` first.
-import { execFileSync, spawn } from "node:child_process";
-import { randomUUID } from "node:crypto";
-import { mkdtemp, mkdir, open, rm } from "node:fs/promises";
-import path from "node:path";
-import pino from "pino";
-import { CodexAppServerAgentSession } from "../src/server/agent/providers/codex-app-server-agent.js";
-
-const megabytes = Number(process.argv[2] ?? "520");
-if (!Number.isSafeInteger(megabytes) || megabytes < 1 || megabytes > 600) {
-  throw new Error("Expected an integer size between 1 and 600 MiB");
-}
-const historyMode = process.argv[3] ?? "legacy";
-if (historyMode !== "legacy" && historyMode !== "paginated") {
-  throw new Error("Expected history mode legacy or paginated");
-}
-const root = await mkdtemp(path.join(process.cwd(), ".codex-history-repro-"));
-const home = path.join(root, "codex-home");
-const now = new Date();
-const timestamp = now.toISOString();
-const threadId = randomUUID();
-const turnId = randomUUID();
-const sessions = path.join(home, "sessions", ...timestamp.slice(0, 10).split("-"));
-await mkdir(sessions, { recursive: true });
-const rollout = await open(
-  path.join(sessions, `rollout-${timestamp.slice(0, 19).replaceAll(":", "-")}-${threadId}.jsonl`),
-  "w",
-);
-async function write(type: string, payload: unknown) {
-  await rollout.write(`${JSON.stringify({ timestamp, type, payload })}\n`);
-}
-await write("session_meta", {
-  id: threadId,
-  timestamp,
-  cwd: root,
-  originator: "codex_cli_rs",
-  cli_version: "0.159.0",
-  source: "cli",
-  model_provider: "openai",
-  history_mode: "legacy",
-});
-await write("event_msg", { type: "task_started", turn_id: turnId, model_context_window: 200000 });
-await write("event_msg", {
-  type: "user_message",
-  message: "Synthetic oversized history",
-  images: [],
-  local_images: [],
-  text_elements: [],
-});
-for (let index = 0; index < megabytes; index++) {
-  await write("event_msg", {
-    type: "agent_message",
-    message: "x".repeat(1024 * 1024),
-    phase: "commentary",
-  });
-}
-await write("event_msg", { type: "task_complete", turn_id: turnId, last_agent_message: "done" });
-await rollout.close();
-if (historyMode === "paginated") {
-  execFileSync("codex", ["migrate-rollouts", "--apply", "--thread", threadId], {
-    env: { ...process.env, CODEX_HOME: home },
-    stdio: "ignore",
-  });
-}
-console.log(
-  `Opening synthetic ${megabytes} MiB ${historyMode} history through the real Codex app-server`,
-);
-const session = new CodexAppServerAgentSession(
-  { provider: "codex", cwd: root },
-  { sessionId: threadId },
-  pino({ level: "silent" }),
-  async () =>
-    spawn(
-      "codex",
-      ["app-server", "--disable", "plugins", "--disable", "apps", "--disable", "remote_plugin"],
-      {
-        stdio: ["pipe", "pipe", "pipe"],
-        env: { ...process.env, CODEX_HOME: home },
-      },
-    ),
-  { codexHome: home },
-  false,
-  false,
-  false,
-  undefined,
-  "history",
-);
-try {
-  await session.connect();
-  let count = 0;
-  for await (const event of session.streamHistory()) {
-    if (event.type !== "timeline") continue;
-    count++;
-    if (event.item.type === "notification") console.log(event.item.message);
-  }
-  console.log(`History loaded: ${count} timeline rows`);
-} catch (error) {
-  // A recoverable session error is acceptable for the crash-isolation assertion.
-  console.log(
-    `History rejected without crashing: ${error instanceof Error ? error.message : String(error)}`,
-  );
-} finally {
-  await session.close();
-  await rm(root, { recursive: true, force: true, maxRetries: 10, retryDelay: 100 });
-}

packages/server/src/server/agent/agent-timeline-store.test.ts

@@ -1,4 +1,6 @@
-import { measureMainThreadWork } from "../../test-utils/main-thread-work.js";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { fileURLToPath } from "node:url";
 import { describe, expect, it } from "vitest";
 import { selectReferenceProjectedTimelinePage } from "./test-utils/timeline-page-reference.js";
 import type { AgentTimelineItem } from "./agent-sdk-types.js";
@@ -251,23 +253,52 @@ it("includes transitive tool updates in a contiguous projected tail", () => {
   expect(tail).toMatchObject({ startSeq: 1, endSeq: 6, hasOlder: false });
 });
 
+async function measureTimelineTail(wholeTurns: boolean) {
+  const fixture = fileURLToPath(
+    new URL("./test-utils/timeline-responsiveness.ts", import.meta.url),
+  );
+  const { stdout, stderr } = await promisify(execFile)(
+    process.execPath,
+    ["--expose-gc", "--import", "tsx", fixture, String(wholeTurns)],
+    { timeout: 15_000 },
+  );
+  process.stderr.write(stderr);
+  return JSON.parse(stdout) as {
+    result: ReturnType<InMemoryAgentTimelineStore["fetch"]>;
+    blockingMs: number;
+  };
+}
+
+it("excludes unrelated test-runner CPU from the timeline fetch budget", async () => {
+  let unrelatedWork: ReturnType<typeof setImmediate>;
+  const burnCpu = () => {
+    const threadCpuUsage: (previous?: NodeJS.CpuUsage) => NodeJS.CpuUsage = Reflect.get(
+      process,
+      "threadCpuUsage",
+    );
+    const start = threadCpuUsage();
+    let elapsed: NodeJS.CpuUsage;
+    do {
+      elapsed = threadCpuUsage(start);
+    } while (elapsed.user + elapsed.system < 80_000);
+    unrelatedWork = setImmediate(burnCpu);
+  };
+  unrelatedWork = setImmediate(burnCpu);
+  try {
+    const { result: tail, blockingMs } = await measureTimelineTail(false);
+    expect(tail.rows).toHaveLength(200);
+    expect(tail.startSeq).toBe(99_801);
+    expect(tail.endSeq).toBe(100_000);
+    expect(blockingMs).toBeLessThan(50);
+  } finally {
+    clearImmediate(unrelatedWork);
+  }
+});
+
 it.each([false, true])(
   "serves tail 200 from 100,000 retained rows without stalling the loop (wholeTurns=%s)",
   async (wholeTurns) => {
-    const store = new InMemoryAgentTimelineStore();
-    store.initialize("large");
-    for (let index = 0; index < 100_000; index++) {
-      store.append("large", { type: "user_message", text: String(index) });
-    }
-    const { result: tail, blockingMs } = await measureMainThreadWork(
-      `timeline tail main-thread work (wholeTurns=${wholeTurns})`,
-      () => {
-        let page = store.fetch("large", { limit: 200, wholeTurns });
-        for (let repeat = 1; repeat < 8; repeat++)
-          page = store.fetch("large", { limit: 200, wholeTurns });
-        return page;
-      },
-    );
+    const { result: tail, blockingMs } = await measureTimelineTail(wholeTurns);
     expect(tail.rows).toHaveLength(200);
     expect(tail.startSeq).toBe(99_801);
     expect(tail.endSeq).toBe(100_000);

packages/server/src/server/agent/providers/codex-app-server-agent.test.ts

@@ -88,7 +88,6 @@ describe("Codex executable discovery", () => {
 import { CodexAppServerClient } from "./codex/app-server-transport.js";
 import {
   createFakeCodexAppServer,
-  fakeCodexThreadHistory,
   type FakeCodexAppServer,
   waitForNextPermission,
   waitForNextTimelineItem,
@@ -1992,7 +1991,7 @@ describe("Codex app-server provider", () => {
       purpose: "history",
     });
 
-    expect(threadRequests).toEqual(["thread/read", "thread/read"]);
+    expect(threadRequests).toEqual(["thread/read"]);
     await session.close();
     appServer.assertNoErrors();
   });
@@ -2069,7 +2068,6 @@ describe("Codex app-server provider", () => {
         "thread/loaded/list",
         "thread/resume",
         "thread/read",
-        "thread/read",
       ]);
       expect(codex.threadMethods(1)).toEqual(["thread/loaded/list", "thread/resume"]);
       expect(codex.manager.getTimeline(codex.agentId)).toEqual(projected);
@@ -2429,7 +2427,7 @@ describe("Codex app-server provider", () => {
         cwd: "/workspace/project",
         model: "gpt-5.4",
         serviceTier: null,
-        excludeTurns: true,
+        excludeTurns: false,
         persistExtendedHistory: true,
       },
     ]);
@@ -2443,9 +2441,8 @@ describe("Codex app-server provider", () => {
 
   test("rewinds a paginated conversation through the public session capability", async () => {
     const appServer = createFakeCodexAppServer({
-      ...fakeCodexThreadHistory({
-        "thread-1": { historyMode: "paginated", turns: [] },
-        "forked-thread": { historyMode: "paginated", turns: [] },
+      "thread/read": () => ({
+        thread: { id: "thread-1", historyMode: "paginated", turns: [] },
       }),
       "thread/rollback": () => {
         throw new Error("paginated threads do not support thread/rollback");
@@ -2490,7 +2487,7 @@ describe("Codex app-server provider", () => {
         cwd: "/workspace/project",
         model: "gpt-5.4",
         serviceTier: null,
-        excludeTurns: true,
+        excludeTurns: false,
         persistExtendedHistory: true,
       },
     ]);
@@ -2507,10 +2504,11 @@ describe("Codex app-server provider", () => {
     async (historyMode) => {
       const appServer = createFakeCodexAppServer(
         historyMode === "paginated"
-          ? fakeCodexThreadHistory({
-              "thread-1": { historyMode: "paginated", turns: [] },
-              "forked-thread": { historyMode: "paginated", turns: [] },
-            })
+          ? {
+              "thread/read": () => ({
+                thread: { id: "thread-1", historyMode: "paginated", turns: [] },
+              }),
+            }
           : undefined,
       );
       const customCodexConfig = {
@@ -4949,7 +4947,6 @@ describe("Codex app-server provider", () => {
     }
 
     expect(requests.map((request) => [request.method, request.params])).toEqual([
-      ["thread/read", { threadId: "test-thread", includeTurns: false }],
       ["thread/read", { threadId: "test-thread", includeTurns: true }],
     ]);
     expect(history).toEqual([

packages/server/src/server/agent/providers/codex-app-server-agent.ts

@@ -92,18 +92,12 @@ import {
   type CodexAppServerTraceContext,
 } from "./codex/app-server-transport.js";
 import { type CodexUserMessageTurnIndex, revertCodexConversation } from "./codex/rewind.js";
-import {
-  type CodexHistoryRow,
-  CodexThreadHistoryTooLargeError,
-  readCodexThreadHistory,
-} from "./codex/thread-history.js";
 import {
   materializeProviderImage,
   renderProviderImageOutputAsAssistantMarkdown,
   type ProviderImageOutput,
 } from "./provider-image-output.js";
 import { normalizeProviderReplayTimestamp } from "../provider-history-timestamps.js";
-import { limitAgentTimelineItemContent } from "../agent-timeline-content.js";
 import {
   formatProviderDiagnostic,
   formatProviderDiagnosticError,
@@ -1810,13 +1804,22 @@ function readCodexHistoryTimestamp(item: unknown): string | null {
   );
 }
 
-/** Falls back to the row's start time for a user message and its end time otherwise. */
-function readCodexHistoryRowTimestamp(
-  row: CodexHistoryRow,
+function readCodexTurnHistoryTimestamp(
+  turn: unknown,
   timelineItem: AgentTimelineItem,
 ): string | null {
-  const startedAt = normalizeProviderReplayTimestamp(row.startedAt);
-  const completedAt = normalizeProviderReplayTimestamp(row.completedAt);
+  const record = toObjectRecord(turn);
+  if (!record) {
+    return null;
+  }
+
+  const startedAt =
+    normalizeProviderReplayTimestamp(record.startedAt) ??
+    normalizeProviderReplayTimestamp(record.started_at);
+  const completedAt =
+    normalizeProviderReplayTimestamp(record.completedAt) ??
+    normalizeProviderReplayTimestamp(record.completed_at);
+
   if (timelineItem.type === "user_message") {
     return startedAt ?? completedAt;
   }
@@ -2060,19 +2063,84 @@ async function threadItemToTimelineEntries(
   return [timelineItem, ...(await mcpToolResultImagesToTimeline(item))];
 }
 
+const CodexThreadReadResponseSchema = z
+  .object({
+    thread: z
+      .object({
+        turns: z
+          .array(
+            z
+              .object({
+                items: z.array(z.unknown()).default([]),
+              })
+              .passthrough(),
+          )
+          .default([]),
+      })
+      .passthrough()
+      .default({ turns: [] }),
+  })
+  .passthrough();
+
+type CodexThreadReadResponse = z.infer<typeof CodexThreadReadResponseSchema>;
+type CodexThreadReadRequest = (threadId: string) => Promise<unknown>;
+
+async function requestCodexThreadHistory(
+  requestThread: CodexThreadReadRequest,
+  threadId: string,
+): Promise<CodexThreadReadResponse> {
+  const response = await requestThread(threadId);
+  return CodexThreadReadResponseSchema.parse(response);
+}
+
 async function loadCodexThreadHistoryTimeline(params: {
-  client: CodexAppServerClientLike;
   threadId: string;
   cwd: string | null;
+  requestThread: CodexThreadReadRequest;
 }): Promise<CodexThreadHistoryProjection> {
+  const response = await requestCodexThreadHistory(params.requestThread, params.threadId);
   const timeline: PersistedTimelineEntry[] = [];
   const subAgentTimelineIndexByThreadId = new Map<string, number>();
-  try {
-    await projectCodexThreadHistory(params, { timeline, subAgentTimelineIndexByThreadId });
-  } catch (error) {
-    if (!(error instanceof CodexThreadHistoryTooLargeError)) throw error;
-    // The session stays usable; the row says why the history stops here.
-    timeline.push({ item: { type: "notification", level: "warning", message: error.message } });
+  for (const turn of response.thread.turns) {
+    for (const item of turn.items) {
+      const historicalSubAgentActivity = readCodexSubAgentActivity(item);
+      if (historicalSubAgentActivity) {
+        const existingIndex = subAgentTimelineIndexByThreadId.get(
+          historicalSubAgentActivity.agentThreadId,
+        );
+        if (existingIndex !== undefined) {
+          const activityTimelineItem = await threadItemToTimeline(item, { cwd: params.cwd });
+          updateHistoricalSubAgentActivity(
+            timeline,
+            existingIndex,
+            historicalSubAgentActivity.kind,
+            activityTimelineItem?.type === "tool_call" &&
+              activityTimelineItem.detail.type === "sub_agent"
+              ? activityTimelineItem.detail.subAgentType
+              : undefined,
+          );
+          continue;
+        }
+      }
+      for (const timelineItem of await threadItemToTimelineEntries(item, { cwd: params.cwd })) {
+        const timestamp =
+          readCodexHistoryTimestamp(item) ?? readCodexTurnHistoryTimestamp(turn, timelineItem);
+        const settledTimelineItem =
+          historicalSubAgentActivity && timelineItem.type === "tool_call"
+            ? settleHistoricalSubAgentActivity(timelineItem, historicalSubAgentActivity.kind)
+            : timelineItem;
+        timeline.push({
+          item: settledTimelineItem,
+          timestamp: timestamp ?? undefined,
+          ...(timelineItem.type === "user_message" && typeof turn.id === "string"
+            ? { providerTurnId: turn.id }
+            : {}),
+        });
+        for (const childThreadId of readCodexHistoricalSubAgentThreadIds(item)) {
+          subAgentTimelineIndexByThreadId.set(childThreadId, timeline.length - 1);
+        }
+      }
+    }
   }
   const subAgentRoutes = Array.from(subAgentTimelineIndexByThreadId.entries()).flatMap(
     ([childThreadId, timelineIndex]): PersistedSubAgentRoute[] => {
@@ -2085,55 +2153,11 @@ async function loadCodexThreadHistoryTimeline(params: {
   return { timeline, subAgentRoutes };
 }
 
-async function projectCodexThreadHistory(
-  params: { client: CodexAppServerClientLike; threadId: string; cwd: string | null },
-  projection: {
-    timeline: PersistedTimelineEntry[];
-    subAgentTimelineIndexByThreadId: Map<string, number>;
-  },
-): Promise<void> {
-  const { timeline, subAgentTimelineIndexByThreadId } = projection;
-  for await (const row of readCodexThreadHistory(params.client, params.threadId)) {
-    const { item } = row;
-    const historicalSubAgentActivity = readCodexSubAgentActivity(item);
-    if (historicalSubAgentActivity) {
-      const existingIndex = subAgentTimelineIndexByThreadId.get(
-        historicalSubAgentActivity.agentThreadId,
-      );
-      if (existingIndex !== undefined) {
-        const activityTimelineItem = await threadItemToTimeline(item, { cwd: params.cwd });
-        updateHistoricalSubAgentActivity(
-          timeline,
-          existingIndex,
-          historicalSubAgentActivity.kind,
-          activityTimelineItem?.type === "tool_call" &&
-            activityTimelineItem.detail.type === "sub_agent"
-            ? activityTimelineItem.detail.subAgentType
-            : undefined,
-        );
-        continue;
-      }
-    }
-    for (const timelineItem of await threadItemToTimelineEntries(item, { cwd: params.cwd })) {
-      const timestamp =
-        readCodexHistoryTimestamp(item) ?? readCodexHistoryRowTimestamp(row, timelineItem);
-      const settledTimelineItem =
-        historicalSubAgentActivity && timelineItem.type === "tool_call"
-          ? settleHistoricalSubAgentActivity(timelineItem, historicalSubAgentActivity.kind)
-          : timelineItem;
-      timeline.push({
-        // Cap each item as it is projected so a large history is never held uncapped.
-        item: limitAgentTimelineItemContent(settledTimelineItem),
-        timestamp: timestamp ?? undefined,
-        ...(timelineItem.type === "user_message" && row.turnId !== undefined
-          ? { providerTurnId: row.turnId }
-          : {}),
-      });
-      for (const childThreadId of readCodexHistoricalSubAgentThreadIds(item)) {
-        subAgentTimelineIndexByThreadId.set(childThreadId, timeline.length - 1);
-      }
-    }
-  }
+function readCodexThread(client: CodexAppServerClientLike, threadId: string): Promise<unknown> {
+  return client.request("thread/read", {
+    threadId,
+    includeTurns: true,
+  });
 }
 
 export async function forkCodexThread(
@@ -3973,9 +3997,9 @@ export class CodexAppServerAgentSession implements AgentSession {
       return { timeline: [], providerSubagentEvents: [] };
     }
     const { timeline, subAgentRoutes } = await loadCodexThreadHistoryTimeline({
-      client,
       threadId: this.currentThreadId,
       cwd: this.config.cwd ?? null,
+      requestThread: (threadIdToRead) => readCodexThread(client, threadIdToRead),
     });
     this.subAgentCallsByCallId.clear();
     this.subAgentCallIdByChildThreadId.clear();
@@ -4031,9 +4055,9 @@ export class CodexAppServerAgentSession implements AgentSession {
       });
       try {
         const childHistory = await loadCodexThreadHistoryTimeline({
-          client,
           threadId: next.route.childThreadId,
           cwd: this.config.cwd ?? null,
+          requestThread: (childThreadId) => readCodexThread(client, childThreadId),
         });
         for (const entry of childHistory.timeline) {
           this.emitProviderSubagentTimeline(next.route.childThreadId, entry.item, entry.timestamp);

packages/server/src/server/agent/providers/codex-history-string-limit.real.e2e.test.ts

@@ -1,53 +0,0 @@
-import { execFile } from "node:child_process";
-import { mkdtemp, rm } from "node:fs/promises";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-import { expect, test } from "vitest";
-
-// Regression for #3905. Real Codex, synthetic on-disk history, no model turns.
-// Opt in because the oversized cases need approximately 2 GiB of memory and over
-// 1 GiB of temporary storage.
-const enabled = process.env.PASEO_CODEX_HISTORY_STRING_LIMIT_REPRO === "1";
-const script = fileURLToPath(
-  new URL("../../../../scripts/reproduce-codex-history-string-limit.mts", import.meta.url),
-);
-
-test.runIf(enabled).each([
-  { megabytes: 2, historyMode: "legacy", expected: "History loaded: 3 timeline rows" },
-  { megabytes: 520, historyMode: "legacy", expected: "codex migrate-rollouts --apply --thread" },
-  { megabytes: 520, historyMode: "paginated", expected: "History loaded: 521 timeline rows" },
-])(
-  "opening $megabytes MiB of $historyMode Codex history does not crash its hosting process",
-  async ({ megabytes, historyMode, expected }) => {
-    const root = await mkdtemp(path.join(process.cwd(), ".codex-history-test-"));
-    try {
-      const result = await new Promise<{ code: number; stdout: string; stderr: string }>(
-        (resolve) => {
-          const child = execFile(
-            process.execPath,
-            ["--import", "tsx", script, String(megabytes), historyMode],
-            {
-              cwd: root,
-              detached: true,
-              timeout: 120_000,
-              maxBuffer: 1024 * 1024,
-            },
-            (error, stdout, stderr) => {
-              try {
-                if (child.pid) process.kill(-child.pid, "SIGKILL");
-              } catch (killError) {
-                if ((killError as NodeJS.ErrnoException).code !== "ESRCH") throw killError;
-              }
-              resolve({ code: error ? Number(error.code ?? 1) : 0, stdout, stderr });
-            },
-          );
-        },
-      );
-      expect(result.code, result.stderr).toBe(0);
-      expect(result.stdout).toContain(expected);
-    } finally {
-      await rm(root, { recursive: true, force: true, maxRetries: 10, retryDelay: 100 });
-    }
-  },
-  180_000,
-);

packages/server/src/server/agent/providers/codex/app-server-transport.test.ts

@@ -185,41 +185,14 @@ describe("Codex app-server transport", () => {
 });
 
 describe("Codex stdout byte admission", () => {
-  test("an oversized response fails only its own request", async () => {
-    const child = createCodexAppServerChildProcess();
-    const client = new CodexAppServerClient(child, createTestLogger());
-    const terminations: Error[] = [];
-    client.setUnexpectedTerminationHandler((error) => terminations.push(error));
-    const oversized = client.request("thread/items/list", {}).catch((error: Error) => error);
-    const other = client.request("model/list", {});
-    const chunk = Buffer.alloc(64 * 1024, "x");
-    child.stdout.write('{"id":1,"result":"');
-    for (let index = 0; index < 2049; index++) child.stdout.write(chunk);
-    child.stdout.write('"}\n{"id":2,"result":{"data":[]}}\n');
-
-    expect(await oversized).toMatchObject({
-      name: "CodexAppServerResponseTooLargeError",
-      method: "thread/items/list",
-      limitBytes: 128 * 1024 * 1024,
-    });
-    await expect(other).resolves.toEqual({ data: [] });
-    const next = client.request("model/list", {});
-    child.stdout.write('{"id":3,"result":{"data":["next"]}}\n');
-    await expect(next).resolves.toEqual({ data: ["next"] });
-    expect(terminations).toEqual([]);
-    await client.dispose();
-    child.stdout.end();
-    child.stderr.end();
-  });
-
-  test("an oversized notification fails pending requests and the session", async () => {
+  test("fails pending requests and the session before joining an oversized line", async () => {
     const child = createCodexAppServerChildProcess();
     const client = new CodexAppServerClient(child, createTestLogger());
     const terminations: Error[] = [];
     client.setUnexpectedTerminationHandler((error) => terminations.push(error));
     const request = client.request("thread/resume", {}, 1000).catch((error: Error) => error);
     const chunk = Buffer.alloc(64 * 1024, "x");
-    child.stdout.write('{"method":"item/completed","params":"');
+    child.stdout.write('{"id":1,"result":"');
     for (let index = 0; index < 2048; index++) child.stdout.write(chunk);
     const error = await request;
     expect(error).toMatchObject({

packages/server/src/server/agent/providers/codex/app-server-transport.ts

@@ -33,26 +33,11 @@ interface JsonRpcNotification {
 }
 
 interface PendingRequest {
-  method: string;
   resolve: (value: unknown) => void;
   reject: (error: Error) => void;
   timer: NodeJS.Timeout;
 }
 
-/** A response past the provider line cap. Only its request fails; the session stays up. */
-export class CodexAppServerResponseTooLargeError extends Error {
-  constructor(
-    readonly method: string,
-    readonly limitBytes: number,
-  ) {
-    super(`Codex app-server response to ${method} exceeds ${limitBytes} bytes`);
-    this.name = "CodexAppServerResponseTooLargeError";
-  }
-}
-
-// Codex serializes a response with `id` first, so its head names the request.
-const OVERSIZED_RESPONSE_HEAD = /^\{"id":(\d+),"result":/;
-
 export class CodexAppServerRpcError extends Error {
   constructor(
     message: string,
@@ -273,7 +258,7 @@ export class CodexAppServerClient {
         this.pending.delete(id);
         reject(new Error(`Codex app-server request timed out for ${method}`));
       }, timeoutMs);
-      this.pending.set(id, { method, resolve, reject, timer });
+      this.pending.set(id, { resolve, reject, timer });
     });
   }
 
@@ -319,21 +304,8 @@ export class CodexAppServerClient {
   }
 
   private handleStreamLimit(failure: ProviderStreamLimitError): void {
-    const responseId = OVERSIZED_RESPONSE_HEAD.exec(failure.lineHead)?.[1];
-    const pending = responseId === undefined ? undefined : this.pending.get(Number(responseId));
-    if (pending) {
-      clearTimeout(pending.timer);
-      this.pending.delete(Number(responseId));
-      this.logger.warn(
-        { method: pending.method, limitBytes: failure.limitBytes },
-        "Codex app-server response exceeded the line cap",
-      );
-      pending.reject(new CodexAppServerResponseTooLargeError(pending.method, failure.limitBytes));
-      return;
-    }
-    // A lost notification or server request cannot be replayed. Fail the session,
+    // A rejected response/notification cannot be replayed safely. Fail the session,
     // including live turns with no pending RPC, rather than dropping a stream unit.
-    this.stdoutLineReader.close();
     this.handleUnexpectedTermination(failure);
     void this.dispose().catch((err) => {
       this.logger.warn({ err }, "Failed to terminate oversized Codex stdout producer");

packages/server/src/server/agent/providers/codex/rewind.test.ts

@@ -108,7 +108,7 @@ describe("Codex Rewind", () => {
         cwd: "/workspace/project",
         model: "gpt-5.4-mini",
         serviceTier: null,
-        excludeTurns: true,
+        excludeTurns: false,
         persistExtendedHistory: true,
       },
     ]);
@@ -190,7 +190,7 @@ describe("Codex Rewind", () => {
         cwd: "/workspace/project",
         model: "gpt-5.4-mini",
         serviceTier: null,
-        excludeTurns: true,
+        excludeTurns: false,
         persistExtendedHistory: true,
       },
     ]);

packages/server/src/server/agent/providers/codex/rewind.ts

@@ -8,7 +8,6 @@ import {
   parseCodexThreadForkResponse,
   parseCodexThreadRollbackResponse,
 } from "./app-server-transport.js";
-import { readCodexThreadHistoryMode } from "./thread-history.js";
 
 export interface CodexRewindClient {
   forkThread?(params: CodexThreadForkParams): Promise<CodexThreadForkResponse>;
@@ -21,6 +20,26 @@ export interface CodexUserMessageTurnIndex {
   count(): number;
 }
 
+type CodexThreadHistoryMode = "legacy" | "paginated";
+
+async function readCodexThreadHistoryMode(
+  client: CodexRewindClient,
+  threadId: string,
+): Promise<CodexThreadHistoryMode> {
+  const response = await client.request("thread/read", { threadId, includeTurns: false });
+  if (typeof response !== "object" || response === null || !("thread" in response)) {
+    throw new Error("Codex thread/read did not return thread metadata");
+  }
+  const thread = response.thread;
+  if (typeof thread !== "object" || thread === null || !("historyMode" in thread)) {
+    return "legacy";
+  }
+  if (thread.historyMode === "legacy" || thread.historyMode === "paginated") {
+    return thread.historyMode;
+  }
+  throw new Error(`Codex thread/read returned unknown history mode ${String(thread.historyMode)}`);
+}
+
 async function forkCodexThread(
   client: CodexRewindClient,
   params: CodexThreadForkParams,
@@ -76,8 +95,7 @@ export async function revertCodexConversation(input: {
     model: input.model ?? null,
     serviceTier: input.serviceTier ?? null,
     ...(input.config ? { config: input.config } : {}),
-    // Paseo re-reads the rewound thread through paged history, not the fork reply.
-    excludeTurns: true,
+    excludeTurns: false,
     persistExtendedHistory: true,
   };
 

packages/server/src/server/agent/providers/codex/test-utils/fake-app-server.ts

@@ -3,10 +3,6 @@ import { EventEmitter } from "node:events";
 import { PassThrough } from "node:stream";
 
 import type { AgentSession, AgentStreamEvent } from "../../../agent-sdk-types.js";
-import { CODEX_PROVIDER_LINE_BYTES } from "../app-server-transport.js";
-
-/** A handler result that the fake writes as a response line past the provider line cap. */
-export const OVERSIZED_RESPONSE = Symbol("oversized Codex response");
 
 type JsonObject = Record<string, unknown>;
 type FakeCodexAppServerHandler = (params: unknown) => unknown;
@@ -233,18 +229,8 @@ export function createFakeCodexAppServer(
       return;
     }
 
-    let response: unknown;
-    try {
-      response = handler(message.params);
-    } catch (error) {
-      response = Promise.reject(error);
-    }
-    Promise.resolve(response)
+    Promise.resolve(handler(message.params))
       .then((result) => {
-        if (result === OVERSIZED_RESPONSE) {
-          writeOversizedResponse(message.id as number);
-          return undefined;
-        }
         const rpcError = toJsonObject(result).__jsonRpcError;
         if (rpcError) {
           child.stdout.write(`${JSON.stringify({ id: message.id, error: rpcError })}\n`);
@@ -327,16 +313,6 @@ export function createFakeCodexAppServer(
     });
   }
 
-  // Codex writes `id` first, then a result past the provider line cap.
-  function writeOversizedResponse(id: number): void {
-    child.stdout.write(`{"id":${id},"result":{"data":[{"item":{"text":"`);
-    const chunk = Buffer.alloc(1024 * 1024, "x");
-    for (let written = 0; written <= CODEX_PROVIDER_LINE_BYTES; written += chunk.byteLength) {
-      child.stdout.write(chunk);
-    }
-    child.stdout.write('"}}]}}\n');
-  }
-
   function writeNotification(method: string, params: JsonObject): void {
     child.stdout.write(`${JSON.stringify({ method, params })}\n`);
   }
@@ -720,81 +696,3 @@ export function waitForProviderSubagent(
 ): Promise<ProviderSubagentEvent> {
   return waitForNextEvent(session, "provider_subagent", (event) => event.event.id === id);
 }
-
-export interface FakeCodexHistoryTurn {
-  id: string;
-  startedAt?: number;
-  completedAt?: number;
-  items: JsonObject[];
-}
-
-export interface FakeCodexHistoryThread {
-  /** Omitted on Codex builds older than 0.143, which only have legacy history. */
-  historyMode?: "legacy" | "paginated";
-  turns: FakeCodexHistoryTurn[];
-}
-
-export interface FakeCodexHistoryOptions {
-  /** Any response carrying one of these items is written past the line cap. */
-  oversizedItemIds?: string[];
-}
-
-/**
- * Codex's persisted thread history: `thread/read` for metadata and legacy full
- * reads, `thread/items/list` for paginated threads. Paginated threads reject
- * the full read as Codex 0.145 and 0.146 do.
- */
-export function fakeCodexThreadHistory(
-  threads: Record<string, FakeCodexHistoryThread>,
-  options: FakeCodexHistoryOptions = {},
-): Record<string, FakeCodexAppServerHandler> {
-  const oversizedItemIds = new Set(options.oversizedItemIds ?? []);
-  const isOversized = (items: JsonObject[]) =>
-    items.some((item) => oversizedItemIds.has(String(item.id)));
-
-  function readThread(params: unknown): { id: string; thread: FakeCodexHistoryThread } {
-    const id = String(toJsonObject(params).threadId);
-    const thread = threads[id];
-    if (!thread) throw new Error(`thread not found: ${id}`);
-    return { id, thread };
-  }
-
-  return {
-    "thread/read": (params) => {
-      const { id, thread } = readThread(params);
-      if (!toJsonObject(params).includeTurns) {
-        return {
-          thread: { id, ...(thread.historyMode ? { historyMode: thread.historyMode } : {}) },
-        };
-      }
-      if (thread.historyMode === "paginated") {
-        throw new Error("paginated threads do not support thread/read(includeTurns=true)");
-      }
-      if (isOversized(thread.turns.flatMap((turn) => turn.items))) return OVERSIZED_RESPONSE;
-      return { thread: { id, turns: thread.turns } };
-    },
-    "thread/items/list": (params) => {
-      const { thread } = readThread(params);
-      if (thread.historyMode !== "paginated") {
-        throw new Error("thread/items/list is not supported for legacy threads");
-      }
-      const request = toJsonObject(params);
-      // Codex records each item's own times; the fake gives every item its turn's.
-      const rows = thread.turns.flatMap((turn) =>
-        turn.items.map((item) => ({
-          turnId: turn.id,
-          item,
-          startedAtMs: turn.startedAt === undefined ? null : turn.startedAt * 1000,
-          completedAtMs: turn.completedAt === undefined ? null : turn.completedAt * 1000,
-        })),
-      );
-      const limit = Math.min(typeof request.limit === "number" ? request.limit : 25, 100);
-      const start =
-        typeof request.cursor === "string" ? Number(request.cursor.slice("cursor-".length)) : 0;
-      const end = Math.min(rows.length, start + limit);
-      const data = rows.slice(start, end);
-      if (isOversized(data.map((row) => row.item))) return OVERSIZED_RESPONSE;
-      return { data, nextCursor: end < rows.length ? `cursor-${end}` : null };
-    },
-  };
-}

packages/server/src/server/agent/providers/codex/thread-history.test.ts

@@ -1,220 +0,0 @@
-import type { ChildProcessWithoutNullStreams } from "node:child_process";
-import { describe, expect, test } from "vitest";
-
-import { createTestLogger } from "../../../../test-utils/test-logger.js";
-import type { AgentSession, AgentStreamEvent } from "../../agent-sdk-types.js";
-import { CodexAppServerAgentClient } from "../codex-app-server-agent.js";
-import {
-  createFakeCodexAppServer,
-  type FakeCodexAppServer,
-  type FakeCodexHistoryOptions,
-  type FakeCodexHistoryThread,
-  fakeCodexThreadHistory,
-} from "./test-utils/fake-app-server.js";
-
-function userItem(id: string, text: string) {
-  return { type: "userMessage", id, content: [{ type: "text", text }] };
-}
-
-function agentItem(id: string, text: string) {
-  return { type: "agentMessage", id, text };
-}
-
-async function openCodexThread(
-  thread: FakeCodexHistoryThread,
-  options?: FakeCodexHistoryOptions,
-): Promise<{ appServer: FakeCodexAppServer; session: AgentSession }> {
-  const appServer = createFakeCodexAppServer(
-    fakeCodexThreadHistory({ "saved-thread": thread }, options),
-  );
-  const provider = new CodexAppServerAgentClient(createTestLogger());
-  const internals = provider as unknown as {
-    goalsEnabledPromise: Promise<boolean> | null;
-    autoReviewEnabledPromise: Promise<boolean> | null;
-    spawnAppServer: () => Promise<ChildProcessWithoutNullStreams>;
-  };
-  internals.goalsEnabledPromise = Promise.resolve(false);
-  internals.autoReviewEnabledPromise = Promise.resolve(false);
-  internals.spawnAppServer = async () => appServer.child;
-  const session = await provider.resumeSession({ sessionId: "saved-thread" });
-  return { appServer, session };
-}
-
-async function readHistory(session: AgentSession): Promise<AgentStreamEvent[]> {
-  const events: AgentStreamEvent[] = [];
-  for await (const event of session.streamHistory()) events.push(event);
-  return events;
-}
-
-function timelineItems(events: AgentStreamEvent[]) {
-  return events.flatMap((event) => (event.type === "timeline" ? [event.item] : []));
-}
-
-function historyRequests(appServer: FakeCodexAppServer) {
-  return appServer
-    .requests()
-    .filter(
-      (request) =>
-        request.method === "thread/read" ||
-        request.method === "thread/turns/list" ||
-        request.method === "thread/items/list",
-    )
-    .map((request) => ({ method: request.method, params: request.params }));
-}
-
-describe("Codex thread history", () => {
-  test("loads a paginated thread through pages", async () => {
-    const answers = Array.from({ length: 150 }, (_, index) =>
-      agentItem(`agent-${index}`, `Answer ${index}`),
-    );
-    const { appServer, session } = await openCodexThread({
-      historyMode: "paginated",
-      turns: [
-        {
-          id: "turn-1",
-          startedAt: 1_778_832_941,
-          completedAt: 1_778_833_000,
-          items: [userItem("user-1", "First"), ...answers.slice(0, 120)],
-        },
-        {
-          id: "turn-2",
-          startedAt: 1_778_833_094,
-          completedAt: 1_778_833_100,
-          items: [userItem("user-2", "Second"), ...answers.slice(120)],
-        },
-      ],
-    });
-    try {
-      const events = await readHistory(session);
-
-      expect(timelineItems(events)).toEqual([
-        { type: "user_message", text: "First", messageId: "user-1" },
-        ...answers.slice(0, 120).map((answer) => ({
-          type: "assistant_message",
-          text: answer.text,
-          messageId: answer.id,
-        })),
-        { type: "user_message", text: "Second", messageId: "user-2" },
-        ...answers.slice(120).map((answer) => ({
-          type: "assistant_message",
-          text: answer.text,
-          messageId: answer.id,
-        })),
-      ]);
-      const timestamps = events.flatMap((event) =>
-        event.type === "timeline" ? [event.timestamp] : [],
-      );
-      expect(timestamps[0]).toBe("2026-05-15T08:15:41.000Z");
-      expect(timestamps[1]).toBe("2026-05-15T08:16:40.000Z");
-      expect(timestamps[121]).toBe("2026-05-15T08:18:14.000Z");
-      const requests = historyRequests(appServer);
-      expect(requests).not.toContainEqual(
-        expect.objectContaining({ params: expect.objectContaining({ includeTurns: true }) }),
-      );
-      const itemPages = requests.filter((request) => request.method === "thread/items/list");
-      expect(itemPages.length).toBeGreaterThan(1);
-      for (const page of itemPages) {
-        expect(page.params).toMatchObject({ threadId: "saved-thread", sortDirection: "asc" });
-        expect((page.params as { limit: number }).limit).toBeLessThanOrEqual(100);
-      }
-    } finally {
-      await session.close();
-    }
-    appServer.assertNoErrors();
-  });
-
-  test("loads a paginated thread whose full read Codex 0.145 rejects", async () => {
-    const { appServer, session } = await openCodexThread({
-      historyMode: "paginated",
-      turns: [{ id: "turn-1", items: [userItem("user-1", "Hello"), agentItem("agent-1", "Hi")] }],
-    });
-    try {
-      expect(timelineItems(await readHistory(session))).toEqual([
-        { type: "user_message", text: "Hello", messageId: "user-1" },
-        { type: "assistant_message", text: "Hi", messageId: "agent-1" },
-      ]);
-    } finally {
-      await session.close();
-    }
-    appServer.assertNoErrors();
-  });
-
-  test("a page too big to send shows a warning row and stops loading", async () => {
-    const answers = Array.from({ length: 120 }, (_, index) =>
-      agentItem(`agent-${index}`, `Answer ${index}`),
-    );
-    const { appServer, session } = await openCodexThread(
-      {
-        historyMode: "paginated",
-        turns: [
-          { id: "turn-1", items: [userItem("user-1", "One"), ...answers] },
-          { id: "turn-2", items: [userItem("user-2", "Two"), agentItem("huge", "never sent")] },
-        ],
-      },
-      { oversizedItemIds: ["huge"] },
-    );
-    const loaded = [
-      { type: "user_message", text: "One", messageId: "user-1" },
-      ...answers.slice(0, 99).map((answer) => ({
-        type: "assistant_message",
-        text: answer.text,
-        messageId: answer.id,
-      })),
-      {
-        type: "notification",
-        level: "warning",
-        message: "The rest of this Codex thread's history is too large to load.",
-      },
-    ];
-    try {
-      expect(timelineItems(await readHistory(session))).toEqual(loaded);
-      // The oversized reply failed only its own request; the session still answers.
-      expect(timelineItems(await readHistory(session))).toEqual(loaded);
-    } finally {
-      await session.close();
-    }
-    appServer.assertNoErrors();
-  });
-
-  test("loads a legacy thread that fits in one read", async () => {
-    const { appServer, session } = await openCodexThread({
-      historyMode: "legacy",
-      turns: [{ id: "turn-1", items: [userItem("user-1", "Hello"), agentItem("agent-1", "Hi")] }],
-    });
-    try {
-      expect(timelineItems(await readHistory(session))).toEqual([
-        { type: "user_message", text: "Hello", messageId: "user-1" },
-        { type: "assistant_message", text: "Hi", messageId: "agent-1" },
-      ]);
-      expect(historyRequests(appServer).map((request) => request.method)).not.toContain(
-        "thread/items/list",
-      );
-    } finally {
-      await session.close();
-    }
-    appServer.assertNoErrors();
-  });
-
-  test("a legacy thread too big for one read shows the migration command", async () => {
-    const { appServer, session } = await openCodexThread(
-      {
-        historyMode: "legacy",
-        turns: [{ id: "turn-1", items: [userItem("user-1", "Hello"), agentItem("huge", "x")] }],
-      },
-      { oversizedItemIds: ["huge"] },
-    );
-    const migrationRow = {
-      type: "notification",
-      level: "warning",
-      message: expect.stringContaining("codex migrate-rollouts --apply --thread saved-thread"),
-    };
-    try {
-      expect(timelineItems(await readHistory(session))).toEqual([migrationRow]);
-      // The session stays up for the user to prompt until they archive it to migrate.
-      expect(timelineItems(await readHistory(session))).toEqual([migrationRow]);
-    } finally {
-      await session.close();
-    }
-    appServer.assertNoErrors();
-  });
-});

packages/server/src/server/agent/providers/codex/thread-history.ts

@@ -1,168 +0,0 @@
-import { z } from "zod";
-
-import { CodexAppServerResponseTooLargeError } from "./app-server-transport.js";
-
-// Codex clamps history pages to 100 rows.
-const PAGE_SIZE = 100;
-
-export interface CodexThreadHistoryClient {
-  request(method: string, params?: unknown): Promise<unknown>;
-}
-
-export type CodexThreadHistoryMode = "legacy" | "paginated";
-
-export interface CodexHistoryRow {
-  item: unknown;
-  turnId: string | undefined;
-  /** The item's times on a paginated thread; its turn's on a legacy thread. */
-  startedAt: unknown;
-  completedAt: unknown;
-}
-
-/** A history reply over the line cap; the rows before it were already read. */
-export class CodexThreadHistoryTooLargeError extends Error {
-  constructor(message: string) {
-    super(message);
-    this.name = "CodexThreadHistoryTooLargeError";
-  }
-}
-
-const CodexThreadMetadataSchema = z
-  .object({
-    thread: z.object({ historyMode: z.enum(["legacy", "paginated"]).optional() }).passthrough(),
-  })
-  .passthrough();
-
-const CodexLegacyThreadReadSchema = z
-  .object({
-    thread: z
-      .object({
-        turns: z
-          .array(
-            z
-              .object({
-                id: z.string().optional(),
-                startedAt: z.unknown().optional(),
-                completedAt: z.unknown().optional(),
-                items: z.array(z.unknown()).default([]),
-              })
-              .passthrough(),
-          )
-          .default([]),
-      })
-      .passthrough()
-      .default({ turns: [] }),
-  })
-  .passthrough();
-
-const CodexItemsPageSchema = z
-  .object({
-    data: z.array(
-      z
-        .object({
-          turnId: z.string(),
-          item: z.unknown(),
-          startedAtMs: z.number().nullable().optional(),
-          completedAtMs: z.number().nullable().optional(),
-        })
-        .passthrough(),
-    ),
-    nextCursor: z.string().nullable().optional(),
-  })
-  .passthrough();
-
-/** Codex builds before 0.143 report no history mode; their threads are legacy. */
-export async function readCodexThreadHistoryMode(
-  client: CodexThreadHistoryClient,
-  threadId: string,
-): Promise<CodexThreadHistoryMode> {
-  const response = CodexThreadMetadataSchema.parse(
-    await client.request("thread/read", { threadId, includeTurns: false }),
-  );
-  return response.thread.historyMode ?? "legacy";
-}
-
-/**
- * Reads a thread's persisted items in order. Paginated threads are read in
- * pages; a legacy thread arrives in one `thread/read` reply, as Codex offers
- * no pages for it.
- */
-export async function* readCodexThreadHistory(
-  client: CodexThreadHistoryClient,
-  threadId: string,
-): AsyncGenerator<CodexHistoryRow> {
-  if ((await readCodexThreadHistoryMode(client, threadId)) === "paginated") {
-    yield* readPaginatedHistory(client, threadId);
-  } else {
-    yield* readLegacyHistory(client, threadId);
-  }
-}
-
-async function* readLegacyHistory(
-  client: CodexThreadHistoryClient,
-  threadId: string,
-): AsyncGenerator<CodexHistoryRow> {
-  const response = await requestHistory(
-    client,
-    "thread/read",
-    { threadId, includeTurns: true },
-    `This Codex thread's history is too large to load in one read. ` +
-      `To move it to paginated history, archive this agent, ` +
-      `run \`codex migrate-rollouts --apply --thread ${threadId}\` (Codex 0.148 or newer), ` +
-      `then unarchive the agent.`,
-  );
-  for (const turn of CodexLegacyThreadReadSchema.parse(response).thread.turns) {
-    for (const item of turn.items) {
-      yield { item, turnId: turn.id, startedAt: turn.startedAt, completedAt: turn.completedAt };
-    }
-  }
-}
-
-async function* readPaginatedHistory(
-  client: CodexThreadHistoryClient,
-  threadId: string,
-): AsyncGenerator<CodexHistoryRow> {
-  const seenCursors = new Set<string>();
-  let cursor: string | undefined;
-  for (;;) {
-    const page = CodexItemsPageSchema.parse(
-      await requestHistory(
-        client,
-        "thread/items/list",
-        { threadId, limit: PAGE_SIZE, sortDirection: "asc", cursor },
-        "The rest of this Codex thread's history is too large to load.",
-      ),
-    );
-    for (const row of page.data) {
-      yield {
-        item: row.item,
-        turnId: row.turnId,
-        startedAt: row.startedAtMs,
-        completedAt: row.completedAtMs,
-      };
-    }
-    if (page.nextCursor == null) return;
-    // Codex's own client guards against a cursor that does not advance.
-    if (seenCursors.has(page.nextCursor)) {
-      throw new Error(`Codex repeated history cursor for thread ${threadId}`);
-    }
-    seenCursors.add(page.nextCursor);
-    cursor = page.nextCursor;
-  }
-}
-
-async function requestHistory(
-  client: CodexThreadHistoryClient,
-  method: string,
-  params: unknown,
-  tooLargeMessage: string,
-): Promise<unknown> {
-  try {
-    return await client.request(method, params);
-  } catch (error) {
-    if (error instanceof CodexAppServerResponseTooLargeError) {
-      throw new CodexThreadHistoryTooLargeError(tooLargeMessage);
-    }
-    throw error;
-  }
-}

packages/server/src/server/agent/providers/jsonl-frame-decoder.ts

@@ -1,17 +1,10 @@
 // Provider-process stdout only; these are not app/daemon wire limits.
 export const JSONL_PROVIDER_LINE_BYTES = 64 * 1024 * 1024;
 
-// Enough of an oversized line to read which response it was, e.g. `{"id":12,"result":`.
-const OVERSIZED_LINE_HEAD_BYTES = 64;
-
 export class ProviderStreamLimitError extends Error {
   readonly code = "PROVIDER_STREAM_LINE_TOO_LARGE";
 
-  constructor(
-    readonly limitBytes: number,
-    /** The first bytes of the oversized line; the rest is discarded unread. */
-    readonly lineHead = "",
-  ) {
+  constructor(readonly limitBytes: number) {
     super(
       `Provider stdout line exceeds ${limitBytes} bytes. Start a new thread or reduce the provider response size.`,
     );
@@ -19,26 +12,10 @@ export class ProviderStreamLimitError extends Error {
   }
 }
 
-function readLineHead(parts: Buffer[]): string {
-  const head: Buffer[] = [];
-  let bytes = 0;
-  for (const part of parts) {
-    if (bytes >= OVERSIZED_LINE_HEAD_BYTES) break;
-    head.push(part.subarray(0, OVERSIZED_LINE_HEAD_BYTES - bytes));
-    bytes += head[head.length - 1].byteLength;
-  }
-  return Buffer.concat(head).toString("utf8");
-}
-
-/**
- * Admits raw UTF-8 bytes before retaining, decoding or joining a complete line.
- * An oversized line is reported with its head and skipped up to its newline;
- * the owner closes the reader if the stream cannot continue without it.
- */
+/** Admits raw UTF-8 bytes before retaining, decoding or joining a complete line. */
 export class ProviderLineReader {
   private parts: Buffer[] = [];
   private bytes = 0;
-  private skippingOversizedLine = false;
   private stopped = false;
 
   constructor(
@@ -54,20 +31,11 @@ export class ProviderLineReader {
     while (start < buffer.byteLength && !this.stopped) {
       const newline = buffer.indexOf(10, start);
       const end = newline === -1 ? buffer.byteLength : newline;
-      if (this.skippingOversizedLine) {
-        if (newline === -1) return;
-        this.skippingOversizedLine = false;
-        start = newline + 1;
-        continue;
-      }
       const length = end - start;
       if (length > this.limitBytes - this.bytes) {
-        const head = readLineHead([...this.parts, buffer.subarray(start, end)]);
-        this.parts = [];
-        this.bytes = 0;
-        this.skippingOversizedLine = true;
-        this.onLimit(new ProviderStreamLimitError(this.limitBytes, head));
-        continue;
+        this.close();
+        this.onLimit(new ProviderStreamLimitError(this.limitBytes));
+        return;
       }
       if (length) this.parts.push(buffer.subarray(start, end));
       this.bytes += length;
@@ -182,10 +150,7 @@ export class JsonlFrameDecoder {
       (line) => {
         if (line.trim()) this.consumeLine(line);
       },
-      (error) => {
-        this.lines.close();
-        this.drop("line-too-large", error);
-      },
+      (error) => this.drop("line-too-large", error),
     );
   }
 

packages/server/src/server/agent/test-utils/timeline-responsiveness.ts

@@ -0,0 +1,25 @@
+import { setImmediate as nextTurn } from "node:timers/promises";
+import { measureMainThreadWork } from "../../../test-utils/main-thread-work.js";
+import { InMemoryAgentTimelineStore } from "../agent-timeline-store.js";
+
+// Measure a cold fetch on its own thread, without Vitest reporting or callbacks.
+const wholeTurns = process.argv[2] === "true";
+const store = new InMemoryAgentTimelineStore();
+store.initialize("large");
+for (let index = 0; index < 100_000; index++) {
+  store.append("large", { type: "user_message", text: String(index) });
+}
+// Finish fixture allocation and collect its temporary garbage before measuring.
+globalThis.gc!();
+await nextTurn();
+const measured = await measureMainThreadWork(
+  `timeline tail main-thread work (wholeTurns=${wholeTurns})`,
+  () => {
+    let page = store.fetch("large", { limit: 200, wholeTurns });
+    for (let repeat = 1; repeat < 8; repeat++)
+      page = store.fetch("large", { limit: 200, wholeTurns });
+    return page;
+  },
+);
+
+process.stdout.write(JSON.stringify(measured));

patches/react-native-unistyles+3.2.4.patch

@@ -486,3 +486,74 @@ diff --git a/node_modules/react-native-unistyles/lib/commonjs/core/withUnistyles
        ...(narrowedProps.style ? {
          style: styleSecrets.styles
        } : {}),
+diff --git a/node_modules/react-native-unistyles/lib/commonjs/web/runtime.js b/node_modules/react-native-unistyles/lib/commonjs/web/runtime.js
+index 305fa49..5957aa5 100644
+--- a/node_modules/react-native-unistyles/lib/commonjs/web/runtime.js
++++ b/node_modules/react-native-unistyles/lib/commonjs/web/runtime.js
+@@ -35,10 +35,17 @@ class UnistylesRuntime {
+     return this.darkMedia;
+   }
+   get colorScheme() {
++    // Read the scheme through fresh lists, never through lightMedia/darkMedia. Chromium defers
++    // MediaQueryList change events while the document is hidden and drops the pending event
++    // of any list whose `matches` was read before the document became visible again, which
++    // would silence the adaptive-theme listeners registered on those two lists.
++    if ((0, _utils.isServer)()) {
++      return _types.ColorScheme.Unspecified;
++    }
+     switch (true) {
+-      case this.getLightMedia()?.matches:
++      case window.matchMedia('(prefers-color-scheme: light)').matches:
+         return _types.ColorScheme.Light;
+-      case this.getDarkMedia()?.matches:
++      case window.matchMedia('(prefers-color-scheme: dark)').matches:
+         return _types.ColorScheme.Dark;
+       default:
+         return _types.ColorScheme.Unspecified;
+diff --git a/node_modules/react-native-unistyles/lib/module/web/runtime.js b/node_modules/react-native-unistyles/lib/module/web/runtime.js
+index 7f13a06..c487bee 100644
+--- a/node_modules/react-native-unistyles/lib/module/web/runtime.js
++++ b/node_modules/react-native-unistyles/lib/module/web/runtime.js
+@@ -31,10 +31,17 @@ export class UnistylesRuntime {
+     return this.darkMedia;
+   }
+   get colorScheme() {
++    // Read the scheme through fresh lists, never through lightMedia/darkMedia. Chromium defers
++    // MediaQueryList change events while the document is hidden and drops the pending event
++    // of any list whose `matches` was read before the document became visible again, which
++    // would silence the adaptive-theme listeners registered on those two lists.
++    if (isServer()) {
++      return ColorScheme.Unspecified;
++    }
+     switch (true) {
+-      case this.getLightMedia()?.matches:
++      case window.matchMedia('(prefers-color-scheme: light)').matches:
+         return ColorScheme.Light;
+-      case this.getDarkMedia()?.matches:
++      case window.matchMedia('(prefers-color-scheme: dark)').matches:
+         return ColorScheme.Dark;
+       default:
+         return ColorScheme.Unspecified;
+diff --git a/node_modules/react-native-unistyles/src/web/runtime.ts b/node_modules/react-native-unistyles/src/web/runtime.ts
+index a16dac0..6519858 100644
+--- a/node_modules/react-native-unistyles/src/web/runtime.ts
++++ b/node_modules/react-native-unistyles/src/web/runtime.ts
+@@ -41,8 +41,16 @@ export class UnistylesRuntime {
+     get colorScheme() {
++        // Read the scheme through fresh lists, never through lightMedia/darkMedia. Chromium defers
++        // MediaQueryList change events while the document is hidden and drops the pending event
++        // of any list whose `matches` was read before the document became visible again, which
++        // would silence the adaptive-theme listeners registered on those two lists.
++        if (isServer()) {
++            return ColorScheme.Unspecified
++        }
++
+         switch (true) {
+-            case this.getLightMedia()?.matches:
++            case window.matchMedia('(prefers-color-scheme: light)').matches:
+                 return ColorScheme.Light
+-            case this.getDarkMedia()?.matches:
++            case window.matchMedia('(prefers-color-scheme: dark)').matches:
+                 return ColorScheme.Dark
+             default:
+                 return ColorScheme.Unspecified

scripts/postinstall-patches.mjs

@@ -24,6 +24,7 @@ const patchedPackages = [
   },
   // Registry cleanup: remove after react-native-unistyles ships
   // https://github.com/jpudysz/react-native-unistyles/pull/1203.
+  // Adaptive themes: keep until colorScheme reads no longer consume listener-owned media changes.
   // withUnistyles: also keep the uniProps filter until upstream consumes its control prop.
   {
     nodeModulesPath: "node_modules/react-native-unistyles",