From 6db3ecd72e52d7a53a9c1a6c0795f0bdaddf136d Mon Sep 17 00:00:00 2001
From: Julius Marminge <51714798+juliusmarminge@users.noreply.github.com>
Date: Fri, 30 Oct 2026 01:14:11 -0700
Subject: [PATCH 1/5] feat(web): `vp run stress` loads the app with concurrent
 streaming threads and records how it holds up

Performance work had no way to put the app under realistic concurrent load.
The rig builds the web client, starts an isolated server with the Replay
provider, streams several long threads that stop for approvals, and drives a
busy user in headless Chromium. It records frame times, long animation frames
with their scripts, a CPU profile by module and function, React renders, heap
and DOM growth, and page health into a report for daily runs.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 apps/server/scripts/dev-replay-agent.test.ts  |  11 +-
 apps/server/scripts/dev-replay-agent.ts       |  14 +-
 .../scripts/dev-replay/stressTranscript.ts    | 216 ++++++++++
 apps/web/stress/README.md                     |  25 ++
 apps/web/stress/analyze.ts                    | 117 ++++++
 apps/web/stress/probe.ts                      | 125 ++++++
 apps/web/stress/run.ts                        | 382 ++++++++++++++++++
 knip.jsonc                                    |   6 +-
 package.json                                  |   1 +
 9 files changed, 888 insertions(+), 9 deletions(-)
 create mode 100644 apps/server/scripts/dev-replay/stressTranscript.ts
 create mode 100644 apps/web/stress/README.md
 create mode 100644 apps/web/stress/analyze.ts
 create mode 100644 apps/web/stress/probe.ts
 create mode 100644 apps/web/stress/run.ts

diff --git a/apps/server/scripts/dev-replay-agent.test.ts b/apps/server/scripts/dev-replay-agent.test.ts
index c3abef65161b7..ee322c9f48fbf 100644
--- a/apps/server/scripts/dev-replay-agent.test.ts
+++ b/apps/server/scripts/dev-replay-agent.test.ts
@@ -6,7 +6,12 @@ import * as NodeURL from "node:url";
 
 import { describe, expect, it } from "@effect/vitest";
 
-import { parseReplayTurns, SCENARIOS, streamChunks } from "./dev-replay-agent.ts";
+import {
+  parseReplayTurns,
+  scenarioTranscript,
+  SCENARIOS,
+  streamChunks,
+} from "./dev-replay-agent.ts";
 
 interface AgentMessage {
   readonly id?: number;
@@ -89,8 +94,8 @@ describe("dev replay agent", () => {
     expect(new Set(toolCallIds).size).toBe(6);
   });
 
-  it.each(SCENARIOS)("$id plays a turn without session setup frames", ({ file }) => {
-    const turns = parseReplayTurns(NodeFS.readFileSync(new URL(file, import.meta.url), "utf8"));
+  it.each(SCENARIOS)("$id plays a turn without session setup frames", (scenario) => {
+    const turns = parseReplayTurns(scenarioTranscript(scenario));
     expect(turns.length).toBeGreaterThan(0);
     const updates = turns.flatMap((turn) =>
       turn.frames.flatMap(({ frame }) =>
diff --git a/apps/server/scripts/dev-replay-agent.ts b/apps/server/scripts/dev-replay-agent.ts
index b6eea893ad6b7..68663f5418508 100644
--- a/apps/server/scripts/dev-replay-agent.ts
+++ b/apps/server/scripts/dev-replay-agent.ts
@@ -10,6 +10,8 @@ import * as NodeCrypto from "node:crypto";
 import * as NodeFS from "node:fs";
 import * as NodeReadline from "node:readline";
 
+import { stressTranscript } from "./dev-replay/stressTranscript.ts";
+
 interface LogicalFrame {
   readonly kind: "notification" | "request" | "response";
   readonly method: string;
@@ -64,6 +66,8 @@ export const SCENARIOS = [
     name: "Multi turn",
     file: `${FIXTURES}/multi_turn/registry_transcript.ndjson`,
   },
+  // Generated, so `vp run stress` can load the app without committing a large recording.
+  { id: "stress", name: "Stress", generate: stressTranscript },
 ] as const;
 
 // Session setup and vendor state stay out: they would replace the replay agent's own models.
@@ -94,6 +98,12 @@ function isReplayedFrame(frame: LogicalFrame): boolean {
   return typeof update?.sessionUpdate === "string" && REPLAYED_UPDATES.has(update.sessionUpdate);
 }
 
+export function scenarioTranscript(scenario: (typeof SCENARIOS)[number]): string {
+  return "generate" in scenario
+    ? scenario.generate()
+    : NodeFS.readFileSync(new URL(scenario.file, import.meta.url), "utf8");
+}
+
 /** Splits a recorded transcript into the turns that follow each `session/prompt`. */
 export function parseReplayTurns(ndjson: string): ReadonlyArray<ReplayTurn> {
   const turns: Array<{ frames: Array<ReplayTurn["frames"][number]>; stopReason: string }> = [];
@@ -177,9 +187,7 @@ function runAgent(): void {
     const cached = turnsByScenario.get(scenarioId);
     if (cached !== undefined) return cached;
     const scenario = SCENARIOS.find((candidate) => candidate.id === scenarioId) ?? SCENARIOS[0];
-    const turns = parseReplayTurns(
-      NodeFS.readFileSync(new URL(scenario.file, import.meta.url), "utf8"),
-    );
+    const turns = parseReplayTurns(scenarioTranscript(scenario));
     turnsByScenario.set(scenarioId, turns);
     return turns;
   };
diff --git a/apps/server/scripts/dev-replay/stressTranscript.ts b/apps/server/scripts/dev-replay/stressTranscript.ts
new file mode 100644
index 0000000000000..895e9b95c1522
--- /dev/null
+++ b/apps/server/scripts/dev-replay/stressTranscript.ts
@@ -0,0 +1,216 @@
+/**
+ * A seeded, long transcript for `vp run stress`: every turn thinks, plans, reads, runs a
+ * command with long output, asks to edit, and answers with a long Markdown reply.
+ */
+
+const TURNS = 4;
+const REPLY_SECTIONS = 14;
+
+function seeded(seed: number) {
+  let state = seed >>> 0;
+  return () => {
+    state = (state + 0x6d2b79f5) >>> 0;
+    let t = state;
+    t = Math.imul(t ^ (t >>> 15), t | 1);
+    t ^= t + Math.imul(t ^ (t >>> 7), t | 61);
+    return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+  };
+}
+
+const WORDS =
+  "the timeline renders each row once while the stream appends text so finished blocks keep their layout and the list measures only what grew between frames when a reply streams the sidebar still updates every running thread".split(
+    " ",
+  );
+const FILES = [
+  "apps/web/src/components/ChatMarkdown.tsx",
+  "apps/web/src/components/chat/MessagesTimeline.tsx",
+  "apps/server/src/orchestration-v2/Orchestrator.ts",
+  "packages/client-runtime/src/state/threadDetail.ts",
+  "apps/web/src/components/pullRequest/PullRequestCodeTab.tsx",
+];
+
+function generator(seed: number) {
+  const random = seeded(seed);
+  const pick = <T>(values: ReadonlyArray<T>) => values[Math.floor(random() * values.length)]!;
+  const words = (count: number) => Array.from({ length: count }, () => pick(WORDS)).join(" ");
+  const sentence = () => {
+    const text = words(8 + Math.floor(random() * 14));
+    return `${text[0]!.toUpperCase()}${text.slice(1)}.`;
+  };
+  const paragraph = () =>
+    Array.from({ length: 2 + Math.floor(random() * 4) }, () => {
+      const roll = random();
+      const text = sentence();
+      if (roll < 0.2) return text.replace(/ (\w+) /, " `$1` ");
+      if (roll < 0.35) return text.replace(/ (\w+ \w+) /, " **$1** ");
+      if (roll < 0.45)
+        return `${text} See [${pick(FILES)}](${pick(FILES)}#L${10 + Math.floor(random() * 400)}).`;
+      if (roll < 0.5) return `${text} Details in [the docs](https://example.com/${pick(WORDS)}).`;
+      return text;
+    }).join(" ");
+  const code = () =>
+    [
+      "```ts",
+      ...Array.from({ length: 6 + Math.floor(random() * 14) }, (_, line) =>
+        line % 4 === 0
+          ? `export function ${pick(WORDS)}${line}(input: number): number {`
+          : line % 4 === 3
+            ? "}"
+            : `  return input * ${line} + ${Math.floor(random() * 100)}; // ${words(4)}`,
+      ),
+      "```",
+    ].join("\n");
+  const table = () =>
+    [
+      "| File | Change | Lines |",
+      "| --- | --- | ---: |",
+      ...Array.from(
+        { length: 3 + Math.floor(random() * 5) },
+        () => `| \`${pick(FILES)}\` | ${words(4)} | ${Math.floor(random() * 300)} |`,
+      ),
+    ].join("\n");
+  const list = (ordered: boolean) =>
+    Array.from(
+      { length: 3 + Math.floor(random() * 4) },
+      (_, index) => `${ordered ? `${index + 1}.` : "-"} ${sentence()}`,
+    ).join("\n");
+  const reply = () =>
+    Array.from({ length: REPLY_SECTIONS }, (_, section) =>
+      [
+        `## ${sentence().slice(0, 40)} ${section + 1}`,
+        paragraph(),
+        pick([code, table, () => list(false), () => list(true), () => `> ${sentence()}`])(),
+        paragraph(),
+      ].join("\n\n"),
+    ).join("\n\n");
+  const terminal = () =>
+    Array.from(
+      { length: 120 },
+      (_, line) =>
+        ` ✓ ${pick(FILES).replace(".tsx", ".test.tsx")} (${line} tests) ${Math.floor(random() * 90)}ms`,
+    ).join("\n");
+  return { paragraph, reply, terminal, words };
+}
+
+export function stressTranscript(): string {
+  const lines: Array<unknown> = [
+    { type: "transcript_start", provider: "acpRegistry", scenario: "dev_replay_stress" },
+  ];
+  const update = (value: Record<string, unknown>, afterMs?: number) =>
+    lines.push({
+      type: "emit_inbound",
+      frame: {
+        kind: "notification",
+        method: "session/update",
+        params: { sessionId: "dev-replay-session", update: value },
+      },
+      ...(afterMs === undefined ? {} : { afterMs }),
+    });
+  const plan = (done: number) => ({
+    sessionUpdate: "plan",
+    entries: ["Read the affected files", "Edit the renderer", "Run the tests"].map(
+      (content, index) => ({
+        content,
+        priority: "high",
+        status: index < done ? "completed" : index === done ? "in_progress" : "pending",
+      }),
+    ),
+  });
+  for (let turn = 0; turn < TURNS; turn++) {
+    const text = generator(turn + 1);
+    lines.push({
+      type: "expect_outbound",
+      frame: { kind: "request", method: "session/prompt", params: "<any>" },
+    });
+    update({
+      sessionUpdate: "agent_thought_chunk",
+      content: { type: "text", text: text.paragraph() },
+    });
+    update(plan(0));
+    for (const [index, path] of FILES.slice(0, 3).entries()) {
+      const id = `read-${index}`;
+      update({
+        sessionUpdate: "tool_call",
+        toolCallId: id,
+        kind: "read",
+        title: `Read ${path}`,
+        status: "pending",
+        rawInput: { path: `<workspace>/${path}` },
+      });
+      update({
+        sessionUpdate: "tool_call_update",
+        toolCallId: id,
+        status: "completed",
+        content: [{ type: "content", content: { type: "text", text: text.paragraph() } }],
+      });
+    }
+    update(plan(1));
+    update({
+      sessionUpdate: "agent_message_chunk",
+      content: { type: "text", text: `${text.paragraph()}\n\n` },
+    });
+    const edit = {
+      toolCallId: "edit",
+      kind: "edit",
+      title: `Edit ${FILES[0]}`,
+      rawInput: { path: `<workspace>/${FILES[0]}` },
+    };
+    const diff = {
+      type: "diff",
+      path: `<workspace>/${FILES[0]}`,
+      oldText: `${text.words(30)}\n`,
+      newText: `${text.words(30)}\n${text.words(30)}\n`,
+    };
+    update({ sessionUpdate: "tool_call", ...edit, status: "pending", content: [diff] });
+    lines.push({
+      type: "emit_inbound",
+      frame: {
+        kind: "request",
+        method: "session/request_permission",
+        params: {
+          sessionId: "dev-replay-session",
+          toolCall: edit,
+          options: [
+            { optionId: "allow-once", name: "Yes", kind: "allow_once" },
+            { optionId: "reject-once", name: "No", kind: "reject_once" },
+          ],
+        },
+      },
+    });
+    lines.push({
+      type: "expect_outbound",
+      frame: { kind: "response", method: "session/request_permission", result: "<any>" },
+    });
+    update({
+      sessionUpdate: "tool_call_update",
+      toolCallId: "edit",
+      status: "completed",
+      content: [diff],
+    });
+    update(plan(2));
+    update({
+      sessionUpdate: "tool_call",
+      toolCallId: "test",
+      kind: "execute",
+      title: "vp test run",
+      status: "in_progress",
+      rawInput: { command: "vp test run" },
+    });
+    update(
+      {
+        sessionUpdate: "tool_call_update",
+        toolCallId: "test",
+        status: "completed",
+        content: [{ type: "content", content: { type: "text", text: text.terminal() } }],
+      },
+      1200,
+    );
+    update(plan(3));
+    update({ sessionUpdate: "agent_message_chunk", content: { type: "text", text: text.reply() } });
+    lines.push({
+      type: "emit_inbound",
+      frame: { kind: "response", method: "session/prompt", result: { stopReason: "end_turn" } },
+    });
+  }
+  return lines.map((line) => JSON.stringify(line)).join("\n");
+}
diff --git a/apps/web/stress/README.md b/apps/web/stress/README.md
new file mode 100644
index 0000000000000..e1d1f7b3a897b
--- /dev/null
+++ b/apps/web/stress/README.md
@@ -0,0 +1,25 @@
+# Stress rig
+
+`vp run stress` puts a production build of T3 Code under concurrent load and records how the page holds up. It finds performance work; it is not a CI gate.
+
+## What a run does
+
+1. Builds `apps/web/dist` in production mode without minification, so profiles name real functions. `--skip-build` reuses the last build.
+2. Starts a server on a fresh home in `.t3/stress/home` (never your real data) with the `Replay (dev)` provider and a scratch git project.
+3. Starts `--threads` threads (default 5) on the Replay `stress` scenario, each with `--turns-per-thread` turns queued (default 4). Every turn thinks, plans, reads, asks for an edit approval, prints long terminal output, and streams a long Markdown reply through the server's default paragraph streaming.
+4. Opens headless Chromium, pairs, and for `--duration` seconds (default 60) acts like a busy user: switches threads, approves edits, types in the composer, opens and closes the right panel, and scrolls.
+5. Writes `report.md`, `summary.json`, `profile.cpuprofile` (open in Chrome DevTools), screenshots, and `server.log` to `.t3/stress/runs/<time>` or `--out`.
+
+Background threads stop at their approval until the rig visits them, so the sidebar always holds a mix of streaming, waiting, and settled threads.
+
+## Reading the report
+
+- **Frames over 33 ms** and **long animation frames** are what a user feels. The long-frame scripts table says what ran during them: `dispatchDiscreteEvent` is a click or key handler, `onMessage` is server traffic.
+- **CPU self time by module** splits the profile by package and source file. **By function** points at the hot code.
+- **Most rendered components** counts React renders over the window. A component that renders far more often than what it shows changes is the usual lead.
+- **JS heap** and **DOM nodes** are sampled each step; a climb across the run is a leak or unbounded list.
+- **Health** must stay at zero error boundaries and page errors; console 404s for missing favicons are expected offline.
+
+## Daily use
+
+Run it on `main`, compare `summary.json` with the previous run, and investigate the largest regression or the largest remaining cost: open the profile, confirm the cause in code, fix it, and show the before and after runs in the PR. Numbers are machine-dependent; compare runs from the same machine.
diff --git a/apps/web/stress/analyze.ts b/apps/web/stress/analyze.ts
new file mode 100644
index 0000000000000..df9cd707e10f4
--- /dev/null
+++ b/apps/web/stress/analyze.ts
@@ -0,0 +1,117 @@
+// @effect-diagnostics nodeBuiltinImport:off - a standalone report builder for the stress rig.
+import * as NodeFS from "node:fs";
+import * as NodePath from "node:path";
+
+export interface CpuProfile {
+  readonly nodes: ReadonlyArray<{
+    readonly id: number;
+    readonly callFrame: {
+      readonly functionName: string;
+      readonly url: string;
+      readonly lineNumber: number;
+    };
+    readonly children?: ReadonlyArray<number>;
+  }>;
+  readonly samples: ReadonlyArray<number>;
+  readonly timeDeltas: ReadonlyArray<number>;
+}
+
+export interface FrameSummary {
+  readonly frames: number;
+  readonly p50Ms: number;
+  readonly p95Ms: number;
+  readonly p99Ms: number;
+  readonly maxMs: number;
+  /** Frames that took longer than two 60 Hz intervals, so at least one frame was dropped. */
+  readonly droppedFrames: number;
+}
+
+const percentile = (sorted: ReadonlyArray<number>, p: number) =>
+  sorted.length === 0 ? 0 : sorted[Math.min(sorted.length - 1, Math.floor(sorted.length * p))]!;
+const round = (value: number) => Math.round(value * 10) / 10;
+
+export function summarizeFrames(frames: ReadonlyArray<number>): FrameSummary {
+  const sorted = frames.toSorted((a, b) => a - b);
+  return {
+    frames: frames.length,
+    p50Ms: round(percentile(sorted, 0.5)),
+    p95Ms: round(percentile(sorted, 0.95)),
+    p99Ms: round(percentile(sorted, 0.99)),
+    maxMs: round(sorted.at(-1) ?? 0),
+    droppedFrames: frames.filter((frame) => frame > 1000 / 30).length,
+  };
+}
+
+/** Total long-animation-frame script time by script, worst first. */
+export function longFrameScripts(
+  longFrames: ReadonlyArray<{
+    readonly scripts: ReadonlyArray<{ readonly source: string; readonly duration: number }>;
+  }>,
+  top = 15,
+): Array<[string, number]> {
+  const totals = new Map<string, number>();
+  for (const frame of longFrames) {
+    for (const script of frame.scripts) {
+      totals.set(script.source, (totals.get(script.source) ?? 0) + script.duration);
+    }
+  }
+  return [...totals]
+    .map(([source, ms]): [string, number] => [source, Math.round(ms)])
+    .sort((a, b) => b[1] - a[1])
+    .slice(0, top);
+}
+
+/** Maps each bundle line to the source module above it, from Rolldown's `// path` comments. */
+function moduleOwners(assetsDir: string): Map<string, string[]> {
+  const owners = new Map<string, string[]>();
+  for (const file of NodeFS.readdirSync(assetsDir).filter((name) => name.endsWith(".js"))) {
+    let current = "(bundle)";
+    owners.set(
+      file,
+      NodeFS.readFileSync(NodePath.join(assetsDir, file), "utf8")
+        .split("\n")
+        .map((line) => {
+          const path = /^\/\/ (\S+\.(?:js|mjs|cjs|ts|tsx))$/.exec(line)?.[1];
+          if (path) {
+            const pkg = /node_modules\/(?:\.pnpm\/[^/]+\/node_modules\/)?((?:@[^/]+\/)?[^/]+)/.exec(
+              path,
+            )?.[1];
+            current = pkg ?? path.replace(/^(?:\.\.\/)+/, "");
+          }
+          return current;
+        }),
+    );
+  }
+  return owners;
+}
+
+/** Self time by function and by source module or package, idle excluded. */
+export function summarizeProfile(profile: CpuProfile, assetsDir: string, top = 25) {
+  const byId = new Map(profile.nodes.map((node) => [node.id, node]));
+  const owners = moduleOwners(assetsDir);
+  const byFunction = new Map<string, number>();
+  const byModule = new Map<string, number>();
+  let busyUs = 0;
+  profile.samples.forEach((id, index) => {
+    const node = byId.get(id);
+    const delta = profile.timeDeltas[index + 1] ?? 0;
+    if (!node || ["(idle)", "(program)"].includes(node.callFrame.functionName)) return;
+    busyUs += delta;
+    const file = node.callFrame.url.split("/").pop() ?? "";
+    const fn = `${node.callFrame.functionName || "(anonymous)"} ${file}:${node.callFrame.lineNumber + 1}`;
+    byFunction.set(fn, (byFunction.get(fn) ?? 0) + delta);
+    const owner =
+      owners.get(file)?.[node.callFrame.lineNumber] ?? (file || node.callFrame.functionName);
+    byModule.set(owner, (byModule.get(owner) ?? 0) + delta);
+  });
+  const ranked = (map: Map<string, number>) =>
+    [...map]
+      .map(([name, us]): [string, number] => [name, Math.round(us / 1000)])
+      .sort((a, b) => b[1] - a[1])
+      .slice(0, top);
+  return {
+    busyMs: Math.round(busyUs / 1000),
+    byFunction: ranked(byFunction),
+    byModule: ranked(byModule),
+  };
+}
diff --git a/apps/web/stress/probe.ts b/apps/web/stress/probe.ts
new file mode 100644
index 0000000000000..cab1fa0c3d9ee
--- /dev/null
+++ b/apps/web/stress/probe.ts
@@ -0,0 +1,125 @@
+/**
+ * Runs in the page before the app (Playwright init script). It records frame intervals, long
+ * animation frames with their scripts, and React commits and component renders through the
+ * DevTools hook, which production React also calls. Read the totals with `window.__stress`.
+ */
+export function installStressProbe(): void {
+  interface Fiber {
+    readonly type: unknown;
+    readonly flags: number;
+    readonly child: Fiber | null;
+    readonly sibling: Fiber | null;
+    readonly alternate: Fiber | null;
+  }
+  const PERFORMED_WORK = 1;
+  const state = {
+    recording: false,
+    frames: [] as number[],
+    longFrames: [] as Array<{
+      start: number;
+      duration: number;
+      blocking: number;
+      scripts: Array<{ source: string; invoker: string; duration: number }>;
+    }>,
+    commits: 0,
+    renders: new Map<string, number>(),
+    errors: [] as string[],
+  };
+
+  const nameOf = (fiber: Fiber): string | null => {
+    const type = fiber.type as {
+      displayName?: string;
+      name?: string;
+      render?: { displayName?: string; name?: string };
+    } | null;
+    if (typeof type === "function" || (typeof type === "object" && type !== null)) {
+      return type.displayName ?? type.name ?? type.render?.displayName ?? type.render?.name ?? null;
+    }
+    return null;
+  };
+  // Skips subtrees React reused untouched, so only components that rendered are counted.
+  const visit = (first: Fiber | null) => {
+    for (let fiber = first; fiber; fiber = fiber.sibling) {
+      const alternate = fiber.alternate;
+      if (alternate && fiber.child === alternate.child && (fiber.flags & PERFORMED_WORK) === 0) {
+        continue;
+      }
+      if (fiber.flags & PERFORMED_WORK && typeof fiber.type !== "string") {
+        const name = nameOf(fiber);
+        if (name) state.renders.set(name, (state.renders.get(name) ?? 0) + 1);
+      }
+      visit(fiber.child);
+    }
+  };
+  Object.assign(window, {
+    __REACT_DEVTOOLS_GLOBAL_HOOK__: {
+      supportsFiber: true,
+      renderers: new Map(),
+      inject: () => 1,
+      checkDCE: () => {},
+      onScheduleFiberRoot: () => {},
+      onCommitFiberUnmount: () => {},
+      onPostCommitFiberRoot: () => {},
+      onCommitFiberRoot: (_id: number, root: { current: Fiber }) => {
+        if (!state.recording) return;
+        state.commits += 1;
+        visit(root.current.child);
+      },
+    },
+  });
+
+  let last = 0;
+  const tick = (now: number) => {
+    if (state.recording && last > 0) state.frames.push(now - last);
+    last = now;
+    requestAnimationFrame(tick);
+  };
+  requestAnimationFrame(tick);
+
+  new PerformanceObserver((list) => {
+    if (!state.recording) return;
+    for (const entry of list.getEntries() as Array<
+      PerformanceEntry & {
+        blockingDuration?: number;
+        scripts?: Array<{
+          sourceURL: string;
+          sourceFunctionName: string;
+          invoker: string;
+          duration: number;
+        }>;
+      }
+    >) {
+      state.longFrames.push({
+        start: entry.startTime,
+        duration: entry.duration,
+        blocking: entry.blockingDuration ?? 0,
+        scripts: (entry.scripts ?? []).map((script) => ({
+          source: `${script.sourceFunctionName || "(anonymous)"} ${script.sourceURL.split("/").pop() ?? ""}`,
+          invoker: script.invoker,
+          duration: script.duration,
+        })),
+      });
+    }
+  }).observe({ type: "long-animation-frame", buffered: false });
+
+  addEventListener("error", (event) => state.errors.push(String(event.message)));
+  addEventListener("unhandledrejection", (event) => state.errors.push(String(event.reason)));
+
+  Object.assign(window, {
+    __stress: {
+      start: () => {
+        state.recording = true;
+      },
+      stop: () => {
+        state.recording = false;
+        return {
+          frames: state.frames,
+          longFrames: state.longFrames,
+          commits: state.commits,
+          renders: Object.fromEntries([...state.renders].sort((a, b) => b[1] - a[1])),
+          errors: state.errors,
+        };
+      },
+    },
+  });
+}
diff --git a/apps/web/stress/run.ts b/apps/web/stress/run.ts
new file mode 100644
index 0000000000000..0685e03b2301c
--- /dev/null
+++ b/apps/web/stress/run.ts
@@ -0,0 +1,382 @@
+// @effect-diagnostics nodeBuiltinImport:off globalConsole:off globalTimers:off - a standalone CLI that drives a browser and a server.
+/**
+ * `vp run stress`: puts a production build of T3 Code under concurrent load and records how
+ * the page holds up. Several Replay threads stream long replies and stop for approvals while
+ * a scripted user switches threads, approves, types, and opens panels. See README.md.
+ */
+import * as NodeChildProcess from "node:child_process";
+import * as NodeFS from "node:fs";
+import * as NodeNet from "node:net";
+import * as NodePath from "node:path";
+import * as NodeUtil from "node:util";
+import { chromium, type Page } from "playwright";
+
+import { longFrameScripts, summarizeFrames, summarizeProfile, type CpuProfile } from "./analyze.ts";
+import { installStressProbe } from "./probe.ts";
+
+const repo = NodePath.resolve(import.meta.dirname, "../../..");
+const webDir = NodePath.join(repo, "apps/web");
+const serverBin = NodePath.join(repo, "apps/server/src/bin.ts");
+const replayAgent = NodePath.join(repo, "apps/server/scripts/dev-replay-agent.ts");
+
+const { values: options } = NodeUtil.parseArgs({
+  options: {
+    threads: { type: "string", default: "5" },
+    duration: { type: "string", default: "60" },
+    "turns-per-thread": { type: "string", default: "4" },
+    out: { type: "string" },
+    "skip-build": { type: "boolean", default: false },
+    headed: { type: "boolean", default: false },
+  },
+});
+const THREADS = Number(options.threads);
+const DURATION_MS = Number(options.duration) * 1000;
+const TURNS_PER_THREAD = Number(options["turns-per-thread"]);
+const runId = new Date().toISOString().replaceAll(":", "-").replace(/\..+/, "");
+const outDir = NodePath.resolve(options.out ?? NodePath.join(repo, ".t3/stress/runs", runId));
+const home = NodePath.join(repo, ".t3/stress/home");
+const log = (message: string) => console.error(`[stress] ${message}`);
+
+const freePort = () =>
+  new Promise<number>((resolve, reject) => {
+    const server = NodeNet.createServer();
+    server.listen(0, "127.0.0.1", () => {
+      const address = server.address();
+      server.close(() =>
+        typeof address === "object" && address
+          ? resolve(address.port)
+          : reject(new Error("no port")),
+      );
+    });
+  });
+
+const t3 = (...args: string[]) =>
+  NodeChildProcess.execFileSync(process.execPath, [serverBin, ...args, "--base-dir", home], {
+    cwd: repo,
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "pipe"],
+  });
+
+function prepareHome(): string {
+  NodeFS.rmSync(home, { recursive: true, force: true });
+  NodeFS.mkdirSync(NodePath.join(home, "userdata"), { recursive: true });
+  // The entry `vp run dev` seeds, written up front because this server runs without a dev URL.
+  NodeFS.writeFileSync(
+    NodePath.join(home, "userdata/settings.json"),
+    JSON.stringify({
+      providerInstances: {
+        devReplay: {
+          driver: "acpRegistry",
+          displayName: "Replay (dev)",
+          config: { source: "local", commandPath: process.execPath, commandArgs: [replayAgent] },
+        },
+      },
+    }),
+  );
+  const workspace = NodePath.join(home, "workspace");
+  NodeFS.mkdirSync(workspace, { recursive: true });
+  NodeFS.writeFileSync(NodePath.join(workspace, "README.md"), "# Stress workspace\n");
+  NodeChildProcess.execFileSync("git", ["init", "-q"], { cwd: workspace });
+  NodeChildProcess.execFileSync("git", ["add", "."], { cwd: workspace });
+  NodeChildProcess.execFileSync(
+    "git",
+    ["-c", "user.name=stress", "-c", "user.email=stress@example.com", "commit", "-qm", "init"],
+    { cwd: workspace },
+  );
+  return workspace;
+}
+
+async function startServer(port: number) {
+  const child = NodeChildProcess.spawn(
+    process.execPath,
+    [serverBin, "serve", "--base-dir", home, "--port", String(port), "--no-browser"],
+    {
+      cwd: repo,
+      stdio: ["ignore", "pipe", "pipe"],
+      env: { ...process.env, NODE_ENV: "production" },
+    },
+  );
+  const serverLog = NodeFS.createWriteStream(NodePath.join(outDir, "server.log"));
+  child.stdout.pipe(serverLog);
+  child.stderr.pipe(serverLog);
+  const pairingUrl = await new Promise<string>((resolve, reject) => {
+    let buffered = "";
+    child.stdout.on("data", (chunk: Buffer) => {
+      buffered += chunk.toString();
+      const match = /Pairing URL: (\S+)/.exec(buffered);
+      if (match) resolve(match[1]!);
+    });
+    child.once("exit", (code) => reject(new Error(`server exited with ${code}; see server.log`)));
+  });
+  return { child, pairingUrl };
+}
+
+// Threads sit in sidebar groups (Working, Settled) that start collapsed.
+async function threadItem(page: Page, title: string) {
+  const item = page.getByRole("treeitem", { name: new RegExp(`${title}\\b`) }).first();
+  // Expanding one group re-renders the tree, so look for the next collapsed group each time.
+  for (let attempt = 0; attempt < 5 && !(await item.isVisible()); attempt++) {
+    const group = page.getByRole("treeitem", { expanded: false }).first();
+    if ((await group.count()) === 0) break;
+    await group.click();
+  }
+  return item;
+}
+
+async function act(page: Page, step: number) {
+  const thread = `Stress ${(step % THREADS) + 1}`;
+  await (await threadItem(page, thread)).click({ timeout: 5000 });
+  await page.waitForTimeout(1500);
+  const approve = page.getByRole("button", { name: "Approve", exact: true });
+  if (await approve.first().isVisible()) await approve.first().click();
+  if (step % 3 === 0) {
+    const composer = page.getByRole("textbox", { name: /^Message/ });
+    await composer.click();
+    await composer.pressSequentially("checking how this behaves under load", { delay: 20 });
+    await composer.press("ControlOrMeta+a");
+    await composer.press("Backspace");
+  }
+  if (step % 4 === 1) {
+    await page.getByRole("button", { name: "Toggle right panel" }).click();
+    await page.waitForTimeout(1000);
+    await page.getByRole("button", { name: "Toggle right panel" }).click();
+  }
+  await page.mouse.wheel(0, step % 2 === 0 ? -1500 : 1500);
+}
+
+async function main() {
+  NodeFS.mkdirSync(outDir, { recursive: true });
+  if (!options["skip-build"]) {
+    log("building the web client (production, unminified for readable profiles)");
+    NodeChildProcess.execFileSync("vp", ["build", "--minify", "false"], {
+      cwd: webDir,
+      stdio: "inherit",
+    });
+  }
+  const workspace = prepareHome();
+  const port = await freePort();
+  const { child, pairingUrl } = await startServer(port);
+  const stopServer = () => {
+    if (child.exitCode === null) child.kill("SIGTERM");
+  };
+  process.once("exit", stopServer);
+  try {
+    t3("project", "add", workspace);
+    const threadIds: string[] = [];
+    for (let index = 1; index <= THREADS; index++) {
+      const started = JSON.parse(
+        t3(
+          "thread",
+          "start",
+          workspace,
+          "Stress turn",
+          "--title",
+          `Stress ${index}`,
+          "--provider",
+          "devReplay",
+          "--model",
+          "stress",
+          "--json",
+        ),
+      ) as { threadId?: string; id?: string };
+      const threadId = started.threadId ?? started.id;
+      if (!threadId) throw new Error(`thread start printed no id for Stress ${index}`);
+      threadIds.push(threadId);
+      for (let turn = 1; turn < TURNS_PER_THREAD; turn++)
+        t3("thread", "send", threadId, "Next stress turn");
+    }
+    log(`${THREADS} threads started with ${TURNS_PER_THREAD} turns each`);
+
+    const browser = await chromium.launch({ headless: !options.headed });
+    const context = await browser.newContext({ viewport: { width: 1440, height: 900 } });
+    const page = await context.newPage();
+    const consoleErrors: string[] = [];
+    page.on("console", (message) => {
+      if (message.type() === "error") consoleErrors.push(message.text().slice(0, 300));
+    });
+    page.on("pageerror", (error) => consoleErrors.push(error.message.slice(0, 300)));
+    await page.addInitScript(installStressProbe);
+    await page.goto(pairingUrl);
+    await page.getByRole("treeitem").first().waitFor({ timeout: 60_000 });
+    await (
+      await threadItem(page, "Stress 1")
+    )
+      .waitFor({ timeout: 30_000 })
+      .catch(async (error: Error) => {
+        await page.screenshot({ path: NodePath.join(outDir, "startup-failure.png") });
+        NodeFS.writeFileSync(
+          NodePath.join(outDir, "startup-failure.txt"),
+          await page.innerText("body"),
+        );
+        throw error;
+      });
+    await page.waitForTimeout(3000);
+
+    const cdp = await context.newCDPSession(page);
+    await cdp.send("Performance.enable");
+    await cdp.send("Profiler.enable");
+    await cdp.send("Profiler.setSamplingInterval", { interval: 1000 });
+    const metrics = async () =>
+      Object.fromEntries(
+        (await cdp.send("Performance.getMetrics")).metrics.map((metric) => [
+          metric.name,
+          metric.value,
+        ]),
+      );
+    const samples: Array<{ atMs: number; heapMb: number; nodes: number }> = [];
+    const before = await metrics();
+    await cdp.send("Profiler.start");
+    await page.evaluate(() =>
+      (window as unknown as { __stress: { start(): void } }).__stress.start(),
+    );
+    const started = Date.now();
+    log(`recording for ${DURATION_MS / 1000}s`);
+    let step = 0;
+    while (Date.now() - started < DURATION_MS) {
+      await act(page, step++).catch((error: Error) =>
+        log(`step ${step} failed: ${error.message.split("\n")[0]}`),
+      );
+      const sample = await metrics();
+      samples.push({
+        atMs: Date.now() - started,
+        heapMb: Math.round((sample.JSHeapUsedSize ?? 0) / 2 ** 20),
+        nodes: sample.Nodes ?? 0,
+      });
+      if (step % 5 === 0)
+        await page.screenshot({ path: NodePath.join(outDir, `step-${step}.png`) });
+    }
+    const probe = (await page.evaluate(() =>
+      (window as unknown as { __stress: { stop(): unknown } }).__stress.stop(),
+    )) as {
+      frames: number[];
+      longFrames: Array<{
+        duration: number;
+        blocking: number;
+        scripts: Array<{ source: string; duration: number }>;
+      }>;
+      commits: number;
+      renders: Record<string, number>;
+      errors: string[];
+    };
+    const { profile } = (await cdp.send("Profiler.stop")) as { profile: CpuProfile };
+    const after = await metrics();
+    NodeFS.writeFileSync(NodePath.join(outDir, "profile.cpuprofile"), JSON.stringify(profile));
+    const crashed = await page.getByText("Something went wrong").count();
+    await browser.close();
+
+    const threads = threadIds.map((threadId) => t3("thread", "show", threadId, "--json"));
+    const seconds = (key: string) => Math.round(((after[key] ?? 0) - (before[key] ?? 0)) * 1000);
+    const summary = {
+      runId,
+      config: {
+        threads: THREADS,
+        turnsPerThread: TURNS_PER_THREAD,
+        durationS: DURATION_MS / 1000,
+        steps: step,
+      },
+      mainThreadMs: {
+        task: seconds("TaskDuration"),
+        script: seconds("ScriptDuration"),
+        layout: seconds("LayoutDuration"),
+        style: seconds("RecalcStyleDuration"),
+      },
+      frames: summarizeFrames(probe.frames),
+      longAnimationFrames: {
+        count: probe.longFrames.length,
+        totalMs: Math.round(probe.longFrames.reduce((sum, frame) => sum + frame.duration, 0)),
+        blockingMs: Math.round(probe.longFrames.reduce((sum, frame) => sum + frame.blocking, 0)),
+        worstMs: Math.round(Math.max(0, ...probe.longFrames.map((frame) => frame.duration))),
+        topScripts: longFrameScripts(probe.longFrames),
+      },
+      memory: {
+        heapMbStart: samples[0]?.heapMb ?? 0,
+        heapMbEnd: samples.at(-1)?.heapMb ?? 0,
+        heapMbMax: Math.max(0, ...samples.map((sample) => sample.heapMb)),
+        domNodesEnd: samples.at(-1)?.nodes ?? 0,
+        samples,
+      },
+      react: {
+        commits: probe.commits,
+        renders: Object.values(probe.renders).reduce((sum, count) => sum + count, 0),
+        topComponents: Object.entries(probe.renders).slice(0, 25),
+      },
+      cpu: summarizeProfile(profile, NodePath.join(webDir, "dist/assets")),
+      health: {
+        errorBoundaries: crashed,
+        pageErrors: probe.errors,
+        consoleErrors: consoleErrors.slice(0, 50),
+        threadsShown: threads.length,
+      },
+    };
+    NodeFS.writeFileSync(NodePath.join(outDir, "summary.json"), JSON.stringify(summary, null, 2));
+    NodeFS.writeFileSync(NodePath.join(outDir, "report.md"), report(summary));
+    console.log(report(summary));
+    log(`artifacts in ${outDir}`);
+  } finally {
+    stopServer();
+  }
+}
+
+function report(summary: {
+  runId: string;
+  config: Record<string, number>;
+  mainThreadMs: Record<string, number>;
+  frames: ReturnType<typeof summarizeFrames>;
+  longAnimationFrames: {
+    count: number;
+    totalMs: number;
+    blockingMs: number;
+    worstMs: number;
+    topScripts: Array<[string, number]>;
+  };
+  memory: { heapMbStart: number; heapMbEnd: number; heapMbMax: number; domNodesEnd: number };
+  react: { commits: number; renders: number; topComponents: Array<[string, number]> };
+  cpu: ReturnType<typeof summarizeProfile>;
+  health: { errorBoundaries: number; pageErrors: string[]; consoleErrors: string[] };
+}): string {
+  const rows = (entries: ReadonlyArray<readonly [string, number]>, unit: string) =>
+    entries.map(([name, value]) => `| ${value} ${unit} | \`${name}\` |`).join("\n");
+  const { frames, longAnimationFrames: laf, memory, react, cpu, health } = summary;
+  return `# Stress run ${summary.runId}
+
+${summary.config.threads} streaming threads, ${summary.config.durationS}s, ${summary.config.steps} user steps.
+
+| Measure | Value |
+| --- | ---: |
+| Main-thread task / script / layout / style | ${summary.mainThreadMs.task} / ${summary.mainThreadMs.script} / ${summary.mainThreadMs.layout} / ${summary.mainThreadMs.style} ms |
+| Frames: p50 / p95 / p99 / max | ${frames.p50Ms} / ${frames.p95Ms} / ${frames.p99Ms} / ${frames.maxMs} ms |
+| Frames over 33 ms (dropped) | ${frames.droppedFrames} of ${frames.frames} |
+| Long animation frames: count / total / blocking / worst | ${laf.count} / ${laf.totalMs} / ${laf.blockingMs} / ${laf.worstMs} ms |
+| JS heap: start / end / max | ${memory.heapMbStart} / ${memory.heapMbEnd} / ${memory.heapMbMax} MB |
+| DOM nodes at end | ${memory.domNodesEnd} |
+| React commits / component renders | ${react.commits} / ${react.renders} |
+| CPU busy (profile) | ${cpu.busyMs} ms |
+| Error boundaries / page errors / console errors | ${health.errorBoundaries} / ${health.pageErrors.length} / ${health.consoleErrors.length} |
+
+## CPU self time by module
+
+| Time | Module |
+| ---: | --- |
+${rows(cpu.byModule, "ms")}
+
+## CPU self time by function
+
+| Time | Function |
+| ---: | --- |
+${rows(cpu.byFunction, "ms")}
+
+## Scripts in long animation frames
+
+| Time | Script |
+| ---: | --- |
+${rows(laf.topScripts, "ms")}
+
+## Most rendered components
+
+| Renders | Component |
+| ---: | --- |
+${rows(react.topComponents, "")}
+`;
+}
+
+await main();
diff --git a/knip.jsonc b/knip.jsonc
index e7289c39147dc..55f867e16be3a 100644
--- a/knip.jsonc
+++ b/knip.jsonc
@@ -92,9 +92,9 @@
       "ignoreDependencies": ["playwright-core", "electron-builder"],
     },
     "apps/web": {
-      // Worktree setup (scripts/setup-worktree.ts) runs this directly, and evidence
-      // fixtures run under node.
-      "entry": ["scripts/warm-dep-cache.ts", "test/fixtures/**/*.mjs"],
+      // Worktree setup (scripts/setup-worktree.ts) runs this directly, evidence fixtures run
+      // under node, and `vp run stress` runs the stress rig.
+      "entry": ["scripts/warm-dep-cache.ts", "test/fixtures/**/*.mjs", "stress/run.ts"],
       // UI component modules are copied and adapted as cohesive sets. Keep their
       // named subcomponents even before they have callers; the file audit still
       // reports an entire component module when nothing imports it.
diff --git a/package.json b/package.json
index b2912d680c855..52593419e8625 100644
--- a/package.json
+++ b/package.json
@@ -29,6 +29,7 @@
     "tc": "vp run -r --cache --concurrency-limit 4 typecheck",
     "check:changed": "node scripts/check-changed.ts",
     "report:renders": "node scripts/render-metrics.ts",
+    "stress": "node apps/web/stress/run.ts",
     "lint": "vp lint --report-unused-disable-directives",
     "knip": "knip --preprocessor ./scripts/knip-schemas.ts",
     "knip:check": "knip --include files,dependencies --no-config-hints && knip --workspace apps/server --workspace apps/desktop --workspace apps/web --workspace packages/client-runtime --workspace packages/contracts --workspace packages/effect-acp --workspace packages/effect-codex-app-server --workspace packages/shared --workspace packages/ssh --workspace packages/tailscale --workspace packages/provider-core --workspace packages/provider-acp --workspace packages/provider-acp-registry --workspace packages/provider-testing --workspace packages/provider-pi --workspace packages/provider-muse --workspace packages/provider-opencode --workspace packages/provider-cursor --workspace packages/provider-fx --workspace packages/provider-grok --workspace packages/secret-provider-core --workspace packages/secret-provider-definitions --workspace packages/secret-provider-onepassword --workspace packages/source-control-core --workspace packages/source-control-definitions --workspace packages/source-control-azure-devops --workspace packages/source-control-bitbucket --workspace packages/source-control-forgejo --workspace packages/source-control-gitcafe --workspace packages/source-control-github --workspace packages/source-control-gitlab --workspace packages/source-control-testing --exports --preprocessor ./scripts/knip-schemas.ts --no-config-hints",

From 99dd97d2e0ee15caaea8a7f73f34cb6ba0e7e9df Mon Sep 17 00:00:00 2001
From: Julius Marminge <51714798+juliusmarminge@users.noreply.github.com>
Date: Fri, 30 Oct 2026 02:24:57 -0700
Subject: [PATCH 2/5] feat(web): the stress rig keeps a recorded huge pull
 request open beside the streams

Huge pull requests could only be tested against GitHub, which truncates their
diffs and answers differently every time. `vp run stress:record-pr` records
one: it fetches the base and head commits into a bare clone and saves every
read the pull request panel makes while it opens the page and a thread's panel.
With `T3CODE_PR_FIXTURES`, the server serves GitHub pull request reads from
those files and diffs from the clone, offline. `vp run stress --pr` links the
recording to a streaming thread and expands and scrolls its diffs while the rig
works the other threads. Threads now run supervised, so approvals pop up, and
profile samples outside the page's own scripts are counted apart.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 .../pullRequest/PullRequestFixtures.test.ts   |  38 ++
 .../src/pullRequest/PullRequestFixtures.ts    | 328 ++++++++++++++++++
 .../PullRequestProviderRegistry.ts            |   8 +-
 apps/web/stress/README.md                     |  14 +-
 apps/web/stress/analyze.ts                    |  28 +-
 apps/web/stress/record.ts                     | 143 ++++++++
 apps/web/stress/run.ts                        | 246 ++++++-------
 apps/web/stress/stack.ts                      | 135 +++++++
 apps/web/stress/ui.ts                         |  91 +++++
 knip.jsonc                                    |   7 +-
 package.json                                  |   1 +
 11 files changed, 897 insertions(+), 142 deletions(-)
 create mode 100644 apps/server/src/pullRequest/PullRequestFixtures.test.ts
 create mode 100644 apps/server/src/pullRequest/PullRequestFixtures.ts
 create mode 100644 apps/web/stress/record.ts
 create mode 100644 apps/web/stress/stack.ts
 create mode 100644 apps/web/stress/ui.ts

diff --git a/apps/server/src/pullRequest/PullRequestFixtures.test.ts b/apps/server/src/pullRequest/PullRequestFixtures.test.ts
new file mode 100644
index 0000000000000..92a541c3ed7ce
--- /dev/null
+++ b/apps/server/src/pullRequest/PullRequestFixtures.test.ts
@@ -0,0 +1,38 @@
+import { describe, expect, it } from "vite-plus/test";
+
+import { parseNumstat, patchPaths, splitPatch } from "./PullRequestFixtures.ts";
+
+const patch = [
+  "diff --git a/src/a.ts b/src/a.ts",
+  "index 1..2 100644",
+  "--- a/src/a.ts",
+  "+++ b/src/a.ts",
+  "@@ -1 +1 @@",
+  "-diff --git a/not/a/header b/in/content",
+  "+x",
+  "diff --git a/old name.ts b/new name.ts",
+  "similarity index 90%",
+  "rename from old name.ts",
+  "rename to new name.ts",
+  "",
+].join("\n");
+
+describe("PullRequestFixtures", () => {
+  it("splits a git diff into file patches and reads their paths, renames included", () => {
+    const files = splitPatch(patch);
+    expect(files).toHaveLength(2);
+    expect(files.join("")).toBe(patch);
+    expect(files.map(patchPaths)).toEqual([
+      { oldPath: "src/a.ts", newPath: "src/a.ts" },
+      { oldPath: "old name.ts", newPath: "new name.ts" },
+    ]);
+  });
+
+  it("reads numstat -z output with renames and binary files", () => {
+    expect(parseNumstat("3\t1\tsrc/a.ts\0-\t-\timage.png\x002\t0\t\0old.ts\0new.ts\0")).toEqual([
+      { path: "src/a.ts", additions: 3, deletions: 1 },
+      { path: "image.png", additions: 0, deletions: 0 },
+      { path: "new.ts", additions: 2, deletions: 0 },
+    ]);
+  });
+});
diff --git a/apps/server/src/pullRequest/PullRequestFixtures.ts b/apps/server/src/pullRequest/PullRequestFixtures.ts
new file mode 100644
index 0000000000000..f1bad01ff5556
--- /dev/null
+++ b/apps/server/src/pullRequest/PullRequestFixtures.ts
@@ -0,0 +1,328 @@
+/**
+ * Recorded GitHub change requests for `vp run stress` (see apps/web/stress/README.md):
+ * `T3CODE_PR_FIXTURES=<dir>` serves reads from calls/, and diffs from a bare clone in repos/ since
+ * the API truncates them; `T3CODE_PR_FIXTURES_RECORD=1` saves what the real host answers instead.
+ */
+import type { SourceControlProviderKind } from "@t3tools/contracts";
+import {
+  PullRequestProviderError,
+  type ProviderDiffSlice,
+  type PullRequestProviderApi,
+} from "@t3tools/source-control-core/server/PullRequestProvider";
+import * as Cache from "effect/Cache";
+import * as Config from "effect/Config";
+import * as Effect from "effect/Effect";
+import * as FileSystem from "effect/FileSystem";
+import * as Option from "effect/Option";
+import * as Path from "effect/Path";
+import * as Schema from "effect/Schema";
+
+import * as ProcessRunner from "../processRunner.ts";
+
+const fixturesConfig = Config.all({
+  dir: Config.String("T3CODE_PR_FIXTURES").pipe(Config.option),
+  record: Config.Boolean("T3CODE_PR_FIXTURES_RECORD").pipe(Config.withDefault(false)),
+});
+
+const RECORDED_READS = [
+  "getViewer",
+  "listChangeRequests",
+  "listChangeRequestsAcross",
+  "listChangeRequestStats",
+  "getChangeRequestChecks",
+  "getChangeRequest",
+  "getChangeRequestPreview",
+  "getChangeRequestSummary",
+  "getChangeRequestWatchFingerprint",
+  "getChangeRequestStack",
+  "getChangeRequestActivity",
+  "getReviewThreadComments",
+  "getViewerPermissions",
+  "getFilesViewed",
+  "getFileRevisions",
+  "listReviewerCandidates",
+  "listLabelCandidates",
+  "listRepositoryLabels",
+  "searchRepositoryAuthors",
+] as const satisfies ReadonlyArray<keyof PullRequestProviderApi>;
+
+const DIFF_PAGE_FILES = 100;
+const PATHS_PAGE_FILES = 1000;
+const MAX_DIFF_BYTES = 2 * 1024 * 1024 * 1024;
+
+const RecordedCall = Schema.Struct({ input: Schema.Unknown, result: Schema.Unknown });
+const ChangeRevisions = Schema.Struct({ baseSha: Schema.String, headSha: Schema.String });
+const decodeCall = Schema.decodeUnknownEffect(Schema.fromJsonString(RecordedCall));
+const decodeRevisions = Schema.decodeUnknownEffect(Schema.fromJsonString(ChangeRevisions));
+
+// Machine and account details differ between the recording and the replay.
+const VOLATILE_INPUT_KEYS = new Set(["cwd", "host", "viewer"]);
+
+function stableKey(value: unknown): string {
+  if (Array.isArray(value)) return `[${value.map(stableKey).join(",")}]`;
+  if (typeof value !== "object" || value === null) return JSON.stringify(value) ?? "null";
+  return `{${Object.entries(value)
+    .filter(([key, entry]) => entry !== undefined && !VOLATILE_INPUT_KEYS.has(key))
+    .sort(([left], [right]) => left.localeCompare(right))
+    .map(([key, entry]) => `${JSON.stringify(key)}:${stableKey(entry)}`)
+    .join(",")}}`;
+}
+
+/** FNV-1a; names files, so collisions only matter between reads of one fixture set. */
+function hash(text: string): string {
+  let value = 0x811c9dc5;
+  for (let index = 0; index < text.length; index++) {
+    value ^= text.charCodeAt(index);
+    value = Math.imul(value, 0x01000193);
+  }
+  return (value >>> 0).toString(16).padStart(8, "0");
+}
+
+const callFile = (method: string, input: unknown) => `${method}-${hash(stableKey(input))}.json`;
+const repositorySlug = (repository: string) => repository.replace("/", "__");
+
+/** Splits `git diff` output into one patch per file, keeping each file's header lines. */
+export function splitPatch(patch: string): string[] {
+  return patch.split(/^(?=diff --git )/m).filter((part) => part.startsWith("diff --git "));
+}
+
+/** The old and new path of one file's patch, from its `---`/`+++` lines or its header. */
+export function patchPaths(filePatch: string): { oldPath: string; newPath: string } {
+  const header = /^diff --git a\/(.+?) b\/(.+)$/m.exec(filePatch);
+  const renameFrom = /^rename from (.+)$/m.exec(filePatch)?.[1];
+  const renameTo = /^rename to (.+)$/m.exec(filePatch)?.[1];
+  const oldPath = renameFrom ?? header?.[1] ?? "";
+  const newPath = renameTo ?? header?.[2] ?? oldPath;
+  return { oldPath, newPath };
+}
+
+/** `git diff --numstat -z`: a rename leaves its path empty and follows with old and new paths. */
+export function parseNumstat(output: string) {
+  const fields = output.split("\0");
+  const files: Array<{ path: string; additions: number; deletions: number }> = [];
+  for (let index = 0; index < fields.length; index++) {
+    const [additions, deletions, path] = fields[index]!.split("\t");
+    if (additions === undefined || deletions === undefined || path === undefined) continue;
+    // Binary files report "-" for both counts.
+    const counts = { additions: Number(additions) || 0, deletions: Number(deletions) || 0 };
+    if (path === "") {
+      files.push({ path: fields[index + 2] ?? "", ...counts });
+      index += 2;
+    } else {
+      files.push({ path, ...counts });
+    }
+  }
+  return files;
+}
+
+/** Wraps a real provider so each read it answers is also written to `dir`. */
+const recordingProvider = Effect.fn("PullRequestFixtures.recordingProvider")(function* (
+  provider: PullRequestProviderApi,
+  dir: string,
+) {
+  const fs = yield* FileSystem.FileSystem;
+  const path = yield* Path.Path;
+  const calls = path.join(dir, "calls");
+  yield* fs.makeDirectory(calls, { recursive: true }).pipe(Effect.orDie);
+  const wrapped: Record<string, unknown> = { ...provider };
+  for (const method of RECORDED_READS) {
+    const read = provider[method] as
+      | ((input: unknown) => Effect.Effect<unknown, PullRequestProviderError>)
+      | undefined;
+    if (read === undefined) continue;
+    wrapped[method] = (input: unknown) =>
+      read(input).pipe(
+        Effect.tap((result) =>
+          fs
+            .writeFileString(
+              path.join(calls, callFile(method, input)),
+              JSON.stringify({ input, result }),
+            )
+            .pipe(Effect.ignore),
+        ),
+      );
+  }
+  return wrapped as unknown as PullRequestProviderApi;
+});
+
+/** Serves `provider`'s kind from `dir` alone: recorded reads, diffs from the local clone. */
+const replayProvider = Effect.fn("PullRequestFixtures.replayProvider")(function* (
+  provider: PullRequestProviderApi,
+  dir: string,
+) {
+  const fs = yield* FileSystem.FileSystem;
+  const path = yield* Path.Path;
+  const processes = yield* ProcessRunner.ProcessRunner;
+  const kind: SourceControlProviderKind = provider.kind;
+
+  const notRecorded = (operation: string, detail: string) =>
+    new PullRequestProviderError({ provider: kind, operation, reason: "not-found", detail });
+
+  const recorded = (method: string, input: unknown) =>
+    fs.readFileString(path.join(dir, "calls", callFile(method, input))).pipe(
+      Effect.flatMap(decodeCall),
+      Effect.map((call) => call.result),
+      Effect.mapError(() => notRecorded(method, `No recorded ${method} for this input.`)),
+    );
+
+  const git = (operation: string, repository: string, args: ReadonlyArray<string>) =>
+    processes
+      .run({
+        command: "git",
+        args: ["--git-dir", path.join(dir, "repos", `${repositorySlug(repository)}.git`), ...args],
+        maxOutputBytes: MAX_DIFF_BYTES,
+        timeout: "10 minutes",
+      })
+      .pipe(
+        Effect.mapError((error) => notRecorded(operation, `git failed: ${error.message}`)),
+        Effect.flatMap((output) =>
+          output.code === 0
+            ? Effect.succeed(output.stdout)
+            : Effect.fail(notRecorded(operation, output.stderr.trim())),
+        ),
+      );
+
+  const revisions = (repository: string, number: number) =>
+    fs
+      .readFileString(path.join(dir, "changes", `${repositorySlug(repository)}__${number}.json`))
+      .pipe(
+        Effect.flatMap(decodeRevisions),
+        Effect.mapError(() =>
+          notRecorded("getDiff", `No recorded revisions for ${repository}#${number}.`),
+        ),
+      );
+
+  // One diff per change or commit, split once; the code tab pages through it many times.
+  const filePatches = yield* Cache.make({
+    capacity: 8,
+    lookup: Effect.fn("PullRequestFixtures.filePatches")(function* (key: string) {
+      const [repository, number, commit] = key.split("\u0000") as [string, string, string];
+      if (commit) {
+        return splitPatch(
+          yield* git("getDiff", repository, ["show", "--no-color", "--format=", "-M", commit]),
+        );
+      }
+      const { baseSha, headSha } = yield* revisions(repository, Number(number));
+      return splitPatch(
+        yield* git("getDiff", repository, ["diff", "--no-color", "-M", baseSha, headSha]),
+      );
+    }),
+  });
+  const patchesFor = (input: {
+    readonly repository: string;
+    readonly number: number;
+    readonly commit?: string | undefined;
+  }) =>
+    Cache.get(filePatches, `${input.repository}\u0000${input.number}\u0000${input.commit ?? ""}`);
+
+  const page = <A>(items: ReadonlyArray<A>, cursor: string | undefined, size: number) => {
+    const start = cursor === undefined ? 0 : Number(cursor);
+    const end = start + size;
+    return { items: items.slice(start, end), nextCursor: end < items.length ? String(end) : null };
+  };
+
+  const fallbackViewer = "fixture";
+  const viewer = recorded("getViewer", {}).pipe(
+    Effect.map((value) => (typeof value === "string" ? value : fallbackViewer)),
+    Effect.orElseSucceed(() => fallbackViewer),
+  );
+
+  const withVerifiedCredential: NonNullable<PullRequestProviderApi["withVerifiedCredential"]> = (
+    _input,
+    use,
+  ) =>
+    viewer.pipe(
+      Effect.flatMap((name) =>
+        use({ accountId: "fixture", viewer: name, credentialFingerprint: "fixture" }),
+      ),
+    );
+  const getDiffFileContents: NonNullable<PullRequestProviderApi["getDiffFileContents"]> = Effect.fn(
+    "PullRequestFixtures.getDiffFileContents",
+  )(function* (input) {
+    const { baseSha, headSha } = input.commit
+      ? { baseSha: `${input.commit}^`, headSha: input.commit }
+      : yield* revisions(input.repository, input.number);
+    const show = (revision: string, file: string) =>
+      git("getDiffFileContents", input.repository, ["show", `${revision}:${file}`]);
+    return {
+      oldContents: input.changeType === "new" ? "" : yield* show(baseSha, input.oldPath),
+      newContents: input.changeType === "deleted" ? "" : yield* show(headSha, input.newPath),
+    };
+  });
+
+  const replayed: Record<string, unknown> = {
+    ...provider,
+    withVerifiedCredential,
+    getRoutingIdentity: () =>
+      viewer.pipe(Effect.map((name) => ({ accountId: "fixture", viewer: name }))),
+    getViewer: () => viewer,
+    getDiff: (input: Parameters<PullRequestProviderApi["getDiff"]>[0]) =>
+      patchesFor(input).pipe(
+        Effect.map((patches): ProviderDiffSlice => {
+          const { items, nextCursor } = page(patches, input.cursor, DIFF_PAGE_FILES);
+          return { patch: items.join(""), truncated: false, nextCursor };
+        }),
+      ),
+    getDiffFilePaths: (
+      input: Parameters<NonNullable<PullRequestProviderApi["getDiffFilePaths"]>>[0],
+    ) =>
+      patchesFor(input).pipe(
+        Effect.map((patches) => {
+          const { items, nextCursor } = page(
+            patches.map(patchPaths),
+            input.cursor,
+            PATHS_PAGE_FILES,
+          );
+          return { files: items, nextCursor };
+        }),
+      ),
+    getFileStats: (input: Parameters<NonNullable<PullRequestProviderApi["getFileStats"]>>[0]) =>
+      revisions(input.repository, input.number).pipe(
+        Effect.flatMap(({ baseSha, headSha }) =>
+          git("getFileStats", input.repository, [
+            "diff",
+            "--numstat",
+            "-z",
+            "-M",
+            baseSha,
+            headSha,
+          ]),
+        ),
+        Effect.map((numstat) => ({ files: parseNumstat(numstat), truncated: false })),
+      ),
+    getDiffFileContents,
+    getFilesViewed: (input: unknown) =>
+      recorded("getFilesViewed", input).pipe(
+        Effect.orElseSucceed(() => ({ files: [], truncated: false })),
+      ),
+    forgetChangeRequestReads: () => Effect.void,
+    runAction: () => Effect.void,
+    updateChangeRequest: () => Effect.void,
+    comment: () => Effect.void,
+    updateComment: () => Effect.void,
+    submitReview: () => Effect.void,
+    setReviewerRequest: () => Effect.void,
+    setLabels: () => Effect.void,
+    replyToThread: () => Effect.void,
+    setReaction: () => Effect.void,
+    setThreadResolution: () => Effect.void,
+    setFilesViewed: () => Effect.void,
+  };
+  for (const method of RECORDED_READS) {
+    if (method === "getViewer" || provider[method] === undefined) continue;
+    replayed[method] = (input: unknown) => recorded(method, input);
+  }
+  return replayed as unknown as PullRequestProviderApi;
+});
+
+/** The fixture form of `provider` when the environment asks for one, else `provider` itself. */
+export const applyFixtures = Effect.fn("PullRequestFixtures.applyFixtures")(function* (
+  provider: PullRequestProviderApi,
+) {
+  const config = yield* fixturesConfig;
+  const dir = Option.getOrUndefined(config.dir);
+  if (dir === undefined || provider.kind !== "github") return provider;
+  return config.record
+    ? yield* recordingProvider(provider, dir)
+    : yield* replayProvider(provider, dir);
+});
diff --git a/apps/server/src/pullRequest/PullRequestProviderRegistry.ts b/apps/server/src/pullRequest/PullRequestProviderRegistry.ts
index 63323b6122d20..91f6042cfcb1e 100644
--- a/apps/server/src/pullRequest/PullRequestProviderRegistry.ts
+++ b/apps/server/src/pullRequest/PullRequestProviderRegistry.ts
@@ -4,6 +4,7 @@ import * as Layer from "effect/Layer";
 import type { SourceControlProviderKind } from "@t3tools/contracts";
 
 import * as BuiltInDrivers from "../sourceControl/builtInDrivers.ts";
+import * as PullRequestFixtures from "./PullRequestFixtures.ts";
 import type { PullRequestProviderApi } from "@t3tools/source-control-core/server/PullRequestProvider";
 
 export class PullRequestProviderRegistry extends Context.Service<
@@ -27,7 +28,12 @@ export function fromProviders(
 /** @public */
 export const make = Effect.gen(function* () {
   const drivers = yield* BuiltInDrivers.SourceControlDrivers;
-  return fromProviders(drivers.flatMap(({ instance }) => instance.pullRequests ?? []));
+  return fromProviders(
+    yield* Effect.forEach(
+      drivers.flatMap(({ instance }) => instance.pullRequests ?? []),
+      PullRequestFixtures.applyFixtures,
+    ),
+  );
 });
 
 export const layer = Layer.effect(PullRequestProviderRegistry, make).pipe(
diff --git a/apps/web/stress/README.md b/apps/web/stress/README.md
index e1d1f7b3a897b..5624b1f91ce35 100644
--- a/apps/web/stress/README.md
+++ b/apps/web/stress/README.md
@@ -10,12 +10,22 @@
 4. Opens headless Chromium, pairs, and for `--duration` seconds (default 60) acts like a busy user: switches threads, approves edits, types in the composer, opens and closes the right panel, and scrolls.
 5. Writes `report.md`, `summary.json`, `profile.cpuprofile` (open in Chrome DevTools), screenshots, and `server.log` to `.t3/stress/runs/<time>` or `--out`.
 
-Background threads stop at their approval until the rig visits them, so the sidebar always holds a mix of streaming, waiting, and settled threads.
+Threads run supervised, so each stops at its edit approval until the rig visits it, and the sidebar always holds a mix of streaming, waiting, and settled threads.
+
+## Huge pull requests
+
+`--pr owner/name#123` links a recorded pull request to the first thread and keeps its panel open beside the stream: the rig expands diffs and scrolls the code tab, and switches to the timeline now and then, while it visits the other threads to approve.
+
+Record a pull request once per machine with `vp run stress:record-pr owner/name#123` (needs `gh` signed in). It fetches the base and head commits into a bare clone and opens the pull request on a recording server, which saves every read the panel makes, from the pull request page and from a thread's panel. Recordings live in `~/.cache/t3code-stress/fixtures` and are shared by every checkout.
+
+During a run the server serves GitHub pull request reads from those files (`T3CODE_PR_FIXTURES`, see `apps/server/src/pullRequest/PullRequestFixtures.ts`): recorded reads as GitHub answered them, and diffs from the clone, since GitHub's API truncates diffs this size. Nothing reaches GitHub, so runs are repeatable and offline. Reads the recording missed fail as not found; record again after the panel starts reading something new.
+
+Reference pull requests: `pingdotgg/t3code#2829` (about 585k changed lines, 932 review threads), `oven-sh/bun#30412` (about 1M lines), and `oven-sh/bun#45631` (about 2.3M lines in 19k files).
 
 ## Reading the report
 
 - **Frames over 33 ms** and **long animation frames** are what a user feels. The long-frame scripts table says what ran during them: `dispatchDiscreteEvent` is a click or key handler, `onMessage` is server traffic.
-- **CPU self time by module** splits the profile by package and source file. **By function** points at the hot code.
+- **CPU self time by module** splits the profile by package and source file. **By function** points at the hot code. Samples with no page script on the stack (the rig's own Playwright work, browser internals) are counted apart.
 - **Most rendered components** counts React renders over the window. A component that renders far more often than what it shows changes is the usual lead.
 - **JS heap** and **DOM nodes** are sampled each step; a climb across the run is a leak or unbounded list.
 - **Health** must stay at zero error boundaries and page errors; console 404s for missing favicons are expected offline.
diff --git a/apps/web/stress/analyze.ts b/apps/web/stress/analyze.ts
index df9cd707e10f4..dd64581811e7b 100644
--- a/apps/web/stress/analyze.ts
+++ b/apps/web/stress/analyze.ts
@@ -85,18 +85,43 @@ function moduleOwners(assetsDir: string): Map<string, string[]> {
   return owners;
 }
 
-/** Self time by function and by source module or package, idle excluded. */
+/**
+ * Self time by function and by source module or package, idle excluded. Samples with no page
+ * script on the stack are the rig's own work (Playwright's injected selectors) or the browser's,
+ * so they are counted apart and left out of the rankings.
+ */
 export function summarizeProfile(profile: CpuProfile, assetsDir: string, top = 25) {
   const byId = new Map(profile.nodes.map((node) => [node.id, node]));
+  const parent = new Map<number, number>();
+  for (const node of profile.nodes)
+    for (const child of node.children ?? []) parent.set(child, node.id);
+  const fromPage = new Map<number, boolean>();
+  const isFromPage = (id: number): boolean => {
+    const known = fromPage.get(id);
+    if (known !== undefined) return known;
+    const node = byId.get(id);
+    const parentId = parent.get(id);
+    const result =
+      node !== undefined &&
+      (/^https?:/.test(node.callFrame.url) || (parentId !== undefined && isFromPage(parentId)));
+    fromPage.set(id, result);
+    return result;
+  };
   const owners = moduleOwners(assetsDir);
   const byFunction = new Map<string, number>();
   const byModule = new Map<string, number>();
   let busyUs = 0;
+  let outsidePageUs = 0;
   profile.samples.forEach((id, index) => {
     const node = byId.get(id);
     const delta = profile.timeDeltas[index + 1] ?? 0;
     if (!node || ["(idle)", "(program)"].includes(node.callFrame.functionName)) return;
     busyUs += delta;
+    const garbage = node.callFrame.functionName === "(garbage collector)";
+    if (!garbage && !isFromPage(id)) {
+      outsidePageUs += delta;
+      return;
+    }
     const file = node.callFrame.url.split("/").pop() ?? "";
     const fn = `${node.callFrame.functionName || "(anonymous)"} ${file}:${node.callFrame.lineNumber + 1}`;
     byFunction.set(fn, (byFunction.get(fn) ?? 0) + delta);
@@ -111,6 +136,7 @@ export function summarizeProfile(profile: CpuProfile, assetsDir: string, top = 2
       .slice(0, top);
   return {
     busyMs: Math.round(busyUs / 1000),
+    outsidePageMs: Math.round(outsidePageUs / 1000),
     byFunction: ranked(byFunction),
     byModule: ranked(byModule),
   };
diff --git a/apps/web/stress/record.ts b/apps/web/stress/record.ts
new file mode 100644
index 0000000000000..3eff6ec707cc9
--- /dev/null
+++ b/apps/web/stress/record.ts
@@ -0,0 +1,143 @@
+// @effect-diagnostics nodeBuiltinImport:off globalConsole:off globalTimers:off - a standalone recording CLI.
+/**
+ * `vp run stress:record-pr <owner/name#number>`: saves a GitHub pull request for `vp run stress
+ * --pr`. It fetches the base and head commits into a shared bare clone for diffs, then opens the
+ * pull request in a recording server, so every read the panel makes is saved as the real host
+ * answered it. Needs `gh` signed in.
+ */
+import * as NodeFS from "node:fs";
+import * as NodePath from "node:path";
+import * as NodeUtil from "node:util";
+import { chromium } from "playwright";
+
+import {
+  changeFile,
+  fixturesDir,
+  freePort,
+  log,
+  parsePullRequest,
+  prepareHome,
+  repo,
+  run,
+  startServer,
+  t3,
+  type RecordedChange,
+} from "./stack.ts";
+import {
+  linkPullRequest,
+  openPullRequestPanel,
+  openThread,
+  scrollEverything,
+  selectPullRequestTab,
+} from "./ui.ts";
+
+const { values: options, positionals } = NodeUtil.parseArgs({
+  allowPositionals: true,
+  options: { headed: { type: "boolean", default: false } },
+});
+if (positionals[0] === undefined) throw new Error("Usage: vp run stress:record-pr owner/name#123");
+const { repository, number } = parsePullRequest(positionals[0]);
+const slug = repository.replace("/", "__");
+
+function recordRevisions() {
+  const [baseSha, headSha, ...titleWords] = run(
+    "gh",
+    [
+      "api",
+      `repos/${repository}/pulls/${number}`,
+      "--jq",
+      '.base.sha + " " + .head.sha + " " + .title',
+    ],
+    repo,
+  )
+    .trim()
+    .split(" ");
+  if (!baseSha || !headSha) throw new Error(`No base and head for ${repository}#${number}`);
+  const gitDir = NodePath.join(fixturesDir, "repos", `${slug}.git`);
+  if (!NodeFS.existsSync(gitDir)) run("git", ["init", "-q", "--bare", gitDir], repo);
+  log(`fetching ${baseSha.slice(0, 10)} and ${headSha.slice(0, 10)} from ${repository}`);
+  run(
+    "git",
+    [
+      "--git-dir",
+      gitDir,
+      "fetch",
+      "-q",
+      "--depth=1",
+      `https://github.com/${repository}.git`,
+      baseSha,
+      headSha,
+    ],
+    repo,
+  );
+  NodeFS.mkdirSync(NodePath.dirname(changeFile(repository, number)), { recursive: true });
+  const change: RecordedChange = { baseSha, headSha, title: titleWords.join(" ") };
+  NodeFS.writeFileSync(changeFile(repository, number), JSON.stringify(change));
+  return change;
+}
+
+async function main() {
+  const change = recordRevisions();
+  const home = NodePath.join(repo, ".t3/stress/record-home");
+  const workspace = prepareHome(home, `https://github.com/${repository}.git`);
+  const server = await startServer({
+    home,
+    port: await freePort(),
+    logFile: NodePath.join(home, "server.log"),
+    env: { T3CODE_PR_FIXTURES: fixturesDir, T3CODE_PR_FIXTURES_RECORD: "1" },
+  });
+  try {
+    const projectId = /Added project (\S+)/.exec(t3(home, "project", "add", workspace))?.[1];
+    if (!projectId) throw new Error("project add printed no id");
+    const browser = await chromium.launch({ headless: !options.headed });
+    const page = await (
+      await browser.newContext({ viewport: { width: 1440, height: 900 } })
+    ).newPage();
+    await page.goto(server.pairingUrl);
+    await page.getByRole("navigation", { name: "Threads" }).waitFor({ timeout: 60_000 });
+    const origin = new URL(server.pairingUrl).origin;
+    await page.goto(
+      `${origin}/pull-requests?${new URLSearchParams({ repository, number: String(number), projectId, host: "github.com" })}`,
+    );
+    const visitTabs = async (where: string) => {
+      for (const tab of ["Summary", "Timeline", "Code"] as const) {
+        await selectPullRequestTab(page, tab);
+        log(`recording the ${tab} tab (${where})`);
+        await page.waitForTimeout(5000);
+        await scrollEverything(page);
+      }
+    };
+    await page.getByRole("navigation", { name: "Pull request tabs" }).waitFor({ timeout: 120_000 });
+    await visitTabs("pull request page");
+    // A thread's panel reads the pull request through its own requests.
+    t3(
+      home,
+      "thread",
+      "start",
+      workspace,
+      "Record",
+      "--title",
+      "Record",
+      "--provider",
+      "devReplay",
+      "--model",
+      "stress",
+    );
+    await page.goto(origin);
+    await openThread(page, "Record");
+    await linkPullRequest(page, `https://github.com/${repository}/pull/${number}`);
+    await openPullRequestPanel(page, change.title).catch(async (error: Error) => {
+      await page.screenshot({ path: NodePath.join(home, "record-failure.png") });
+      throw error;
+    });
+    await visitTabs("thread panel");
+    await page.screenshot({ path: NodePath.join(home, "recorded.png") });
+    await browser.close();
+  } finally {
+    server.stop();
+  }
+  const calls = NodeFS.readdirSync(NodePath.join(fixturesDir, "calls"));
+  log(`${calls.length} recorded reads in ${fixturesDir}`);
+}
+
+await main();
diff --git a/apps/web/stress/run.ts b/apps/web/stress/run.ts
index 0685e03b2301c..04568b78a9658 100644
--- a/apps/web/stress/run.ts
+++ b/apps/web/stress/run.ts
@@ -6,24 +6,49 @@
  */
 import * as NodeChildProcess from "node:child_process";
 import * as NodeFS from "node:fs";
-import * as NodeNet from "node:net";
 import * as NodePath from "node:path";
 import * as NodeUtil from "node:util";
 import { chromium, type Page } from "playwright";
 
 import { longFrameScripts, summarizeFrames, summarizeProfile, type CpuProfile } from "./analyze.ts";
 import { installStressProbe } from "./probe.ts";
+import {
+  changeFile,
+  fixturesDir,
+  freePort,
+  log,
+  parsePullRequest,
+  prepareHome,
+  repo,
+  startServer,
+  t3,
+  webDir,
+  type RecordedChange,
+} from "./stack.ts";
+import {
+  expandDiffs,
+  linkPullRequest,
+  openPullRequestPanel,
+  openThread,
+  selectPullRequestTab,
+} from "./ui.ts";
 
-const repo = NodePath.resolve(import.meta.dirname, "../../..");
-const webDir = NodePath.join(repo, "apps/web");
-const serverBin = NodePath.join(repo, "apps/server/src/bin.ts");
-const replayAgent = NodePath.join(repo, "apps/server/scripts/dev-replay-agent.ts");
+function recordedChange(input: { repository: string; number: number }): RecordedChange {
+  const file = changeFile(input.repository, input.number);
+  if (!NodeFS.existsSync(file)) {
+    throw new Error(
+      `${input.repository}#${input.number} is not recorded; run \`vp run stress:record-pr ${input.repository}#${input.number}\` first.`,
+    );
+  }
+  return JSON.parse(NodeFS.readFileSync(file, "utf8")) as RecordedChange;
+}
 
 const { values: options } = NodeUtil.parseArgs({
   options: {
     threads: { type: "string", default: "5" },
     duration: { type: "string", default: "60" },
     "turns-per-thread": { type: "string", default: "4" },
+    pr: { type: "string" },
     out: { type: "string" },
     "skip-build": { type: "boolean", default: false },
     headed: { type: "boolean", default: false },
@@ -32,116 +57,47 @@ const { values: options } = NodeUtil.parseArgs({
 const THREADS = Number(options.threads);
 const DURATION_MS = Number(options.duration) * 1000;
 const TURNS_PER_THREAD = Number(options["turns-per-thread"]);
+const pullRequest = options.pr === undefined ? undefined : parsePullRequest(options.pr);
+const pullRequestTitle = pullRequest ? recordedChange(pullRequest).title : "";
 const runId = new Date().toISOString().replaceAll(":", "-").replace(/\..+/, "");
 const outDir = NodePath.resolve(options.out ?? NodePath.join(repo, ".t3/stress/runs", runId));
 const home = NodePath.join(repo, ".t3/stress/home");
-const log = (message: string) => console.error(`[stress] ${message}`);
-
-const freePort = () =>
-  new Promise<number>((resolve, reject) => {
-    const server = NodeNet.createServer();
-    server.listen(0, "127.0.0.1", () => {
-      const address = server.address();
-      server.close(() =>
-        typeof address === "object" && address
-          ? resolve(address.port)
-          : reject(new Error("no port")),
-      );
-    });
-  });
-
-const t3 = (...args: string[]) =>
-  NodeChildProcess.execFileSync(process.execPath, [serverBin, ...args, "--base-dir", home], {
-    cwd: repo,
-    encoding: "utf8",
-    stdio: ["ignore", "pipe", "pipe"],
-  });
-
-function prepareHome(): string {
-  NodeFS.rmSync(home, { recursive: true, force: true });
-  NodeFS.mkdirSync(NodePath.join(home, "userdata"), { recursive: true });
-  // The entry `vp run dev` seeds, written up front because this server runs without a dev URL.
-  NodeFS.writeFileSync(
-    NodePath.join(home, "userdata/settings.json"),
-    JSON.stringify({
-      providerInstances: {
-        devReplay: {
-          driver: "acpRegistry",
-          displayName: "Replay (dev)",
-          config: { source: "local", commandPath: process.execPath, commandArgs: [replayAgent] },
-        },
-      },
-    }),
-  );
-  const workspace = NodePath.join(home, "workspace");
-  NodeFS.mkdirSync(workspace, { recursive: true });
-  NodeFS.writeFileSync(NodePath.join(workspace, "README.md"), "# Stress workspace\n");
-  NodeChildProcess.execFileSync("git", ["init", "-q"], { cwd: workspace });
-  NodeChildProcess.execFileSync("git", ["add", "."], { cwd: workspace });
-  NodeChildProcess.execFileSync(
-    "git",
-    ["-c", "user.name=stress", "-c", "user.email=stress@example.com", "commit", "-qm", "init"],
-    { cwd: workspace },
-  );
-  return workspace;
-}
-
-async function startServer(port: number) {
-  const child = NodeChildProcess.spawn(
-    process.execPath,
-    [serverBin, "serve", "--base-dir", home, "--port", String(port), "--no-browser"],
-    {
-      cwd: repo,
-      stdio: ["ignore", "pipe", "pipe"],
-      env: { ...process.env, NODE_ENV: "production" },
-    },
-  );
-  const serverLog = NodeFS.createWriteStream(NodePath.join(outDir, "server.log"));
-  child.stdout.pipe(serverLog);
-  child.stderr.pipe(serverLog);
-  const pairingUrl = await new Promise<string>((resolve, reject) => {
-    let buffered = "";
-    child.stdout.on("data", (chunk: Buffer) => {
-      buffered += chunk.toString();
-      const match = /Pairing URL: (\S+)/.exec(buffered);
-      if (match) resolve(match[1]!);
-    });
-    child.once("exit", (code) => reject(new Error(`server exited with ${code}; see server.log`)));
-  });
-  return { child, pairingUrl };
-}
 
-// Threads sit in sidebar groups (Working, Settled) that start collapsed.
-async function threadItem(page: Page, title: string) {
-  const item = page.getByRole("treeitem", { name: new RegExp(`${title}\\b`) }).first();
-  // Expanding one group re-renders the tree, so look for the next collapsed group each time.
-  for (let attempt = 0; attempt < 5 && !(await item.isVisible()); attempt++) {
-    const group = page.getByRole("treeitem", { expanded: false }).first();
-    if ((await group.count()) === 0) break;
-    await group.click();
-  }
-  return item;
-}
+const approvePending = async (page: Page) => {
+  const approve = page.locator("button", { hasText: /^Approve$/ });
+  if (await approve.first().isVisible()) await approve.first().click();
+};
 
+/**
+ * One step of a busy user. Without a pull request it tours the threads. With one, odd steps
+ * work in its panel beside Stress 1, which keeps streaming, and even steps visit another thread
+ * to approve its edit before coming back.
+ */
 async function act(page: Page, step: number) {
-  const thread = `Stress ${(step % THREADS) + 1}`;
-  await (await threadItem(page, thread)).click({ timeout: 5000 });
-  await page.waitForTimeout(1500);
-  const approve = page.getByRole("button", { name: "Approve", exact: true });
-  if (await approve.first().isVisible()) await approve.first().click();
-  if (step % 3 === 0) {
-    const composer = page.getByRole("textbox", { name: /^Message/ });
-    await composer.click();
-    await composer.pressSequentially("checking how this behaves under load", { delay: 20 });
-    await composer.press("ControlOrMeta+a");
-    await composer.press("Backspace");
-  }
-  if (step % 4 === 1) {
-    await page.getByRole("button", { name: "Toggle right panel" }).click();
-    await page.waitForTimeout(1000);
-    await page.getByRole("button", { name: "Toggle right panel" }).click();
+  if (!pullRequest || step % 2 === 0) {
+    await openThread(page, `Stress ${(step % THREADS) + 1}`);
+    await page.waitForTimeout(1500);
+    await approvePending(page);
+    if (step % 3 === 0) {
+      const composer = page.locator('[contenteditable="true"][aria-label^="Message"]');
+      await composer.click();
+      await composer.pressSequentially("checking how this behaves under load", { delay: 20 });
+      await composer.press("ControlOrMeta+a");
+      await composer.press("Backspace");
+    }
+    await page.mouse.wheel(0, step % 4 === 0 ? -1500 : 1500);
+    if (!pullRequest) return;
   }
-  await page.mouse.wheel(0, step % 2 === 0 ? -1500 : 1500);
+  await openThread(page, "Stress 1");
+  await approvePending(page);
+  const tabs = page.locator('nav[aria-label="Pull request tabs"]');
+  if (!(await tabs.isVisible())) await openPullRequestPanel(page, pullRequestTitle);
+  const tab = step % 6 === 5 ? "Timeline" : "Code";
+  await selectPullRequestTab(page, tab);
+  if (tab === "Code") await expandDiffs(page, 4);
+  // Scroll the panel, which sits on the right half of the window.
+  await page.mouse.move(1150, 500);
+  for (let tick = 0; tick < 6; tick++) await page.mouse.wheel(0, 900);
 }
 
 async function main() {
@@ -153,19 +109,24 @@ async function main() {
       stdio: "inherit",
     });
   }
-  const workspace = prepareHome();
-  const port = await freePort();
-  const { child, pairingUrl } = await startServer(port);
-  const stopServer = () => {
-    if (child.exitCode === null) child.kill("SIGTERM");
-  };
-  process.once("exit", stopServer);
+  const workspace = prepareHome(
+    home,
+    pullRequest && `https://github.com/${pullRequest.repository}.git`,
+  );
+  const server = await startServer({
+    home,
+    port: await freePort(),
+    logFile: NodePath.join(outDir, "server.log"),
+    ...(pullRequest ? { env: { T3CODE_PR_FIXTURES: fixturesDir } } : {}),
+  });
+  const { pairingUrl } = server;
   try {
-    t3("project", "add", workspace);
+    t3(home, "project", "add", workspace);
     const threadIds: string[] = [];
     for (let index = 1; index <= THREADS; index++) {
       const started = JSON.parse(
         t3(
+          home,
           "thread",
           "start",
           workspace,
@@ -183,7 +144,7 @@ async function main() {
       if (!threadId) throw new Error(`thread start printed no id for Stress ${index}`);
       threadIds.push(threadId);
       for (let turn = 1; turn < TURNS_PER_THREAD; turn++)
-        t3("thread", "send", threadId, "Next stress turn");
+        t3(home, "thread", "send", threadId, "Next stress turn");
     }
     log(`${THREADS} threads started with ${TURNS_PER_THREAD} turns each`);
 
@@ -197,19 +158,23 @@ async function main() {
     page.on("pageerror", (error) => consoleErrors.push(error.message.slice(0, 300)));
     await page.addInitScript(installStressProbe);
     await page.goto(pairingUrl);
-    await page.getByRole("treeitem").first().waitFor({ timeout: 60_000 });
-    await (
-      await threadItem(page, "Stress 1")
-    )
-      .waitFor({ timeout: 30_000 })
-      .catch(async (error: Error) => {
-        await page.screenshot({ path: NodePath.join(outDir, "startup-failure.png") });
-        NodeFS.writeFileSync(
-          NodePath.join(outDir, "startup-failure.txt"),
-          await page.innerText("body"),
-        );
-        throw error;
-      });
+    await page.getByRole("navigation", { name: "Threads" }).waitFor({ timeout: 60_000 });
+    await openThread(page, "Stress 1").catch(async (error: Error) => {
+      await page.screenshot({ path: NodePath.join(outDir, "startup-failure.png") });
+      NodeFS.writeFileSync(
+        NodePath.join(outDir, "startup-failure.txt"),
+        await page.innerText("body"),
+      );
+      throw error;
+    });
+    if (pullRequest) {
+      await linkPullRequest(
+        page,
+        `https://github.com/${pullRequest.repository}/pull/${pullRequest.number}`,
+      );
+      await openPullRequestPanel(page, pullRequestTitle);
+      await selectPullRequestTab(page, "Code");
+    }
     await page.waitForTimeout(3000);
 
     const cdp = await context.newCDPSession(page);
@@ -233,9 +198,15 @@ async function main() {
     log(`recording for ${DURATION_MS / 1000}s`);
     let step = 0;
     while (Date.now() - started < DURATION_MS) {
-      await act(page, step++).catch((error: Error) =>
-        log(`step ${step} failed: ${error.message.split("\n")[0]}`),
-      );
+      await act(page, step++).catch((error: Error) => {
+        const lines = error.message.split("\n");
+        const target = lines.find((line) => line.includes("waiting for")) ?? "";
+        log(`step ${step} failed: ${lines[0]} ${target.trim()}`);
+        if (process.env.STRESS_DEBUG) {
+          log(error.message);
+          void page.screenshot({ path: NodePath.join(outDir, `failed-step-${step}.png`) });
+        }
+      });
       const sample = await metrics();
       samples.push({
         atMs: Date.now() - started,
@@ -264,7 +235,7 @@ async function main() {
     const crashed = await page.getByText("Something went wrong").count();
     await browser.close();
 
-    const threads = threadIds.map((threadId) => t3("thread", "show", threadId, "--json"));
+    const threads = threadIds.map((threadId) => t3(home, "thread", "show", threadId, "--json"));
     const seconds = (key: string) => Math.round(((after[key] ?? 0) - (before[key] ?? 0)) * 1000);
     const summary = {
       runId,
@@ -313,12 +284,13 @@ async function main() {
     console.log(report(summary));
     log(`artifacts in ${outDir}`);
   } finally {
-    stopServer();
+    server.stop();
   }
 }
 
 function report(summary: {
   runId: string;
+  pullRequest: string | null;
   config: Record<string, number>;
   mainThreadMs: Record<string, number>;
   frames: ReturnType<typeof summarizeFrames>;
@@ -339,7 +311,7 @@ function report(summary: {
   const { frames, longAnimationFrames: laf, memory, react, cpu, health } = summary;
   return `# Stress run ${summary.runId}
 
-${summary.config.threads} streaming threads, ${summary.config.durationS}s, ${summary.config.steps} user steps.
+${summary.config.threads} streaming threads${summary.pullRequest ? `, pull request ${summary.pullRequest} open` : ""}, ${summary.config.durationS}s, ${summary.config.steps} user steps.
 
 | Measure | Value |
 | --- | ---: |
@@ -350,7 +322,7 @@ ${summary.config.threads} streaming threads, ${summary.config.durationS}s, ${sum
 | JS heap: start / end / max | ${memory.heapMbStart} / ${memory.heapMbEnd} / ${memory.heapMbMax} MB |
 | DOM nodes at end | ${memory.domNodesEnd} |
 | React commits / component renders | ${react.commits} / ${react.renders} |
-| CPU busy (profile) | ${cpu.busyMs} ms |
+| CPU busy (profile), of which outside page scripts | ${cpu.busyMs} / ${cpu.outsidePageMs} ms |
 | Error boundaries / page errors / console errors | ${health.errorBoundaries} / ${health.pageErrors.length} / ${health.consoleErrors.length} |
 
 ## CPU self time by module
diff --git a/apps/web/stress/stack.ts b/apps/web/stress/stack.ts
new file mode 100644
index 0000000000000..4c424d8506741
--- /dev/null
+++ b/apps/web/stress/stack.ts
@@ -0,0 +1,135 @@
+// @effect-diagnostics nodeBuiltinImport:off - shared setup for the stress rig's CLIs.
+import * as NodeChildProcess from "node:child_process";
+import * as NodeFS from "node:fs";
+import * as NodeNet from "node:net";
+import * as NodeOS from "node:os";
+import * as NodePath from "node:path";
+
+export const repo = NodePath.resolve(import.meta.dirname, "../../..");
+export const webDir = NodePath.join(repo, "apps/web");
+const serverBin = NodePath.join(repo, "apps/server/src/bin.ts");
+const replayAgent = NodePath.join(repo, "apps/server/scripts/dev-replay-agent.ts");
+
+/** Recorded pull requests outlive any one checkout, so every worktree shares them. */
+export const fixturesDir = NodePath.join(
+  process.env.XDG_CACHE_HOME ?? NodePath.join(NodeOS.homedir(), ".cache"),
+  "t3code-stress/fixtures",
+);
+
+export const log = (message: string) => console.error(`[stress] ${message}`);
+
+export const freePort = () =>
+  new Promise<number>((resolve, reject) => {
+    const server = NodeNet.createServer();
+    server.listen(0, "127.0.0.1", () => {
+      const address = server.address();
+      server.close(() =>
+        typeof address === "object" && address
+          ? resolve(address.port)
+          : reject(new Error("no port")),
+      );
+    });
+  });
+
+export const run = (command: string, args: ReadonlyArray<string>, cwd: string) =>
+  NodeChildProcess.execFileSync(command, args, {
+    cwd,
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "pipe"],
+    maxBuffer: 64 * 1024 * 1024,
+  });
+
+/** Runs the `t3` CLI from source against `home`. */
+export const t3 = (home: string, ...args: string[]) =>
+  run(process.execPath, [serverBin, ...args, "--base-dir", home], repo);
+
+/**
+ * A fresh T3 home with the Replay provider and one git workspace. `remote` names the workspace's
+ * origin, which decides the repository its pull requests come from.
+ */
+export function prepareHome(home: string, remote?: string): string {
+  NodeFS.rmSync(home, { recursive: true, force: true });
+  NodeFS.mkdirSync(NodePath.join(home, "userdata"), { recursive: true });
+  // The entry `vp run dev` seeds, written up front because this server runs without a dev URL.
+  NodeFS.writeFileSync(
+    NodePath.join(home, "userdata/settings.json"),
+    JSON.stringify({
+      // Replay turns ask before they edit; supervised threads stop there until someone answers.
+      defaultRuntimeMode: "approval-required",
+      providerInstances: {
+        devReplay: {
+          driver: "acpRegistry",
+          displayName: "Replay (dev)",
+          config: { source: "local", commandPath: process.execPath, commandArgs: [replayAgent] },
+        },
+      },
+    }),
+  );
+  const workspace = NodePath.join(home, "workspace");
+  NodeFS.mkdirSync(workspace, { recursive: true });
+  NodeFS.writeFileSync(NodePath.join(workspace, "README.md"), "# Stress workspace\n");
+  run("git", ["init", "-q"], workspace);
+  run("git", ["add", "."], workspace);
+  run(
+    "git",
+    ["-c", "user.name=stress", "-c", "user.email=stress@example.com", "commit", "-qm", "init"],
+    workspace,
+  );
+  if (remote) run("git", ["remote", "add", "origin", remote], workspace);
+  return workspace;
+}
+
+/** Starts `t3 serve` on `home`, logging to `logFile`, and resolves with its pairing URL. */
+export async function startServer(input: {
+  readonly home: string;
+  readonly port: number;
+  readonly logFile: string;
+  readonly env?: Readonly<Record<string, string>>;
+}) {
+  const child = NodeChildProcess.spawn(
+    process.execPath,
+    [serverBin, "serve", "--base-dir", input.home, "--port", String(input.port), "--no-browser"],
+    {
+      cwd: repo,
+      stdio: ["ignore", "pipe", "pipe"],
+      env: { ...process.env, NODE_ENV: "production", ...input.env },
+    },
+  );
+  const serverLog = NodeFS.createWriteStream(input.logFile);
+  child.stdout.pipe(serverLog);
+  child.stderr.pipe(serverLog);
+  const pairingUrl = await new Promise<string>((resolve, reject) => {
+    let buffered = "";
+    child.stdout.on("data", (chunk: Buffer) => {
+      buffered += chunk.toString();
+      const match = /Pairing URL: (\S+)/.exec(buffered);
+      if (match) resolve(match[1]!);
+    });
+    child.once("exit", (code) =>
+      reject(new Error(`server exited with ${code}; see ${input.logFile}`)),
+    );
+  });
+  const stop = () => {
+    if (child.exitCode === null) child.kill("SIGTERM");
+  };
+  process.once("exit", stop);
+  return { pairingUrl, stop };
+}
+
+/** `owner/name#123` or a pull request URL. */
+export function parsePullRequest(value: string) {
+  const match =
+    /^([\w.-]+)\/([\w.-]+)#(\d+)$/.exec(value) ??
+    /github\.com\/([\w.-]+)\/([\w.-]+)\/pull\/(\d+)/.exec(value);
+  if (!match) throw new Error(`Expected owner/name#number or a pull request URL, got ${value}`);
+  return { repository: `${match[1]}/${match[2]}`, number: Number(match[3]) };
+}
+
+export interface RecordedChange {
+  readonly baseSha: string;
+  readonly headSha: string;
+  readonly title: string;
+}
+
+export const changeFile = (repository: string, number: number) =>
+  NodePath.join(fixturesDir, "changes", `${repository.replace("/", "__")}__${number}.json`);
diff --git a/apps/web/stress/ui.ts b/apps/web/stress/ui.ts
new file mode 100644
index 0000000000000..744b98c9c4ba2
--- /dev/null
+++ b/apps/web/stress/ui.ts
@@ -0,0 +1,91 @@
+// @effect-diagnostics globalTimers:off - browser steps shared by the stress rig's CLIs.
+import type { Page } from "playwright";
+
+/** Opens a sidebar thread by title, expanding the collapsed groups (Working, Settled) it sits in. */
+export async function openThread(page: Page, title: string) {
+  const item = page
+    // Exact title text: badges such as a linked pull request number follow it without a space.
+    .locator('[role="treeitem"]', { has: page.getByText(title, { exact: true }) })
+    .first();
+  // Expanding one group re-renders the tree, so look for the next collapsed group each time.
+  for (let attempt = 0; attempt < 5 && !(await item.isVisible()); attempt++) {
+    const group = page
+      .locator('[role="treeitem"][aria-expanded="false"]')
+      .filter({ visible: true })
+      .first();
+    if ((await group.count()) === 0) break;
+    await group.click();
+  }
+  await item.click({ timeout: 5000 });
+  await page
+    .locator('nav[aria-label="Thread breadcrumb"]', { hasText: title })
+    .waitFor({ timeout: 10_000 });
+}
+
+/** Links a pull request to the open thread through the command palette. */
+export async function linkPullRequest(page: Page, url: string) {
+  await page.keyboard.press("Escape");
+  await page.keyboard.press("ControlOrMeta+k");
+  await page.keyboard.type("Link pull request");
+  await page
+    .getByRole("option", { name: /Link pull request to thread/ })
+    .first()
+    .click();
+  const dialog = page.getByRole("dialog", { name: "Link pull request" });
+  await dialog.getByRole("textbox").fill(url);
+  await dialog.getByRole("button", { name: "Link", exact: true }).click();
+  await dialog.waitFor({ state: "hidden" });
+}
+
+/** Opens the linked pull request from the thread details card into the right panel. */
+export async function openPullRequestPanel(page: Page, title: string) {
+  const link = page.getByText(title, { exact: true }).first();
+  // The details card is a panel the user can close; another page may have left it closed.
+  const shown = await link
+    .waitFor({ timeout: 5000 })
+    .then(() => true)
+    .catch(() => false);
+  if (!shown) {
+    await page.getByRole("button", { name: "Toggle thread details panel" }).click();
+  }
+  await link.click();
+  await pullRequestTabs(page).waitFor({ timeout: 60_000 });
+}
+
+const pullRequestTabs = (page: Page) => page.locator('nav[aria-label="Pull request tabs"]');
+
+export async function selectPullRequestTab(page: Page, tab: "Summary" | "Timeline" | "Code") {
+  await pullRequestTabs(page)
+    .locator("button", { hasText: new RegExp(`^${tab}$`) })
+    .click();
+}
+
+// Steps below run during measurement, so they use CSS selectors: role queries compute the
+// accessible name of every candidate, which costs seconds on a page this large.
+
+/** Expands the next `count` collapsed file diffs in the code tab. */
+export async function expandDiffs(page: Page, count: number) {
+  const buttons = page.locator('button[aria-label="Expand diff"]');
+  for (let index = 0; index < count && (await buttons.count()) > 0; index++) {
+    await buttons.first().click({ timeout: 5000 });
+  }
+}
+
+/** Scrolls every scrollable region to its end, so lists that load more as they show do. */
+export async function scrollEverything(page: Page, passes = 40) {
+  for (let pass = 0; pass < passes; pass++) {
+    const moved = await page.evaluate(() => {
+      let any = false;
+      for (const element of document.querySelectorAll<HTMLElement>("*")) {
+        const room = element.scrollHeight - element.clientHeight;
+        if (room > 40 && element.scrollTop < room - 4) {
+          element.scrollTop = element.scrollHeight;
+          any = true;
+        }
+      }
+      return any;
+    });
+    await page.waitForTimeout(1500);
+    if (!moved) return;
+  }
+}
diff --git a/knip.jsonc b/knip.jsonc
index 55f867e16be3a..360bc0f7a2563 100644
--- a/knip.jsonc
+++ b/knip.jsonc
@@ -94,7 +94,12 @@
     "apps/web": {
       // Worktree setup (scripts/setup-worktree.ts) runs this directly, evidence fixtures run
       // under node, and `vp run stress` runs the stress rig.
-      "entry": ["scripts/warm-dep-cache.ts", "test/fixtures/**/*.mjs", "stress/run.ts"],
+      "entry": [
+        "scripts/warm-dep-cache.ts",
+        "test/fixtures/**/*.mjs",
+        "stress/run.ts",
+        "stress/record.ts",
+      ],
       // UI component modules are copied and adapted as cohesive sets. Keep their
       // named subcomponents even before they have callers; the file audit still
       // reports an entire component module when nothing imports it.
diff --git a/package.json b/package.json
index 52593419e8625..86790f73e23bd 100644
--- a/package.json
+++ b/package.json
@@ -30,6 +30,7 @@
     "check:changed": "node scripts/check-changed.ts",
     "report:renders": "node scripts/render-metrics.ts",
     "stress": "node apps/web/stress/run.ts",
+    "stress:record-pr": "node apps/web/stress/record.ts",
     "lint": "vp lint --report-unused-disable-directives",
     "knip": "knip --preprocessor ./scripts/knip-schemas.ts",
     "knip:check": "knip --include files,dependencies --no-config-hints && knip --workspace apps/server --workspace apps/desktop --workspace apps/web --workspace packages/client-runtime --workspace packages/contracts --workspace packages/effect-acp --workspace packages/effect-codex-app-server --workspace packages/shared --workspace packages/ssh --workspace packages/tailscale --workspace packages/provider-core --workspace packages/provider-acp --workspace packages/provider-acp-registry --workspace packages/provider-testing --workspace packages/provider-pi --workspace packages/provider-muse --workspace packages/provider-opencode --workspace packages/provider-cursor --workspace packages/provider-fx --workspace packages/provider-grok --workspace packages/secret-provider-core --workspace packages/secret-provider-definitions --workspace packages/secret-provider-onepassword --workspace packages/source-control-core --workspace packages/source-control-definitions --workspace packages/source-control-azure-devops --workspace packages/source-control-bitbucket --workspace packages/source-control-forgejo --workspace packages/source-control-gitcafe --workspace packages/source-control-github --workspace packages/source-control-gitlab --workspace packages/source-control-testing --exports --preprocessor ./scripts/knip-schemas.ts --no-config-hints",

From 6eb8714835c48e5af8a064791ffc3708fbd3d201 Mon Sep 17 00:00:00 2001
From: Julius Marminge <51714798+juliusmarminge@users.noreply.github.com>
Date: Fri, 30 Oct 2026 10:08:11 -0700
Subject: [PATCH 3/5] fix(web): stress rig steps wait out a blocked page
 instead of skipping

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 apps/web/stress/ui.ts | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/apps/web/stress/ui.ts b/apps/web/stress/ui.ts
index 744b98c9c4ba2..e535698e4e241 100644
--- a/apps/web/stress/ui.ts
+++ b/apps/web/stress/ui.ts
@@ -16,7 +16,8 @@ export async function openThread(page: Page, title: string) {
     if ((await group.count()) === 0) break;
     await group.click();
   }
-  await item.click({ timeout: 5000 });
+  // A loaded page can block for seconds; the click waits it out rather than skipping the step.
+  await item.click({ timeout: 15_000 });
   await page
     .locator('nav[aria-label="Thread breadcrumb"]', { hasText: title })
     .waitFor({ timeout: 10_000 });

From 1bd4dcb365b08376c4339260586f6de513c0fc34 Mon Sep 17 00:00:00 2001
From: Julius Marminge <51714798+juliusmarminge@users.noreply.github.com>
Date: Fri, 30 Oct 2026 12:45:30 -0700
Subject: [PATCH 4/5] feat(web): `vp run stress --pr-tab timeline` keeps the
 pull request timeline open

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 apps/web/stress/README.md | 2 +-
 apps/web/stress/run.ts    | 5 +++--
 2 files changed, 4 insertions(+), 3 deletions(-)

diff --git a/apps/web/stress/README.md b/apps/web/stress/README.md
index 5624b1f91ce35..5e1c827ddc9cc 100644
--- a/apps/web/stress/README.md
+++ b/apps/web/stress/README.md
@@ -14,7 +14,7 @@ Threads run supervised, so each stops at its edit approval until the rig visits
 
 ## Huge pull requests
 
-`--pr owner/name#123` links a recorded pull request to the first thread and keeps its panel open beside the stream: the rig expands diffs and scrolls the code tab, and switches to the timeline now and then, while it visits the other threads to approve.
+`--pr owner/name#123` links a recorded pull request to the first thread and keeps its panel open beside the stream: the rig expands diffs and scrolls the code tab, and switches to the timeline now and then, while it visits the other threads to approve. `--pr-tab timeline` keeps the timeline open instead.
 
 Record a pull request once per machine with `vp run stress:record-pr owner/name#123` (needs `gh` signed in). It fetches the base and head commits into a bare clone and opens the pull request on a recording server, which saves every read the panel makes, from the pull request page and from a thread's panel. Recordings live in `~/.cache/t3code-stress/fixtures` and are shared by every checkout.
 
diff --git a/apps/web/stress/run.ts b/apps/web/stress/run.ts
index 04568b78a9658..246f000f0bbb0 100644
--- a/apps/web/stress/run.ts
+++ b/apps/web/stress/run.ts
@@ -49,6 +49,7 @@ const { values: options } = NodeUtil.parseArgs({
     duration: { type: "string", default: "60" },
     "turns-per-thread": { type: "string", default: "4" },
     pr: { type: "string" },
+    "pr-tab": { type: "string", default: "code" },
     out: { type: "string" },
     "skip-build": { type: "boolean", default: false },
     headed: { type: "boolean", default: false },
@@ -92,7 +93,7 @@ async function act(page: Page, step: number) {
   await approvePending(page);
   const tabs = page.locator('nav[aria-label="Pull request tabs"]');
   if (!(await tabs.isVisible())) await openPullRequestPanel(page, pullRequestTitle);
-  const tab = step % 6 === 5 ? "Timeline" : "Code";
+  const tab = options["pr-tab"] === "timeline" ? "Timeline" : step % 6 === 5 ? "Timeline" : "Code";
   await selectPullRequestTab(page, tab);
   if (tab === "Code") await expandDiffs(page, 4);
   // Scroll the panel, which sits on the right half of the window.
@@ -173,7 +174,7 @@ async function main() {
         `https://github.com/${pullRequest.repository}/pull/${pullRequest.number}`,
       );
       await openPullRequestPanel(page, pullRequestTitle);
-      await selectPullRequestTab(page, "Code");
+      await selectPullRequestTab(page, options["pr-tab"] === "timeline" ? "Timeline" : "Code");
     }
     await page.waitForTimeout(3000);
 

From 2d964ae7ab55cac4407de4327744af87d4d1ea4f Mon Sep 17 00:00:00 2001
From: Julius Marminge <51714798+juliusmarminge@users.noreply.github.com>
Date: Mon, 2 Nov 2026 14:06:38 -0800
Subject: [PATCH 5/5] feat(web): the stress rig measures against 60 and 120 fps
 frame budgets

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 apps/web/stress/README.md  |  3 +-
 apps/web/stress/analyze.ts | 73 ++++++++++++++++++++++++++++++++++++--
 apps/web/stress/run.ts     | 34 ++++++++++++++++--
 3 files changed, 103 insertions(+), 7 deletions(-)

diff --git a/apps/web/stress/README.md b/apps/web/stress/README.md
index 5e1c827ddc9cc..d7d5b34e26927 100644
--- a/apps/web/stress/README.md
+++ b/apps/web/stress/README.md
@@ -24,7 +24,8 @@ Reference pull requests: `pingdotgg/t3code#2829` (about 585k changed lines, 932
 
 ## Reading the report
 
-- **Frames over 33 ms** and **long animation frames** are what a user feels. The long-frame scripts table says what ran during them: `dispatchDiscreteEvent` is a click or key handler, `onMessage` is server traffic.
+- **Frames** are measured against a 60 Hz budget, the most headless Chrome presents. **Main-thread tasks over 16.7 / 8.3 ms** carry the 60 and 120 fps targets: each such task blocks at least one frame at that rate on any display, and the blocking time sums how far tasks ran past the budget. The window's `trace.json` opens in the DevTools Performance panel.
+- **Long animation frames** are the frames a user feels as a hitch. The long-frame scripts table says what ran during them: `dispatchDiscreteEvent` is a click or key handler, `onMessage` is server traffic.
 - **CPU self time by module** splits the profile by package and source file. **By function** points at the hot code. Samples with no page script on the stack (the rig's own Playwright work, browser internals) are counted apart.
 - **Most rendered components** counts React renders over the window. A component that renders far more often than what it shows changes is the usual lead.
 - **JS heap** and **DOM nodes** are sampled each step; a climb across the run is a leak or unbounded list.
diff --git a/apps/web/stress/analyze.ts b/apps/web/stress/analyze.ts
index dd64581811e7b..413948d0b9a50 100644
--- a/apps/web/stress/analyze.ts
+++ b/apps/web/stress/analyze.ts
@@ -22,23 +22,90 @@ export interface FrameSummary {
   readonly p95Ms: number;
   readonly p99Ms: number;
   readonly maxMs: number;
-  /** Frames that took longer than two 60 Hz intervals, so at least one frame was dropped. */
-  readonly droppedFrames: number;
+  readonly fps: number;
+  /** Frames that missed at least one 60 Hz vsync. Headless Chrome presents at 60 Hz at most. */
+  readonly missed60Hz: number;
 }
 
 const percentile = (sorted: ReadonlyArray<number>, p: number) =>
   sorted.length === 0 ? 0 : sorted[Math.min(sorted.length - 1, Math.floor(sorted.length * p))]!;
 const round = (value: number) => Math.round(value * 10) / 10;
 
+const BUDGET_60HZ_MS = 1000 / 60;
+const BUDGET_120HZ_MS = 1000 / 120;
+
 export function summarizeFrames(frames: ReadonlyArray<number>): FrameSummary {
   const sorted = frames.toSorted((a, b) => a - b);
+  const totalMs = frames.reduce((sum, frame) => sum + frame, 0);
   return {
     frames: frames.length,
     p50Ms: round(percentile(sorted, 0.5)),
     p95Ms: round(percentile(sorted, 0.95)),
     p99Ms: round(percentile(sorted, 0.99)),
     maxMs: round(sorted.at(-1) ?? 0),
-    droppedFrames: frames.filter((frame) => frame > 1000 / 30).length,
+    fps: totalMs === 0 ? 0 : round((frames.length * 1000) / totalMs),
+    // Intervals land on whole vsyncs, so anything past one and a half is a missed one.
+    missed60Hz: frames.filter((frame) => frame > BUDGET_60HZ_MS * 1.5).length,
+  };
+}
+
+export interface TraceEvent {
+  readonly ph: string;
+  readonly name: string;
+  readonly pid: number;
+  readonly tid: number;
+  readonly ts: number;
+  readonly dur?: number;
+  readonly args?: { readonly name?: string };
+}
+
+export interface TaskSummary {
+  readonly tasks: number;
+  readonly longestMs: number;
+  /** Tasks longer than a frame budget; each one blocks at least one frame at that rate. */
+  readonly over60Hz: number;
+  readonly over120Hz: number;
+  /** Time past the budget summed over tasks, like Lighthouse's total blocking time. */
+  readonly blockedMs60Hz: number;
+  readonly blockedMs120Hz: number;
+}
+
+/**
+ * Main-thread tasks of the page from a `toplevel` trace. A task over 8.3 ms blocks a 120 Hz
+ * frame on any display, which frame intervals cannot show while headless Chrome caps at 60 Hz.
+ */
+export function summarizeTasks(events: ReadonlyArray<TraceEvent>): TaskSummary {
+  const rendererMain = new Set(
+    events
+      .filter((event) => event.ph === "M" && event.name === "thread_name")
+      .filter((event) => event.args?.name === "CrRendererMain")
+      .map((event) => `${event.pid}:${event.tid}`),
+  );
+  const byThread = new Map<string, number[]>();
+  for (const event of events) {
+    const thread = `${event.pid}:${event.tid}`;
+    if (event.ph !== "X" || event.name !== "ThreadControllerImpl::RunTask") continue;
+    if (!rendererMain.has(thread)) continue;
+    let durations = byThread.get(thread);
+    if (!durations) byThread.set(thread, (durations = []));
+    durations.push((event.dur ?? 0) / 1000);
+  }
+  // The app's renderer is the busy one; others (about:blank, spare renderers) barely run.
+  const durations = [...byThread.values()].reduce<number[]>(
+    (busiest, thread) =>
+      thread.reduce((a, b) => a + b, 0) > busiest.reduce((a, b) => a + b, 0) ? thread : busiest,
+    [],
+  );
+  const over = (budget: number) => durations.filter((ms) => ms > budget);
+  const blocked = (budget: number) =>
+    Math.round(over(budget).reduce((sum, ms) => sum + ms - budget, 0));
+  return {
+    tasks: durations.length,
+    longestMs: round(durations.reduce((longest, ms) => Math.max(longest, ms), 0)),
+    over60Hz: over(BUDGET_60HZ_MS).length,
+    over120Hz: over(BUDGET_120HZ_MS).length,
+    blockedMs60Hz: blocked(BUDGET_60HZ_MS),
+    blockedMs120Hz: blocked(BUDGET_120HZ_MS),
   };
 }
 
diff --git a/apps/web/stress/run.ts b/apps/web/stress/run.ts
index 246f000f0bbb0..ddfc400000ec5 100644
--- a/apps/web/stress/run.ts
+++ b/apps/web/stress/run.ts
@@ -10,7 +10,14 @@ import * as NodePath from "node:path";
 import * as NodeUtil from "node:util";
 import { chromium, type Page } from "playwright";
 
-import { longFrameScripts, summarizeFrames, summarizeProfile, type CpuProfile } from "./analyze.ts";
+import {
+  longFrameScripts,
+  summarizeFrames,
+  summarizeProfile,
+  summarizeTasks,
+  type CpuProfile,
+  type TraceEvent,
+} from "./analyze.ts";
 import { installStressProbe } from "./probe.ts";
 import {
   changeFile,
@@ -192,6 +199,7 @@ async function main() {
     const samples: Array<{ atMs: number; heapMb: number; nodes: number }> = [];
     const before = await metrics();
     await cdp.send("Profiler.start");
+    await cdp.send("Tracing.start", { categories: "toplevel", transferMode: "ReturnAsStream" });
     await page.evaluate(() =>
       (window as unknown as { __stress: { start(): void } }).__stress.start(),
     );
@@ -231,6 +239,21 @@ async function main() {
       errors: string[];
     };
     const { profile } = (await cdp.send("Profiler.stop")) as { profile: CpuProfile };
+    const traced = new Promise<{ stream?: string }>((resolve) =>
+      cdp.once("Tracing.tracingComplete", resolve),
+    );
+    await cdp.send("Tracing.end");
+    const { stream } = await traced;
+    let trace = "";
+    for (let eof = !stream; !eof;) {
+      const chunk = await cdp.send("IO.read", { handle: stream! });
+      trace += chunk.base64Encoded ? Buffer.from(chunk.data, "base64").toString() : chunk.data;
+      eof = chunk.eof;
+    }
+    NodeFS.writeFileSync(NodePath.join(outDir, "trace.json"), trace);
+    const parsedTrace = JSON.parse(trace || "[]") as
+      | ReadonlyArray<TraceEvent>
+      | { traceEvents: ReadonlyArray<TraceEvent> };
     const after = await metrics();
     NodeFS.writeFileSync(NodePath.join(outDir, "profile.cpuprofile"), JSON.stringify(profile));
     const crashed = await page.getByText("Something went wrong").count();
@@ -253,6 +276,7 @@ async function main() {
         style: seconds("RecalcStyleDuration"),
       },
       frames: summarizeFrames(probe.frames),
+      tasks: summarizeTasks("traceEvents" in parsedTrace ? parsedTrace.traceEvents : parsedTrace),
       longAnimationFrames: {
         count: probe.longFrames.length,
         totalMs: Math.round(probe.longFrames.reduce((sum, frame) => sum + frame.duration, 0)),
@@ -295,6 +319,7 @@ function report(summary: {
   config: Record<string, number>;
   mainThreadMs: Record<string, number>;
   frames: ReturnType<typeof summarizeFrames>;
+  tasks: ReturnType<typeof summarizeTasks>;
   longAnimationFrames: {
     count: number;
     totalMs: number;
@@ -309,7 +334,7 @@ function report(summary: {
 }): string {
   const rows = (entries: ReadonlyArray<readonly [string, number]>, unit: string) =>
     entries.map(([name, value]) => `| ${value} ${unit} | \`${name}\` |`).join("\n");
-  const { frames, longAnimationFrames: laf, memory, react, cpu, health } = summary;
+  const { frames, tasks, longAnimationFrames: laf, memory, react, cpu, health } = summary;
   return `# Stress run ${summary.runId}
 
 ${summary.config.threads} streaming threads${summary.pullRequest ? `, pull request ${summary.pullRequest} open` : ""}, ${summary.config.durationS}s, ${summary.config.steps} user steps.
@@ -318,7 +343,10 @@ ${summary.config.threads} streaming threads${summary.pullRequest ? `, pull reque
 | --- | ---: |
 | Main-thread task / script / layout / style | ${summary.mainThreadMs.task} / ${summary.mainThreadMs.script} / ${summary.mainThreadMs.layout} / ${summary.mainThreadMs.style} ms |
 | Frames: p50 / p95 / p99 / max | ${frames.p50Ms} / ${frames.p95Ms} / ${frames.p99Ms} / ${frames.maxMs} ms |
-| Frames over 33 ms (dropped) | ${frames.droppedFrames} of ${frames.frames} |
+| Frame rate (headless caps at 60) | ${frames.fps} fps |
+| Frames that missed a 60 Hz vsync | ${frames.missed60Hz} of ${frames.frames} |
+| Main-thread tasks over 16.7 / 8.3 ms (each blocks a 60 / 120 Hz frame) | ${tasks.over60Hz} / ${tasks.over120Hz} of ${tasks.tasks} |
+| Blocking time past 16.7 / 8.3 ms, longest task | ${tasks.blockedMs60Hz} / ${tasks.blockedMs120Hz} / ${tasks.longestMs} ms |
 | Long animation frames: count / total / blocking / worst | ${laf.count} / ${laf.totalMs} / ${laf.blockingMs} / ${laf.worstMs} ms |
 | JS heap: start / end / max | ${memory.heapMbStart} / ${memory.heapMbEnd} / ${memory.heapMbMax} MB |
 | DOM nodes at end | ${memory.domNodesEnd} |