diff --git a/apps/code/package.json b/apps/code/package.json
index 78a4c1ab1..528cb19a0 100644
--- a/apps/code/package.json
+++ b/apps/code/package.json
@@ -126,7 +126,7 @@
     "@opentelemetry/semantic-conventions": "^1.39.0",
     "@parcel/watcher": "^2.5.6",
     "@phosphor-icons/react": "^2.1.10",
-    "@pierre/diffs": "^1.1.7",
+    "@pierre/diffs": "^1.1.21",
     "@posthog/agent": "workspace:*",
     "@posthog/electron-trpc": "workspace:*",
     "@posthog/enricher": "workspace:*",
diff --git a/apps/code/src/main/services/fs/schemas.ts b/apps/code/src/main/services/fs/schemas.ts
index 7f8730b92..971ddedb6 100644
--- a/apps/code/src/main/services/fs/schemas.ts
+++ b/apps/code/src/main/services/fs/schemas.ts
@@ -11,6 +11,34 @@ export const readRepoFileInput = z.object({
   filePath: z.string(),
 });
 
+export const readRepoFilesInput = z.object({
+  repoPath: z.string(),
+  filePaths: z.array(z.string()),
+});
+
+export const readRepoFileBoundedInput = z.object({
+  repoPath: z.string(),
+  filePath: z.string(),
+  maxLines: z.number().int().positive(),
+});
+
+export const readRepoFilesBoundedInput = z.object({
+  repoPath: z.string(),
+  filePaths: z.array(z.string()),
+  maxLines: z.number().int().positive(),
+});
+
+export const boundedReadResult = z.discriminatedUnion("kind", [
+  z.object({ kind: z.literal("content"), content: z.string() }),
+  z.object({ kind: z.literal("missing") }),
+  z.object({ kind: z.literal("too-large") }),
+]);
+
+export const readRepoFilesBoundedOutput = z.record(
+  z.string(),
+  boundedReadResult,
+);
+
 export const readAbsoluteFileInput = z.object({
   filePath: z.string(),
 });
@@ -32,9 +60,12 @@ const fileEntry = z.object({
 
 export const listRepoFilesOutput = z.array(fileEntry);
 export const readRepoFileOutput = z.string().nullable();
+export const readRepoFilesOutput = z.record(z.string(), readRepoFileOutput);
 
 export type ListRepoFilesInput = z.infer<typeof listRepoFilesInput>;
 export type ReadRepoFileInput = z.infer<typeof readRepoFileInput>;
+export type ReadRepoFilesInput = z.infer<typeof readRepoFilesInput>;
 export type WriteRepoFileInput = z.infer<typeof writeRepoFileInput>;
 export type FileEntry = z.infer<typeof fileEntry>;
 export type FileEntryKind = z.infer<typeof fileEntryKind>;
+export type BoundedReadResult = z.infer<typeof boundedReadResult>;
diff --git a/apps/code/src/main/services/fs/service.ts b/apps/code/src/main/services/fs/service.ts
index 2dcf62847..189a5a739 100644
--- a/apps/code/src/main/services/fs/service.ts
+++ b/apps/code/src/main/services/fs/service.ts
@@ -6,13 +6,14 @@ import { MAIN_TOKENS } from "../../di/tokens";
 import { logger } from "../../utils/logger";
 import { FileWatcherEvent } from "../file-watcher/schemas";
 import type { FileWatcherService } from "../file-watcher/service";
-import type { FileEntry } from "./schemas";
+import type { BoundedReadResult, FileEntry } from "./schemas";
 
 const log = logger.scope("fs");
 
 @injectable()
 export class FsService {
   private static readonly CACHE_TTL = 30000;
+  private static readonly READ_REPO_FILES_CONCURRENCY = 24;
   private cache = new Map<string, { files: FileEntry[]; timestamp: number }>();
 
   constructor(
@@ -101,13 +102,70 @@ export class FsService {
         "utf-8",
       );
     } catch (error) {
-      if ((error as NodeJS.ErrnoException).code !== "ENOENT") {
+      const code = (error as NodeJS.ErrnoException).code;
+      if (code !== "ENOENT" && code !== "EISDIR") {
         log.error(`Failed to read file ${filePath}:`, error);
       }
       return null;
     }
   }
 
+  async readRepoFiles(
+    repoPath: string,
+    filePaths: string[],
+  ): Promise<Record<string, string | null>> {
+    const uniqueFilePaths = [...new Set(filePaths)];
+    const entries = await this.mapWithConcurrency(
+      uniqueFilePaths,
+      FsService.READ_REPO_FILES_CONCURRENCY,
+      async (filePath) =>
+        [filePath, await this.readRepoFile(repoPath, filePath)] as const,
+    );
+    return Object.fromEntries(entries);
+  }
+
+  async readRepoFileBounded(
+    repoPath: string,
+    filePath: string,
+    maxLines: number,
+  ): Promise<BoundedReadResult> {
+    try {
+      const content = await fs.promises.readFile(
+        this.resolvePath(repoPath, filePath),
+        "utf-8",
+      );
+      if (exceedsLineLimit(content, maxLines)) {
+        return { kind: "too-large" };
+      }
+      return { kind: "content", content };
+    } catch (error) {
+      const code = (error as NodeJS.ErrnoException).code;
+      if (code === "ENOENT" || code === "EISDIR") {
+        return { kind: "missing" };
+      }
+      log.error(`Failed to read file ${filePath}:`, error);
+      return { kind: "missing" };
+    }
+  }
+
+  async readRepoFilesBounded(
+    repoPath: string,
+    filePaths: string[],
+    maxLines: number,
+  ): Promise<Record<string, BoundedReadResult>> {
+    const uniqueFilePaths = [...new Set(filePaths)];
+    const entries = await this.mapWithConcurrency(
+      uniqueFilePaths,
+      FsService.READ_REPO_FILES_CONCURRENCY,
+      async (filePath) =>
+        [
+          filePath,
+          await this.readRepoFileBounded(repoPath, filePath, maxLines),
+        ] as const,
+    );
+    return Object.fromEntries(entries);
+  }
+
   async readAbsoluteFile(filePath: string): Promise<string | null> {
     try {
       return await fs.promises.readFile(path.resolve(filePath), "utf-8");
@@ -166,12 +224,12 @@ export class FsService {
   }
 
   private resolvePath(repoPath: string, filePath: string): string {
-    const fullPath = path.join(repoPath, filePath);
-    const resolved = path.resolve(fullPath);
-    if (!resolved.startsWith(path.resolve(repoPath))) {
+    const base = path.resolve(repoPath);
+    const resolved = path.resolve(base, filePath);
+    if (resolved !== base && !resolved.startsWith(base + path.sep)) {
       throw new Error("Access denied: path outside repository");
     }
-    return fullPath;
+    return resolved;
   }
 
   private toFileEntries(
@@ -206,4 +264,43 @@ export class FsService {
     }
     return Array.from(dirs).sort();
   }
+
+  private async mapWithConcurrency<T, R>(
+    items: readonly T[],
+    concurrency: number,
+    mapper: (item: T) => Promise<R>,
+  ): Promise<R[]> {
+    if (items.length === 0) return [];
+
+    const results = new Array<R>(items.length);
+    let index = 0;
+
+    const worker = async () => {
+      while (index < items.length) {
+        const currentIndex = index++;
+        results[currentIndex] = await mapper(items[currentIndex]);
+      }
+    };
+
+    await Promise.all(
+      Array.from({ length: Math.min(concurrency, items.length) }, () =>
+        worker(),
+      ),
+    );
+
+    return results;
+  }
+}
+
+function exceedsLineLimit(content: string, maxLines: number): boolean {
+  let lineCount = 1;
+  for (let i = 0; i < content.length; i++) {
+    if (content.charCodeAt(i) === 10) {
+      lineCount++;
+      if (lineCount > maxLines) {
+        return true;
+      }
+    }
+  }
+  return false;
 }
diff --git a/apps/code/src/main/services/git/service.ts b/apps/code/src/main/services/git/service.ts
index 90d789d0b..4ab8709f7 100644
--- a/apps/code/src/main/services/git/service.ts
+++ b/apps/code/src/main/services/git/service.ts
@@ -310,14 +310,34 @@ export class GitService extends TypedEventEmitter<GitServiceEvents> {
     const files = await getChangedFilesDetailed(directoryPath, {
       excludePatterns: [".claude", "CLAUDE.local.md"],
     });
-    return files.map((f) => ({
-      path: f.path,
-      status: f.status,
-      originalPath: f.originalPath,
-      linesAdded: f.linesAdded,
-      linesRemoved: f.linesRemoved,
-      staged: f.staged,
-    }));
+    type HeadChangedFile = Omit<ChangedFile, "patch">;
+    const filteredFiles: Array<HeadChangedFile | null> = await Promise.all(
+      files.map(async (file) => {
+        if (file.status === "untracked") {
+          try {
+            const stats = await fs.promises.stat(
+              path.join(directoryPath, file.path),
+            );
+            if (!stats.isFile()) return null;
+          } catch {
+            return null;
+          }
+        }
+
+        return {
+          path: file.path,
+          status: file.status,
+          originalPath: file.originalPath,
+          linesAdded: file.linesAdded,
+          linesRemoved: file.linesRemoved,
+          staged: file.staged,
+        };
+      }),
+    );
+
+    return filteredFiles.filter(
+      (file): file is HeadChangedFile => file !== null,
+    );
   }
 
   public async getFileAtHead(
diff --git a/apps/code/src/main/trpc/routers/fs.ts b/apps/code/src/main/trpc/routers/fs.ts
index 1aede0b35..eaff0fb42 100644
--- a/apps/code/src/main/trpc/routers/fs.ts
+++ b/apps/code/src/main/trpc/routers/fs.ts
@@ -1,11 +1,17 @@
 import { container } from "../../di/container";
 import { MAIN_TOKENS } from "../../di/tokens";
 import {
+  boundedReadResult,
   listRepoFilesInput,
   listRepoFilesOutput,
   readAbsoluteFileInput,
+  readRepoFileBoundedInput,
   readRepoFileInput,
   readRepoFileOutput,
+  readRepoFilesBoundedInput,
+  readRepoFilesBoundedOutput,
+  readRepoFilesInput,
+  readRepoFilesOutput,
   writeRepoFileInput,
 } from "../../services/fs/schemas";
 import type { FsService } from "../../services/fs/service";
@@ -28,6 +34,35 @@ export const fsRouter = router({
       getService().readRepoFile(input.repoPath, input.filePath),
     ),
 
+  readRepoFiles: publicProcedure
+    .input(readRepoFilesInput)
+    .output(readRepoFilesOutput)
+    .query(({ input }) =>
+      getService().readRepoFiles(input.repoPath, input.filePaths),
+    ),
+
+  readRepoFileBounded: publicProcedure
+    .input(readRepoFileBoundedInput)
+    .output(boundedReadResult)
+    .query(({ input }) =>
+      getService().readRepoFileBounded(
+        input.repoPath,
+        input.filePath,
+        input.maxLines,
+      ),
+    ),
+
+  readRepoFilesBounded: publicProcedure
+    .input(readRepoFilesBoundedInput)
+    .output(readRepoFilesBoundedOutput)
+    .query(({ input }) =>
+      getService().readRepoFilesBounded(
+        input.repoPath,
+        input.filePaths,
+        input.maxLines,
+      ),
+    ),
+
   readAbsoluteFile: publicProcedure
     .input(readAbsoluteFileInput)
     .output(readRepoFileOutput)
diff --git a/apps/code/src/renderer/components/TreeDirectoryRow.tsx b/apps/code/src/renderer/components/TreeDirectoryRow.tsx
index 7dee21d32..8e62497bb 100644
--- a/apps/code/src/renderer/components/TreeDirectoryRow.tsx
+++ b/apps/code/src/renderer/components/TreeDirectoryRow.tsx
@@ -71,6 +71,7 @@ interface TreeFileRowProps {
   fileName: string;
   depth: number;
   isActive?: boolean;
+  title?: string;
   onClick?: () => void;
   onDoubleClick?: () => void;
   onContextMenu?: (e: React.MouseEvent) => void;
@@ -84,6 +85,7 @@ export function TreeFileRow({
   fileName,
   depth,
   isActive = false,
+  title,
   onClick,
   onDoubleClick,
   onContextMenu,
@@ -95,6 +97,7 @@ export function TreeFileRow({
     <Flex
       align="center"
       gap="1"
+      title={title}
       onClick={onClick}
       onDoubleClick={onDoubleClick}
       onContextMenu={onContextMenu}
diff --git a/apps/code/src/renderer/features/code-review/components/CloudReviewPage.tsx b/apps/code/src/renderer/features/code-review/components/CloudReviewPage.tsx
index ff29e93de..3bbb8d910 100644
--- a/apps/code/src/renderer/features/code-review/components/CloudReviewPage.tsx
+++ b/apps/code/src/renderer/features/code-review/components/CloudReviewPage.tsx
@@ -6,8 +6,13 @@ import { Flex, Spinner, Text } from "@radix-ui/themes";
 import { useReviewNavigationStore } from "@renderer/features/code-review/stores/reviewNavigationStore";
 import type { Task } from "@shared/types";
 import { useMemo } from "react";
-import { RemoteDiffList } from "./RemoteDiffList";
-import { ReviewShell, useReviewState } from "./ReviewShell";
+import { PatchedFileDiff } from "./PatchedFileDiff";
+import {
+  buildItemIndex,
+  type ReviewListItem,
+  ReviewShell,
+  useReviewState,
+} from "./ReviewShell";
 
 interface CloudReviewPageProps {
   task: Task;
@@ -43,8 +48,6 @@ export function CloudReviewPage({ task }: CloudReviewPageProps) {
     expandAll,
     collapseAll,
     uncollapseFile,
-    revealFile,
-    getDeferredReason,
   } = useReviewState(reviewFiles, allPaths);
 
   const toolCallFallbacks = useMemo(() => {
@@ -60,6 +63,45 @@ export function CloudReviewPage({ task }: CloudReviewPageProps) {
     return diffs;
   }, [remoteFiles.length, toolCalls, reviewFiles]);
 
+  const items = useMemo<ReviewListItem[]>(() => {
+    return reviewFiles.map((file) => {
+      const isCollapsed = collapsedFiles.has(file.path);
+      const githubFileUrl = prUrl
+        ? `${prUrl}/files#diff-${file.path.replaceAll("/", "-")}`
+        : undefined;
+
+      return {
+        key: file.path,
+        scrollKey: file.path,
+        node: (
+          <PatchedFileDiff
+            file={file}
+            taskId={taskId}
+            prUrl={prUrl}
+            options={diffOptions}
+            collapsed={isCollapsed}
+            onToggle={() => toggleFile(file.path)}
+            commentThreads={showReviewComments ? commentThreads : undefined}
+            fallback={toolCallFallbacks?.get(file.path) ?? null}
+            externalUrl={githubFileUrl}
+          />
+        ),
+      };
+    });
+  }, [
+    collapsedFiles,
+    commentThreads,
+    diffOptions,
+    prUrl,
+    reviewFiles,
+    showReviewComments,
+    taskId,
+    toggleFile,
+    toolCallFallbacks,
+  ]);
+
+  const itemIndexByFilePath = useMemo(() => buildItemIndex(items), [items]);
+
   if (!prUrl && !effectiveBranch && reviewFiles.length === 0) {
     if (isRunActive) {
       return (
@@ -91,19 +133,8 @@ export function CloudReviewPage({ task }: CloudReviewPageProps) {
       onExpandAll={expandAll}
       onCollapseAll={collapseAll}
       onUncollapseFile={uncollapseFile}
-    >
-      <RemoteDiffList
-        files={reviewFiles}
-        taskId={taskId}
-        prUrl={prUrl}
-        options={diffOptions}
-        collapsedFiles={collapsedFiles}
-        toggleFile={toggleFile}
-        revealFile={revealFile}
-        getDeferredReason={getDeferredReason}
-        commentThreads={showReviewComments ? commentThreads : undefined}
-        fallbacks={toolCallFallbacks}
-      />
-    </ReviewShell>
+      items={items}
+      itemIndexByFilePath={itemIndexByFilePath}
+    />
   );
 }
diff --git a/apps/code/src/renderer/features/code-review/components/DiffStatsBadge.tsx b/apps/code/src/renderer/features/code-review/components/DiffStatsBadge.tsx
index 655fa0726..1b8ac3a1d 100644
--- a/apps/code/src/renderer/features/code-review/components/DiffStatsBadge.tsx
+++ b/apps/code/src/renderer/features/code-review/components/DiffStatsBadge.tsx
@@ -6,29 +6,16 @@ import {
   formatHotkey,
   SHORTCUTS,
 } from "@renderer/constants/keyboard-shortcuts";
-import { useReviewNavigationStore } from "@renderer/features/code-review/stores/reviewNavigationStore";
 import type { Task } from "@shared/types";
-import { useTaskDiffStats } from "../hooks/useTaskDiffStats";
+import { useDiffStatsToggle } from "../hooks/useDiffStatsToggle";
 
 interface DiffStatsBadgeProps {
   task: Task;
 }
 
 export function DiffStatsBadge({ task }: DiffStatsBadgeProps) {
-  const taskId = task.id;
-  const { filesChanged, linesAdded, linesRemoved } = useTaskDiffStats(task);
-
-  const reviewMode = useReviewNavigationStore(
-    (s) => s.reviewModes[taskId] ?? "closed",
-  );
-  const setReviewMode = useReviewNavigationStore((s) => s.setReviewMode);
-
-  const hasChanges = filesChanged > 0;
-  const isOpen = reviewMode !== "closed";
-
-  const handleClick = () => {
-    setReviewMode(taskId, isOpen ? "closed" : "split");
-  };
+  const { linesAdded, linesRemoved, hasChanges, isOpen, toggle } =
+    useDiffStatsToggle(task, "split");
 
   return (
     <Tooltip
@@ -37,7 +24,7 @@ export function DiffStatsBadge({ task }: DiffStatsBadgeProps) {
       side="bottom"
     >
       <Button
-        onClick={handleClick}
+        onClick={toggle}
         variant="outline"
         size="sm"
         className={`no-drag font-mono text-(--gray-11) text-[11px] transition-colors duration-100 hover:bg-(--gray-a3) ${isOpen ? "bg-(--gray-a3)" : "bg-transparent"}`}
diff --git a/apps/code/src/renderer/features/code-review/components/InteractiveFileDiff.tsx b/apps/code/src/renderer/features/code-review/components/InteractiveFileDiff.tsx
index bf58ece60..e2a2ecf53 100644
--- a/apps/code/src/renderer/features/code-review/components/InteractiveFileDiff.tsx
+++ b/apps/code/src/renderer/features/code-review/components/InteractiveFileDiff.tsx
@@ -5,9 +5,11 @@ import {
   parseDiffFromFile,
 } from "@pierre/diffs";
 import { FileDiff, MultiFileDiff } from "@pierre/diffs/react";
+import { useInView } from "@renderer/hooks/useInView";
 import { trpcClient, useTRPC } from "@renderer/trpc/client";
 import { useQueryClient } from "@tanstack/react-query";
 import { useCallback, useMemo, useRef, useState } from "react";
+import { DIFF_METRICS, REVIEW_PREFETCH_ROOT_MARGIN } from "../constants";
 import { useCommentState } from "../hooks/useCommentState";
 import { useExpandableFileDiff } from "../hooks/useExpandableFileDiff";
 import type {
@@ -86,6 +88,20 @@ function HunkRevertButton({
   );
 }
 
+function ExpansionPlaceholder({
+  patchFileDiff,
+  renderCustomHeader,
+}: {
+  patchFileDiff: PatchDiffProps["fileDiff"];
+  renderCustomHeader?: PatchDiffProps["renderCustomHeader"];
+}) {
+  return (
+    <div className="overflow-hidden rounded-(--radius-2) border border-(--gray-5) bg-(--gray-2)">
+      {renderCustomHeader?.(patchFileDiff)}
+    </div>
+  );
+}
+
 function isPatchDiff(props: InteractiveFileDiffProps): props is PatchDiffProps {
   return "fileDiff" in props && props.fileDiff != null;
 }
@@ -109,11 +125,15 @@ function PatchDiffView({
 }: PatchDiffProps) {
   const trpc = useTRPC();
   const queryClient = useQueryClient();
-  const initialFileDiff = useExpandableFileDiff(
-    patchFileDiff,
-    repoPath,
-    skipExpansion,
-  );
+  const [containerRef, inView] = useInView<HTMLDivElement>({
+    rootMargin: REVIEW_PREFETCH_ROOT_MARGIN,
+    once: true,
+  });
+  const {
+    fileDiff: initialFileDiff,
+    tooLarge,
+    pending,
+  } = useExpandableFileDiff(patchFileDiff, repoPath, skipExpansion, inView);
   const [fileDiff, setFileDiff] = useState(initialFileDiff);
   const [revertingHunks, setRevertingHunks] = useState<Set<number>>(
     () => new Set(),
@@ -248,14 +268,30 @@ function PatchDiffView({
   );
 
   return (
-    <FileDiff
-      fileDiff={fileDiff}
-      options={mergedOptions}
-      lineAnnotations={annotations}
-      selectedLines={selectedRange}
-      renderAnnotation={renderAnnotation}
-      renderCustomHeader={renderCustomHeader}
-    />
+    <div ref={containerRef}>
+      {pending ? (
+        <ExpansionPlaceholder
+          patchFileDiff={patchFileDiff}
+          renderCustomHeader={renderCustomHeader}
+        />
+      ) : (
+        <FileDiff
+          fileDiff={fileDiff}
+          options={mergedOptions}
+          lineAnnotations={annotations}
+          selectedLines={selectedRange}
+          renderAnnotation={renderAnnotation}
+          renderCustomHeader={renderCustomHeader}
+          metrics={DIFF_METRICS}
+        />
+      )}
+      {tooLarge && (
+        <div className="border-(--gray-5) border-t bg-(--gray-2) px-3 py-1.5 text-(--gray-10) text-[12px]">
+          File exceeds the 5,000-line review limit — surrounding context is
+          hidden.
+        </div>
+      )}
+    </div>
   );
 }
 
@@ -320,6 +356,7 @@ function FilesDiffView({
       selectedLines={selectedRange}
       renderAnnotation={renderAnnotation}
       renderCustomHeader={renderCustomHeader}
+      metrics={DIFF_METRICS}
     />
   );
 }
diff --git a/apps/code/src/renderer/features/code-review/components/LazyDiff.tsx b/apps/code/src/renderer/features/code-review/components/LazyDiff.tsx
deleted file mode 100644
index 73bcf400b..000000000
--- a/apps/code/src/renderer/features/code-review/components/LazyDiff.tsx
+++ /dev/null
@@ -1,31 +0,0 @@
-import { type ReactNode, useEffect, useRef, useState } from "react";
-
-const VISIBILITY_MARGIN = 1500;
-
-interface LazyDiffProps {
-  children: ReactNode;
-}
-
-export function LazyDiff({ children }: LazyDiffProps) {
-  const ref = useRef<HTMLDivElement>(null);
-  const [mounted, setMounted] = useState(false);
-
-  useEffect(() => {
-    const el = ref.current;
-    if (!el || mounted) return;
-
-    const observer = new IntersectionObserver(
-      ([entry]) => {
-        if (entry.isIntersecting) {
-          setMounted(true);
-          observer.disconnect();
-        }
-      },
-      { rootMargin: `${VISIBILITY_MARGIN}px 0px` },
-    );
-    observer.observe(el);
-    return () => observer.disconnect();
-  }, [mounted]);
-
-  return <div ref={ref}>{mounted ? children : null}</div>;
-}
diff --git a/apps/code/src/renderer/features/code-review/components/PatchedFileDiff.tsx b/apps/code/src/renderer/features/code-review/components/PatchedFileDiff.tsx
index 066477a0f..53b393c85 100644
--- a/apps/code/src/renderer/features/code-review/components/PatchedFileDiff.tsx
+++ b/apps/code/src/renderer/features/code-review/components/PatchedFileDiff.tsx
@@ -47,13 +47,12 @@ export function PatchedFileDiff({
   }, [fileDiff, fallback, file.path]);
 
   if (!diffSourceProps) {
-    const hasChanges = (file.linesAdded ?? 0) + (file.linesRemoved ?? 0) > 0;
     return (
       <DeferredDiffPlaceholder
         filePath={file.path}
         linesAdded={file.linesAdded ?? 0}
         linesRemoved={file.linesRemoved ?? 0}
-        reason={hasChanges ? "large" : "unavailable"}
+        reason="unavailable"
         collapsed={collapsed}
         onToggle={onToggle}
         externalUrl={externalUrl}
diff --git a/apps/code/src/renderer/features/code-review/components/RemoteDiffList.tsx b/apps/code/src/renderer/features/code-review/components/RemoteDiffList.tsx
deleted file mode 100644
index 8b4c2920b..000000000
--- a/apps/code/src/renderer/features/code-review/components/RemoteDiffList.tsx
+++ /dev/null
@@ -1,75 +0,0 @@
-import type { ChangedFile } from "@shared/types";
-import type { DiffOptions } from "../types";
-import type { PrCommentThread } from "../utils/prCommentAnnotations";
-import { LazyDiff } from "./LazyDiff";
-import { PatchedFileDiff } from "./PatchedFileDiff";
-import { DeferredDiffPlaceholder, type DeferredReason } from "./ReviewShell";
-
-interface RemoteDiffListProps {
-  files: ChangedFile[];
-  taskId: string;
-  options: DiffOptions;
-  collapsedFiles: Set<string>;
-  toggleFile: (path: string) => void;
-  revealFile: (path: string) => void;
-  getDeferredReason: (path: string) => DeferredReason | null;
-  prUrl?: string | null;
-  commentThreads?: Map<number, PrCommentThread>;
-  fallbacks?: Map<string, { oldText: string | null; newText: string | null }>;
-}
-
-export function RemoteDiffList({
-  files,
-  taskId,
-  options,
-  collapsedFiles,
-  toggleFile,
-  revealFile,
-  getDeferredReason,
-  prUrl,
-  commentThreads,
-  fallbacks,
-}: RemoteDiffListProps) {
-  return files.map((file) => {
-    const isCollapsed = collapsedFiles.has(file.path);
-    const deferredReason = getDeferredReason(file.path);
-
-    if (deferredReason) {
-      return (
-        <div key={file.path} data-file-path={file.path}>
-          <DeferredDiffPlaceholder
-            filePath={file.path}
-            linesAdded={file.linesAdded ?? 0}
-            linesRemoved={file.linesRemoved ?? 0}
-            reason={deferredReason}
-            collapsed={isCollapsed}
-            onToggle={() => toggleFile(file.path)}
-            onShow={() => revealFile(file.path)}
-          />
-        </div>
-      );
-    }
-
-    const githubFileUrl = prUrl
-      ? `${prUrl}/files#diff-${file.path.replaceAll("/", "-")}`
-      : undefined;
-
-    return (
-      <div key={file.path} data-file-path={file.path}>
-        <LazyDiff>
-          <PatchedFileDiff
-            file={file}
-            taskId={taskId}
-            prUrl={prUrl}
-            options={options}
-            collapsed={isCollapsed}
-            onToggle={() => toggleFile(file.path)}
-            commentThreads={commentThreads}
-            fallback={fallbacks?.get(file.path) ?? null}
-            externalUrl={githubFileUrl}
-          />
-        </LazyDiff>
-      </div>
-    );
-  });
-}
diff --git a/apps/code/src/renderer/features/code-review/components/ReviewPage.tsx b/apps/code/src/renderer/features/code-review/components/ReviewPage.tsx
index 3450075fd..39814158b 100644
--- a/apps/code/src/renderer/features/code-review/components/ReviewPage.tsx
+++ b/apps/code/src/renderer/features/code-review/components/ReviewPage.tsx
@@ -4,35 +4,88 @@ import {
   usePrChangedFiles,
 } from "@features/git-interaction/hooks/useGitQueries";
 import { usePrDetails } from "@features/git-interaction/hooks/usePrDetails";
-import { makeFileKey } from "@features/git-interaction/utils/fileKey";
 import { usePanelLayoutStore } from "@features/panels/store/panelLayoutStore";
 import { useCwd } from "@features/sidebar/hooks/useCwd";
 import type { parsePatchFiles } from "@pierre/diffs";
 import { Flex, Text } from "@radix-ui/themes";
 import { useReviewNavigationStore } from "@renderer/features/code-review/stores/reviewNavigationStore";
-import { useTRPC } from "@renderer/trpc/client";
+import { trpc, useTRPC } from "@renderer/trpc/client";
 import type { ChangedFile, Task } from "@shared/types";
-import { useQuery } from "@tanstack/react-query";
-import { useMemo } from "react";
+import { useQueryClient } from "@tanstack/react-query";
+import { useEffect, useMemo } from "react";
+import { REVIEW_FILE_CACHE_TIME_MS, REVIEW_MAX_FILE_LINES } from "../constants";
 import { useEffectiveDiffSource } from "../hooks/useEffectiveDiffSource";
 import { useReviewDiffs } from "../hooks/useReviewDiffs";
 import type { DiffOptions } from "../types";
 import type { PrCommentThread } from "../utils/prCommentAnnotations";
 import type { ResolvedDiffSource } from "../utils/resolveDiffSource";
-import { InteractiveFileDiff } from "./InteractiveFileDiff";
-import { LazyDiff } from "./LazyDiff";
-import { RemoteDiffList } from "./RemoteDiffList";
 import {
-  DeferredDiffPlaceholder,
-  type DeferredReason,
-  DiffFileHeader,
+  buildItemIndex,
+  type ReviewListItem,
   ReviewShell,
-  sumHunkStats,
   useReviewState,
 } from "./ReviewShell";
+import {
+  buildPatchReviewItems,
+  buildRemoteReviewItems,
+  buildUntrackedReviewItems,
+} from "./reviewItemBuilders";
+
+const EMPTY_CHANGED_FILES: ChangedFile[] = [];
+
+function usePrefetchUntrackedFileContents(
+  repoPath: string,
+  files: ChangedFile[],
+  enabled: boolean,
+) {
+  const trpcClient = useTRPC();
+  const queryClient = useQueryClient();
+  const filePaths = useMemo(
+    () => [...new Set(files.map((file) => file.path))],
+    [files],
+  );
+
+  useEffect(() => {
+    if (!enabled || filePaths.length === 0) return;
+
+    let cancelled = false;
+
+    const run = async () => {
+      const batchResult = await queryClient.fetchQuery({
+        ...trpc.fs.readRepoFilesBounded.queryOptions(
+          {
+            repoPath,
+            filePaths,
+            maxLines: REVIEW_MAX_FILE_LINES,
+          },
+          {
+            staleTime: 30_000,
+            gcTime: REVIEW_FILE_CACHE_TIME_MS,
+          },
+        ),
+      });
+
+      if (cancelled) return;
+
+      for (const [filePath, result] of Object.entries(batchResult)) {
+        queryClient.setQueryData(
+          trpcClient.fs.readRepoFileBounded.queryKey({
+            repoPath,
+            filePath,
+            maxLines: REVIEW_MAX_FILE_LINES,
+          }),
+          result,
+        );
+      }
+    };
 
-const EMPTY_BRANCH_FILES: ChangedFile[] = [];
-const EMPTY_PR_FILES: ChangedFile[] = [];
+    void run();
+
+    return () => {
+      cancelled = true;
+    };
+  }, [enabled, filePaths, queryClient, repoPath, trpcClient]);
+}
 
 interface ReviewPageProps {
   task: Task;
@@ -87,8 +140,6 @@ export function ReviewPage({ task }: ReviewPageProps) {
     toggleFile,
     expandAll,
     collapseAll,
-    revealFile,
-    getDeferredReason,
     uncollapseFile,
   } = useReviewState(changedFiles, allPaths);
 
@@ -107,31 +158,16 @@ export function ReviewPage({ task }: ReviewPageProps) {
     );
   }
 
-  if (effectiveSource === "branch") {
+  if (effectiveSource === "branch" || effectiveSource === "pr") {
     return (
-      <BranchReviewPage
+      <RemoteReviewPage
         task={task}
-        branch={linkedBranch as string}
         repoPath={repoPath}
-        defaultBranch={defaultBranch}
-        isReviewOpen={isReviewOpen}
-        effectiveSource={effectiveSource}
-        branchSourceAvailable={branchSourceAvailable}
-        prSourceAvailable={prSourceAvailable}
+        branch={effectiveSource === "branch" ? linkedBranch : null}
         prUrl={prUrl}
-        commentThreads={effectiveCommentThreads}
-      />
-    );
-  }
-
-  if (effectiveSource === "pr") {
-    return (
-      <PrReviewPage
-        task={task}
-        prUrl={prUrl as string}
-        defaultBranch={defaultBranch}
         isReviewOpen={isReviewOpen}
         effectiveSource={effectiveSource}
+        defaultBranch={defaultBranch}
         branchSourceAvailable={branchSourceAvailable}
         prSourceAvailable={prSourceAvailable}
         commentThreads={effectiveCommentThreads}
@@ -139,179 +175,271 @@ export function ReviewPage({ task }: ReviewPageProps) {
     );
   }
 
-  const sharedDiffProps = {
-    repoPath,
-    taskId,
-    diffOptions,
-    collapsedFiles,
-    toggleFile,
-    revealFile,
-    getDeferredReason,
-    openFile,
-    prUrl,
-    commentThreads: effectiveCommentThreads,
-  };
-
   return (
-    <ReviewShell
+    <LocalReviewContent
       task={task}
-      fileCount={totalFileCount}
+      repoPath={repoPath}
+      taskId={taskId}
+      openFile={openFile}
+      prUrl={prUrl}
+      totalFileCount={totalFileCount}
       linesAdded={linesAdded}
       linesRemoved={linesRemoved}
-      isLoading={changesLoading || diffLoading}
-      isEmpty={totalFileCount === 0}
-      allExpanded={collapsedFiles.size === 0}
-      onExpandAll={expandAll}
-      onCollapseAll={collapseAll}
-      onUncollapseFile={uncollapseFile}
-      onRefresh={refetch}
+      changesLoading={changesLoading}
+      diffLoading={diffLoading}
+      diffOptions={diffOptions}
+      collapsedFiles={collapsedFiles}
+      toggleFile={toggleFile}
+      expandAll={expandAll}
+      collapseAll={collapseAll}
+      uncollapseFile={uncollapseFile}
+      refetch={refetch}
+      hasStagedFiles={hasStagedFiles}
+      stagedParsedFiles={stagedParsedFiles}
+      unstagedParsedFiles={unstagedParsedFiles}
+      untrackedFiles={untrackedFiles}
+      stagedPathSet={stagedPathSet}
+      commentThreads={effectiveCommentThreads}
       effectiveSource={effectiveSource}
       branchSourceAvailable={branchSourceAvailable}
       prSourceAvailable={prSourceAvailable}
       defaultBranch={defaultBranch}
-    >
-      {hasStagedFiles && stagedParsedFiles.length > 0 && (
-        <>
-          <SectionLabel label="Staged Changes" />
-          <FileDiffList files={stagedParsedFiles} staged {...sharedDiffProps} />
-        </>
-      )}
-      {hasStagedFiles &&
-        (unstagedParsedFiles.length > 0 || untrackedFiles.length > 0) && (
-          <SectionLabel label="Changes" />
-        )}
-      <FileDiffList
-        files={unstagedParsedFiles}
-        alsoStagedPaths={stagedPathSet}
-        {...sharedDiffProps}
-      />
-      {untrackedFiles.map((file) => {
-        const key = makeFileKey(file.staged, file.path);
-        const isCollapsed = collapsedFiles.has(key);
-        return (
-          <div key={key} data-file-path={key}>
-            <LazyDiff>
-              <UntrackedFileDiff
-                file={file}
-                repoPath={repoPath}
-                options={diffOptions}
-                collapsed={isCollapsed}
-                onToggle={() => toggleFile(key)}
-                taskId={taskId}
-              />
-            </LazyDiff>
-          </div>
-        );
-      })}
-    </ReviewShell>
+    />
   );
 }
 
-function BranchReviewPage({
+function LocalReviewContent({
   task,
-  branch,
   repoPath,
-  defaultBranch,
-  isReviewOpen,
+  taskId,
+  openFile,
+  prUrl,
+  totalFileCount,
+  linesAdded,
+  linesRemoved,
+  changesLoading,
+  diffLoading,
+  diffOptions,
+  collapsedFiles,
+  toggleFile,
+  expandAll,
+  collapseAll,
+  uncollapseFile,
+  refetch,
+  hasStagedFiles,
+  stagedParsedFiles,
+  unstagedParsedFiles,
+  untrackedFiles,
+  stagedPathSet,
+  commentThreads,
   effectiveSource,
   branchSourceAvailable,
   prSourceAvailable,
-  prUrl,
-  commentThreads,
+  defaultBranch,
 }: {
   task: Task;
-  branch: string;
-  repoPath: string | null;
-  defaultBranch: string | null;
-  isReviewOpen: boolean;
+  repoPath: string;
+  taskId: string;
+  openFile: (taskId: string, path: string, preview: boolean) => void;
+  prUrl: string | null;
+  totalFileCount: number;
+  linesAdded: number;
+  linesRemoved: number;
+  changesLoading: boolean;
+  diffLoading: boolean;
+  diffOptions: DiffOptions;
+  collapsedFiles: Set<string>;
+  toggleFile: (key: string) => void;
+  expandAll: () => void;
+  collapseAll: () => void;
+  uncollapseFile: (filePath: string) => void;
+  refetch: () => void;
+  hasStagedFiles: boolean;
+  stagedParsedFiles: ReturnType<typeof parsePatchFiles>[number]["files"];
+  unstagedParsedFiles: ReturnType<typeof parsePatchFiles>[number]["files"];
+  untrackedFiles: ChangedFile[];
+  stagedPathSet: Set<string>;
+  commentThreads?: Map<number, PrCommentThread>;
   effectiveSource: ResolvedDiffSource;
   branchSourceAvailable: boolean;
   prSourceAvailable: boolean;
-  prUrl: string | null;
-  commentThreads?: Map<number, PrCommentThread>;
+  defaultBranch: string | null;
 }) {
-  const taskId = task.id;
+  usePrefetchUntrackedFileContents(repoPath, untrackedFiles, true);
+
+  const items = useMemo<ReviewListItem[]>(() => {
+    const reviewItems: ReviewListItem[] = [];
+
+    if (hasStagedFiles && stagedParsedFiles.length > 0) {
+      reviewItems.push({
+        key: "section:staged",
+        node: <SectionLabel label="Staged Changes" />,
+      });
+      reviewItems.push(
+        ...buildPatchReviewItems({
+          files: stagedParsedFiles,
+          staged: true,
+          repoPath,
+          taskId,
+          diffOptions,
+          collapsedFiles,
+          toggleFile,
+          openFile,
+          prUrl,
+          commentThreads,
+        }),
+      );
+    }
 
-  const { data: files = EMPTY_BRANCH_FILES, isLoading } =
-    useLocalBranchChangedFiles(
-      isReviewOpen ? repoPath : null,
-      isReviewOpen ? branch : null,
+    if (
+      hasStagedFiles &&
+      (unstagedParsedFiles.length > 0 || untrackedFiles.length > 0)
+    ) {
+      reviewItems.push({
+        key: "section:changes",
+        node: <SectionLabel label="Changes" />,
+      });
+    }
+
+    reviewItems.push(
+      ...buildPatchReviewItems({
+        files: unstagedParsedFiles,
+        alsoStagedPaths: stagedPathSet,
+        repoPath,
+        taskId,
+        diffOptions,
+        collapsedFiles,
+        toggleFile,
+        openFile,
+        prUrl,
+        commentThreads,
+      }),
+    );
+    reviewItems.push(
+      ...buildUntrackedReviewItems({
+        files: untrackedFiles,
+        repoPath,
+        taskId,
+        diffOptions,
+        collapsedFiles,
+        toggleFile,
+      }),
     );
 
-  const allPaths = useMemo(() => files.map((f) => f.path), [files]);
+    return reviewItems;
+  }, [
+    collapsedFiles,
+    commentThreads,
+    diffOptions,
+    hasStagedFiles,
+    openFile,
+    prUrl,
+    repoPath,
+    stagedParsedFiles,
+    stagedPathSet,
+    taskId,
+    toggleFile,
+    untrackedFiles,
+    unstagedParsedFiles,
+  ]);
 
-  const reviewState = useReviewState(files, allPaths);
+  const itemIndexByFilePath = useMemo(() => buildItemIndex(items), [items]);
 
   return (
     <ReviewShell
       task={task}
-      fileCount={files.length}
-      linesAdded={reviewState.linesAdded}
-      linesRemoved={reviewState.linesRemoved}
-      isLoading={
-        (isLoading || (!repoPath && isReviewOpen)) && files.length === 0
-      }
-      isEmpty={files.length === 0}
-      allExpanded={reviewState.collapsedFiles.size === 0}
-      onExpandAll={reviewState.expandAll}
-      onCollapseAll={reviewState.collapseAll}
-      onUncollapseFile={reviewState.uncollapseFile}
+      fileCount={totalFileCount}
+      linesAdded={linesAdded}
+      linesRemoved={linesRemoved}
+      isLoading={changesLoading || diffLoading}
+      isEmpty={totalFileCount === 0}
+      allExpanded={collapsedFiles.size === 0}
+      onExpandAll={expandAll}
+      onCollapseAll={collapseAll}
+      onUncollapseFile={uncollapseFile}
+      onRefresh={refetch}
       effectiveSource={effectiveSource}
       branchSourceAvailable={branchSourceAvailable}
       prSourceAvailable={prSourceAvailable}
       defaultBranch={defaultBranch}
-    >
-      <RemoteDiffList
-        files={files}
-        taskId={taskId}
-        prUrl={prUrl}
-        options={reviewState.diffOptions}
-        collapsedFiles={reviewState.collapsedFiles}
-        toggleFile={reviewState.toggleFile}
-        revealFile={reviewState.revealFile}
-        getDeferredReason={reviewState.getDeferredReason}
-        commentThreads={commentThreads}
-      />
-    </ReviewShell>
+      items={items}
+      itemIndexByFilePath={itemIndexByFilePath}
+    />
   );
 }
 
-function PrReviewPage({
+function RemoteReviewPage({
   task,
+  repoPath,
+  branch,
   prUrl,
-  defaultBranch,
   isReviewOpen,
   effectiveSource,
+  defaultBranch,
   branchSourceAvailable,
   prSourceAvailable,
   commentThreads,
 }: {
   task: Task;
-  prUrl: string;
-  defaultBranch: string | null;
+  repoPath: string | null;
+  branch: string | null;
+  prUrl: string | null;
   isReviewOpen: boolean;
   effectiveSource: ResolvedDiffSource;
+  defaultBranch: string | null;
   branchSourceAvailable: boolean;
   prSourceAvailable: boolean;
   commentThreads?: Map<number, PrCommentThread>;
 }) {
   const taskId = task.id;
+  const isBranch = effectiveSource === "branch";
 
-  const { data: files = EMPTY_PR_FILES, isLoading } = usePrChangedFiles(
-    isReviewOpen ? prUrl : null,
-  );
+  const { data: branchFiles = EMPTY_CHANGED_FILES, isLoading: branchLoading } =
+    useLocalBranchChangedFiles(
+      isBranch && isReviewOpen ? repoPath : null,
+      isBranch && isReviewOpen ? branch : null,
+    );
+  const { data: prFiles = EMPTY_CHANGED_FILES, isLoading: prLoading } =
+    usePrChangedFiles(!isBranch && isReviewOpen ? prUrl : null);
 
-  const allPaths = useMemo(() => files.map((f) => f.path), [files]);
+  const files = isBranch ? branchFiles : prFiles;
+  const isLoading = isBranch
+    ? (branchLoading || (!repoPath && isReviewOpen)) && files.length === 0
+    : prLoading && files.length === 0;
 
+  const allPaths = useMemo(() => files.map((f) => f.path), [files]);
   const reviewState = useReviewState(files, allPaths);
 
+  const items = useMemo(
+    () =>
+      buildRemoteReviewItems({
+        files,
+        taskId,
+        prUrl,
+        options: reviewState.diffOptions,
+        collapsedFiles: reviewState.collapsedFiles,
+        toggleFile: reviewState.toggleFile,
+        commentThreads,
+      }),
+    [
+      commentThreads,
+      files,
+      prUrl,
+      reviewState.collapsedFiles,
+      reviewState.diffOptions,
+      reviewState.toggleFile,
+      taskId,
+    ],
+  );
+  const itemIndexByFilePath = useMemo(() => buildItemIndex(items), [items]);
+
   return (
     <ReviewShell
       task={task}
       fileCount={files.length}
       linesAdded={reviewState.linesAdded}
       linesRemoved={reviewState.linesRemoved}
-      isLoading={isLoading && files.length === 0}
+      isLoading={isLoading}
       isEmpty={files.length === 0}
       allExpanded={reviewState.collapsedFiles.size === 0}
       onExpandAll={reviewState.expandAll}
@@ -321,19 +449,9 @@ function PrReviewPage({
       branchSourceAvailable={branchSourceAvailable}
       prSourceAvailable={prSourceAvailable}
       defaultBranch={defaultBranch}
-    >
-      <RemoteDiffList
-        files={files}
-        taskId={taskId}
-        prUrl={prUrl}
-        options={reviewState.diffOptions}
-        collapsedFiles={reviewState.collapsedFiles}
-        toggleFile={reviewState.toggleFile}
-        revealFile={reviewState.revealFile}
-        getDeferredReason={reviewState.getDeferredReason}
-        commentThreads={commentThreads}
-      />
-    </ReviewShell>
+      items={items}
+      itemIndexByFilePath={itemIndexByFilePath}
+    />
   );
 }
 
@@ -346,135 +464,3 @@ function SectionLabel({ label }: { label: string }) {
     </Flex>
   );
 }
-
-interface FileDiffListProps {
-  files: ReturnType<typeof parsePatchFiles>[number]["files"];
-  staged?: boolean;
-  alsoStagedPaths?: Set<string>;
-  repoPath: string;
-  taskId: string;
-  diffOptions: DiffOptions;
-  collapsedFiles: Set<string>;
-  toggleFile: (key: string) => void;
-  revealFile: (key: string) => void;
-  getDeferredReason: (key: string) => DeferredReason | null;
-  openFile: (taskId: string, path: string, preview: boolean) => void;
-  prUrl: string | null;
-  commentThreads?: Map<number, PrCommentThread>;
-}
-
-function FileDiffList({
-  files,
-  staged = false,
-  alsoStagedPaths,
-  repoPath,
-  taskId,
-  diffOptions,
-  collapsedFiles,
-  toggleFile,
-  revealFile,
-  getDeferredReason,
-  openFile,
-  prUrl,
-  commentThreads,
-}: FileDiffListProps) {
-  return files.map((fileDiff) => {
-    const filePath = fileDiff.name ?? fileDiff.prevName ?? "";
-    const key = makeFileKey(staged, filePath);
-    const isCollapsed = collapsedFiles.has(key);
-    const deferredReason = getDeferredReason(key);
-    const skipExpansion = staged || (alsoStagedPaths?.has(filePath) ?? false);
-
-    if (deferredReason) {
-      const { additions, deletions } = sumHunkStats(fileDiff.hunks);
-      return (
-        <div key={key} data-file-path={key}>
-          <DeferredDiffPlaceholder
-            filePath={filePath}
-            linesAdded={additions}
-            linesRemoved={deletions}
-            reason={deferredReason}
-            collapsed={isCollapsed}
-            onToggle={() => toggleFile(key)}
-            onShow={() => revealFile(key)}
-          />
-        </div>
-      );
-    }
-
-    return (
-      <div key={key} data-file-path={key}>
-        <LazyDiff>
-          <InteractiveFileDiff
-            fileDiff={fileDiff}
-            repoPath={repoPath}
-            skipExpansion={skipExpansion}
-            options={{ ...diffOptions, collapsed: isCollapsed }}
-            taskId={taskId}
-            prUrl={prUrl}
-            commentThreads={commentThreads}
-            renderCustomHeader={(fd) => (
-              <DiffFileHeader
-                fileDiff={fd}
-                collapsed={isCollapsed}
-                onToggle={() => toggleFile(key)}
-                onOpenFile={() =>
-                  openFile(taskId, `${repoPath}/${filePath}`, false)
-                }
-              />
-            )}
-          />
-        </LazyDiff>
-      </div>
-    );
-  });
-}
-
-function UntrackedFileDiff({
-  file,
-  repoPath,
-  taskId,
-  options,
-  collapsed,
-  onToggle,
-}: {
-  file: ChangedFile;
-  repoPath: string;
-  taskId: string;
-  options: DiffOptions;
-  collapsed: boolean;
-  onToggle: () => void;
-}) {
-  const trpc = useTRPC();
-  const { data: content } = useQuery(
-    trpc.fs.readRepoFile.queryOptions(
-      { repoPath, filePath: file.path },
-      { staleTime: 30_000 },
-    ),
-  );
-
-  const oldFile = useMemo(
-    () => ({ name: file.path, contents: "" }),
-    [file.path],
-  );
-  const newFile = useMemo(
-    () => ({ name: file.path, contents: content ?? "" }),
-    [file.path, content],
-  );
-
-  return (
-    <InteractiveFileDiff
-      oldFile={oldFile}
-      newFile={newFile}
-      options={{ ...options, collapsed }}
-      taskId={taskId}
-      renderCustomHeader={(fd) => (
-        <DiffFileHeader
-          fileDiff={fd}
-          collapsed={collapsed}
-          onToggle={onToggle}
-        />
-      )}
-    />
-  );
-}
diff --git a/apps/code/src/renderer/features/code-review/components/ReviewRows.tsx b/apps/code/src/renderer/features/code-review/components/ReviewRows.tsx
new file mode 100644
index 000000000..d1f402028
--- /dev/null
+++ b/apps/code/src/renderer/features/code-review/components/ReviewRows.tsx
@@ -0,0 +1,249 @@
+import type { parsePatchFiles } from "@pierre/diffs";
+import { useInView } from "@renderer/hooks/useInView";
+import type { ChangedFile } from "@shared/types";
+import { memo, useCallback, useMemo } from "react";
+import { REVIEW_PREFETCH_ROOT_MARGIN } from "../constants";
+import { useReadRepoFileBounded } from "../hooks/useReadRepoFileBounded";
+import type { DiffOptions } from "../types";
+import { contentHash } from "../utils/contentHash";
+import type { PrCommentThread } from "../utils/prCommentAnnotations";
+import { InteractiveFileDiff } from "./InteractiveFileDiff";
+import { PatchedFileDiff } from "./PatchedFileDiff";
+import {
+  DeferredDiffPlaceholder,
+  DiffFileHeader,
+  FileHeaderRow,
+  splitFilePath,
+} from "./ReviewShell";
+
+interface PatchRowProps {
+  itemKey: string;
+  filePath: string;
+  fileDiff: ReturnType<typeof parsePatchFiles>[number]["files"][number];
+  repoPath: string;
+  taskId: string;
+  diffOptions: DiffOptions;
+  collapsed: boolean;
+  skipExpansion: boolean;
+  toggleFile: (key: string) => void;
+  openFile: (taskId: string, path: string, preview: boolean) => void;
+  prUrl: string | null;
+  commentThreads?: Map<number, PrCommentThread>;
+}
+
+export const PatchRow = memo(function PatchRow({
+  itemKey,
+  filePath,
+  fileDiff,
+  repoPath,
+  taskId,
+  diffOptions,
+  collapsed,
+  skipExpansion,
+  toggleFile,
+  openFile,
+  prUrl,
+  commentThreads,
+}: PatchRowProps) {
+  const onToggle = useCallback(
+    () => toggleFile(itemKey),
+    [toggleFile, itemKey],
+  );
+  const onOpenFile = useCallback(
+    () => openFile(taskId, `${repoPath}/${filePath}`, false),
+    [openFile, taskId, repoPath, filePath],
+  );
+  const options = useMemo(
+    () => ({ ...diffOptions, collapsed }),
+    [diffOptions, collapsed],
+  );
+  const renderHeader = useCallback(
+    (fd: typeof fileDiff) => (
+      <DiffFileHeader
+        fileDiff={fd}
+        collapsed={collapsed}
+        onToggle={onToggle}
+        onOpenFile={onOpenFile}
+      />
+    ),
+    [collapsed, onToggle, onOpenFile],
+  );
+  return (
+    <InteractiveFileDiff
+      fileDiff={fileDiff}
+      repoPath={repoPath}
+      skipExpansion={skipExpansion}
+      options={options}
+      taskId={taskId}
+      prUrl={prUrl}
+      commentThreads={commentThreads}
+      renderCustomHeader={renderHeader}
+    />
+  );
+});
+
+interface UntrackedRowProps {
+  itemKey: string;
+  file: ChangedFile;
+  repoPath: string;
+  taskId: string;
+  diffOptions: DiffOptions;
+  collapsed: boolean;
+  toggleFile: (key: string) => void;
+}
+
+export const UntrackedRow = memo(function UntrackedRow({
+  itemKey,
+  file,
+  repoPath,
+  taskId,
+  diffOptions,
+  collapsed,
+  toggleFile,
+}: UntrackedRowProps) {
+  const onToggle = useCallback(
+    () => toggleFile(itemKey),
+    [toggleFile, itemKey],
+  );
+  return (
+    <UntrackedFileDiff
+      file={file}
+      repoPath={repoPath}
+      options={diffOptions}
+      collapsed={collapsed}
+      onToggle={onToggle}
+      taskId={taskId}
+    />
+  );
+});
+
+interface RemoteRowProps {
+  file: ChangedFile;
+  taskId: string;
+  prUrl?: string | null;
+  options: DiffOptions;
+  collapsed: boolean;
+  toggleFile: (path: string) => void;
+  commentThreads?: Map<number, PrCommentThread>;
+  externalUrl?: string;
+}
+
+export const RemoteRow = memo(function RemoteRow({
+  file,
+  taskId,
+  prUrl,
+  options,
+  collapsed,
+  toggleFile,
+  commentThreads,
+  externalUrl,
+}: RemoteRowProps) {
+  const onToggle = useCallback(
+    () => toggleFile(file.path),
+    [toggleFile, file.path],
+  );
+  return (
+    <PatchedFileDiff
+      file={file}
+      taskId={taskId}
+      prUrl={prUrl}
+      options={options}
+      collapsed={collapsed}
+      onToggle={onToggle}
+      commentThreads={commentThreads}
+      externalUrl={externalUrl}
+    />
+  );
+});
+
+function UntrackedFileDiff({
+  file,
+  repoPath,
+  taskId,
+  options,
+  collapsed,
+  onToggle,
+}: {
+  file: ChangedFile;
+  repoPath: string;
+  taskId: string;
+  options: DiffOptions;
+  collapsed: boolean;
+  onToggle: () => void;
+}) {
+  const [containerRef, inView] = useInView<HTMLDivElement>({
+    rootMargin: REVIEW_PREFETCH_ROOT_MARGIN,
+    once: true,
+  });
+  const { data: result } = useReadRepoFileBounded(
+    repoPath,
+    file.path,
+    !collapsed && inView,
+  );
+
+  const content = result?.kind === "content" ? result.content : null;
+
+  const oldFile = useMemo(
+    () => ({
+      name: file.path,
+      contents: "",
+      cacheKey: `untracked-old:${file.path}`,
+    }),
+    [file.path],
+  );
+  const newFile = useMemo(
+    () => ({
+      name: file.path,
+      contents: content ?? "",
+      cacheKey: content
+        ? `untracked-new:${file.path}:${contentHash(content)}`
+        : undefined,
+    }),
+    [file.path, content],
+  );
+
+  if (!collapsed && inView && result?.kind === "too-large") {
+    return (
+      <DeferredDiffPlaceholder
+        filePath={file.path}
+        linesAdded={file.linesAdded ?? 0}
+        linesRemoved={0}
+        reason="line-limit"
+        collapsed={collapsed}
+        onToggle={onToggle}
+      />
+    );
+  }
+
+  const hasContent = result?.kind === "content";
+  const { dirPath, fileName } = splitFilePath(file.path);
+
+  return (
+    <div ref={containerRef}>
+      {hasContent ? (
+        <InteractiveFileDiff
+          oldFile={oldFile}
+          newFile={newFile}
+          options={{ ...options, collapsed }}
+          taskId={taskId}
+          renderCustomHeader={(fd) => (
+            <DiffFileHeader
+              fileDiff={fd}
+              collapsed={collapsed}
+              onToggle={onToggle}
+            />
+          )}
+        />
+      ) : (
+        <FileHeaderRow
+          dirPath={dirPath}
+          fileName={fileName}
+          additions={file.linesAdded ?? 0}
+          deletions={0}
+          collapsed={collapsed}
+          onToggle={onToggle}
+        />
+      )}
+    </div>
+  );
+}
diff --git a/apps/code/src/renderer/features/code-review/components/ReviewShell.test.tsx b/apps/code/src/renderer/features/code-review/components/ReviewShell.test.tsx
index 602f83901..209f46b77 100644
--- a/apps/code/src/renderer/features/code-review/components/ReviewShell.test.tsx
+++ b/apps/code/src/renderer/features/code-review/components/ReviewShell.test.tsx
@@ -60,7 +60,7 @@ function renderHeader(path: string) {
       filePath={path}
       linesAdded={10}
       linesRemoved={2}
-      reason="generated"
+      reason="line-limit"
       collapsed={false}
       onToggle={() => {}}
     />,
diff --git a/apps/code/src/renderer/features/code-review/components/ReviewShell.tsx b/apps/code/src/renderer/features/code-review/components/ReviewShell.tsx
index 7fb1d8c41..212f09b52 100644
--- a/apps/code/src/renderer/features/code-review/components/ReviewShell.tsx
+++ b/apps/code/src/renderer/features/code-review/components/ReviewShell.tsx
@@ -18,10 +18,15 @@ import {
   useRef,
   useState,
 } from "react";
+import { VList, type VListHandle } from "virtua";
+import {
+  REVIEW_LIST_BUFFER_PX,
+  REVIEW_LIST_ESTIMATED_ITEM_SIZE,
+} from "../constants";
 import type { ResolvedDiffSource } from "../utils/resolveDiffSource";
 import { ReviewToolbar } from "./ReviewToolbar";
 
-function splitFilePath(fullPath: string): {
+export function splitFilePath(fullPath: string): {
   dirPath: string;
   fileName: string;
 } {
@@ -45,63 +50,24 @@ export function sumHunkStats(hunks: FileDiffMetadata["hunks"]): {
   return { additions, deletions };
 }
 
+export function buildItemIndex(
+  items: { scrollKey?: string }[],
+): Map<string, number> {
+  const index = new Map<string, number>();
+  for (let i = 0; i < items.length; i++) {
+    const key = items[i].scrollKey;
+    if (key) index.set(key, i);
+  }
+  return index;
+}
+
 function workerFactory(): Worker {
   return new Worker(WorkerUrl, { type: "module" });
 }
 
 const STICKY_HEADER_CSS = `[data-diffs-header] { position: sticky; top: 0; z-index: 1; background: var(--gray-2); }`;
 
-const LARGE_DIFF_LINE_THRESHOLD = 500;
-
-const AUTO_COLLAPSE_PATTERNS = [
-  /package-lock\.json$/,
-  /pnpm-lock\.yaml$/,
-  /yarn\.lock$/,
-  /bun\.lockb?$/,
-  /Cargo\.lock$/,
-  /poetry\.lock$/,
-  /Pipfile\.lock$/,
-  /composer\.lock$/,
-  /Gemfile\.lock$/,
-  /flake\.lock$/,
-  /deno\.lock$/,
-  /[.-]min\.(js|css)$/,
-  /\.map$/,
-  /(^|\/)dist\//,
-  /(^|\/)vendor\//,
-  /(^|\/)node_modules\//,
-  /(^|\/)__generated__\//,
-  /\.generated\./,
-  /\.designer\.(cs|vb)$/,
-  /\.snap$/,
-  /\.pbxproj$/,
-];
-
-export type DeferredReason = "deleted" | "large" | "generated" | "unavailable";
-
-export function computeAutoDeferred(
-  files: {
-    path: string;
-    status?: string;
-    linesAdded?: number;
-    linesRemoved?: number;
-  }[],
-): Map<string, DeferredReason> {
-  const map = new Map<string, DeferredReason>();
-  for (const file of files) {
-    if (file.status === "deleted") {
-      map.set(file.path, "deleted");
-      continue;
-    }
-    const totalLines = (file.linesAdded ?? 0) + (file.linesRemoved ?? 0);
-    if (totalLines > LARGE_DIFF_LINE_THRESHOLD) {
-      map.set(file.path, "large");
-    } else if (AUTO_COLLAPSE_PATTERNS.some((p) => p.test(file.path))) {
-      map.set(file.path, "generated");
-    }
-  }
-  return map;
-}
+export type DeferredReason = "line-limit" | "unavailable";
 
 function useDiffOptions() {
   const viewMode = useDiffViewerStore((s) => s.viewMode);
@@ -135,37 +101,16 @@ export function useReviewState(
     [changedFiles],
   );
 
-  const autoDeferred = useMemo(
-    () => computeAutoDeferred(changedFiles),
-    [changedFiles],
-  );
-
-  const collapseState = useCollapseState(allPaths, autoDeferred);
+  const collapseState = useCollapseState(allPaths);
 
   return { diffOptions, linesAdded, linesRemoved, ...collapseState };
 }
 
-function useCollapseState(
-  filePaths: string[],
-  deferredPaths: Map<string, DeferredReason>,
-) {
-  const [revealedFiles, setRevealedFiles] = useState<Set<string>>(
-    () => new Set(),
-  );
+function useCollapseState(filePaths: string[]) {
   const [collapsedFiles, setCollapsedFiles] = useState<Set<string>>(
     () => new Set(),
   );
 
-  const [lastDeferred, setLastDeferred] = useState(deferredPaths);
-  if (deferredPaths !== lastDeferred) {
-    setLastDeferred(deferredPaths);
-    setRevealedFiles(new Set());
-  }
-
-  const revealFile = useCallback((filePath: string) => {
-    setRevealedFiles((prev) => new Set(prev).add(filePath));
-  }, []);
-
   const toggleFile = useCallback((filePath: string) => {
     setCollapsedFiles((prev) => {
       const next = new Set(prev);
@@ -191,22 +136,12 @@ function useCollapseState(
     [filePaths],
   );
 
-  const getDeferredReason = useCallback(
-    (path: string): DeferredReason | null => {
-      if (revealedFiles.has(path)) return null;
-      return deferredPaths.get(path) ?? null;
-    },
-    [deferredPaths, revealedFiles],
-  );
-
   return {
     collapsedFiles,
     toggleFile,
     uncollapseFile,
     expandAll,
     collapseAll,
-    revealFile,
-    getDeferredReason,
   };
 }
 
@@ -290,7 +225,8 @@ export interface ReviewShellProps {
   linesRemoved: number;
   isLoading: boolean;
   isEmpty: boolean;
-  children: ReactNode;
+  items: ReviewListItem[];
+  itemIndexByFilePath: Map<string, number>;
   onUncollapseFile?: (filePath: string) => void;
   allExpanded: boolean;
   onExpandAll: () => void;
@@ -302,6 +238,12 @@ export interface ReviewShellProps {
   defaultBranch?: string | null;
 }
 
+export interface ReviewListItem {
+  key: string;
+  scrollKey?: string;
+  node: ReactNode;
+}
+
 export function ReviewShell({
   task,
   fileCount,
@@ -309,7 +251,8 @@ export function ReviewShell({
   linesRemoved,
   isLoading,
   isEmpty,
-  children,
+  items,
+  itemIndexByFilePath,
   onUncollapseFile,
   allExpanded,
   onExpandAll,
@@ -321,7 +264,7 @@ export function ReviewShell({
   defaultBranch,
 }: ReviewShellProps) {
   const taskId = task.id;
-  const scrollContainerRef = useRef<HTMLDivElement | null>(null);
+  const listRef = useRef<VListHandle | null>(null);
 
   const reviewMode = useReviewNavigationStore(
     (s) => s.reviewModes[taskId] ?? "closed",
@@ -345,73 +288,74 @@ export function ReviewShell({
 
   useEffect(() => {
     if (!scrollRequest) return;
-
-    const container = scrollContainerRef.current;
-    if (!container) return;
-
-    const target = container.querySelector(
-      `[data-file-path="${CSS.escape(scrollRequest)}"]`,
-    );
-    if (!target) return;
+    const targetIndex = itemIndexByFilePath.get(scrollRequest);
+    if (targetIndex === undefined) return;
 
     onUncollapseFile?.(scrollRequest);
-
-    target.scrollIntoView({ block: "start" });
-    setActiveFilePath(taskId, scrollRequest);
-    clearScrollRequest(taskId);
+    requestAnimationFrame(() => {
+      listRef.current?.scrollToIndex(targetIndex, { align: "start" });
+      setActiveFilePath(taskId, scrollRequest);
+      clearScrollRequest(taskId);
+    });
   }, [
-    scrollRequest,
     clearScrollRequest,
+    itemIndexByFilePath,
+    onUncollapseFile,
+    scrollRequest,
     setActiveFilePath,
     taskId,
-    onUncollapseFile,
   ]);
 
-  useEffect(() => {
-    const container = scrollContainerRef.current;
-    if (!container) return;
-
-    const fileDivs =
-      container.querySelectorAll<HTMLElement>("[data-file-path]");
-    if (fileDivs.length === 0) return;
-
-    const observer = new IntersectionObserver(
-      (entries) => {
-        let topEntry: IntersectionObserverEntry | null = null;
-        for (const entry of entries) {
-          if (
-            entry.isIntersecting &&
-            (!topEntry ||
-              entry.boundingClientRect.top < topEntry.boundingClientRect.top)
-          ) {
-            topEntry = entry;
-          }
-        }
-        if (topEntry) {
-          const path =
-            (topEntry.target as HTMLElement).dataset.filePath ?? null;
-          const current =
-            useReviewNavigationStore.getState().activeFilePaths[taskId] ?? null;
-          if (path !== current) {
-            setActiveFilePath(taskId, path);
-          }
-        }
-      },
-      { root: container, rootMargin: "0px 0px -80% 0px", threshold: 0 },
-    );
-
-    for (const div of fileDivs) {
-      observer.observe(div);
-    }
+  const lastActiveRef = useRef<string | null>(null);
+  const handleScroll = useCallback(
+    (offset: number) => {
+      const handle = listRef.current;
+      if (!handle) return;
+      const index = handle.findItemIndex(offset);
+      const item = items[index];
+      const scrollKey = item?.scrollKey;
+      if (!scrollKey || scrollKey === lastActiveRef.current) return;
+      lastActiveRef.current = scrollKey;
+      setActiveFilePath(taskId, scrollKey);
+    },
+    [items, setActiveFilePath, taskId],
+  );
 
-    return () => observer.disconnect();
-  }, [taskId, setActiveFilePath]);
+  const renderItem = useCallback(
+    (item: ReviewListItem) => (
+      <div
+        key={item.key}
+        data-scroll-key={item.scrollKey}
+        className="pb-2 last:pb-0"
+      >
+        {item.node}
+      </div>
+    ),
+    [],
+  );
 
   return (
     <WorkerPoolContextProvider
       poolOptions={{ workerFactory }}
       highlighterOptions={{
         theme: { dark: "github-dark", light: "github-light" },
+        langs: [
+          "typescript",
+          "tsx",
+          "javascript",
+          "jsx",
+          "json",
+          "css",
+          "html",
+          "markdown",
+          "python",
+          "ruby",
+          "go",
+          "rust",
+          "shell",
+          "yaml",
+          "sql",
+        ],
       }}
     >
       <Flex direction="column" height="100%" id="review-shell">
@@ -430,25 +374,30 @@ export function ReviewShell({
           defaultBranch={defaultBranch}
         />
         <Flex className="min-h-0 flex-1">
-          <div
-            ref={scrollContainerRef}
-            className="scrollbar-overlay-y min-w-0 flex-1 space-y-2 overflow-auto"
-            id="review-shell-diff-container"
-          >
-            {isLoading ? (
-              <Flex align="center" justify="center" height="100%">
-                <Spinner size="2" />
-              </Flex>
-            ) : isEmpty ? (
-              <Flex align="center" justify="center" height="100%">
-                <Text color="gray" className="text-sm">
-                  No file changes to review
-                </Text>
-              </Flex>
-            ) : (
-              children
-            )}
-          </div>
+          {isLoading ? (
+            <Flex align="center" justify="center" className="min-w-0 flex-1">
+              <Spinner size="2" />
+            </Flex>
+          ) : isEmpty ? (
+            <Flex align="center" justify="center" className="min-w-0 flex-1">
+              <Text color="gray" className="text-sm">
+                No file changes to review
+              </Text>
+            </Flex>
+          ) : (
+            <VList
+              ref={listRef}
+              bufferSize={REVIEW_LIST_BUFFER_PX}
+              itemSize={REVIEW_LIST_ESTIMATED_ITEM_SIZE}
+              className="pierre-scroll-root scrollbar-overlay-y min-w-0 flex-1 overflow-auto bg-(--gray-2)"
+              shift={false}
+              style={{ scrollbarGutter: "stable" }}
+              onScroll={handleScroll}
+              data={items}
+            >
+              {renderItem}
+            </VList>
+          )}
 
           {isExpanded && <ExpandedSidebar task={task} />}
         </Flex>
@@ -457,7 +406,7 @@ export function ReviewShell({
   );
 }
 
-function FileHeaderRow({
+export function FileHeaderRow({
   dirPath,
   fileName,
   additions,
@@ -556,17 +505,10 @@ export function DiffFileHeader({
   );
 }
 
-function getDeferredMessage(
-  reason: DeferredReason,
-  totalLines: number,
-): string {
+function getDeferredMessage(reason: DeferredReason): string {
   switch (reason) {
-    case "deleted":
-      return `Deleted file not rendered — ${totalLines} lines removed.`;
-    case "generated":
-      return `Generated file not rendered — ${totalLines} lines changed.`;
-    case "large":
-      return `Large diff not rendered — ${totalLines} lines changed.`;
+    case "line-limit":
+      return "File exceeds the 5,000-line review limit.";
     case "unavailable":
       return "Unable to load diff.";
   }
@@ -605,7 +547,7 @@ export function DeferredDiffPlaceholder({
       />
       {!collapsed && (
         <div className="w-full border-b border-b-(--gray-5) bg-(--gray-2) p-[16px] text-center text-(--gray-9) text-xs">
-          {getDeferredMessage(reason, linesAdded + linesRemoved)}
+          {getDeferredMessage(reason)}
           {onShow ? (
             <>
               {" "}
diff --git a/apps/code/src/renderer/features/code-review/components/reviewItemBuilders.tsx b/apps/code/src/renderer/features/code-review/components/reviewItemBuilders.tsx
new file mode 100644
index 000000000..6a54f55c9
--- /dev/null
+++ b/apps/code/src/renderer/features/code-review/components/reviewItemBuilders.tsx
@@ -0,0 +1,146 @@
+import { makeFileKey } from "@features/git-interaction/utils/fileKey";
+import type { parsePatchFiles } from "@pierre/diffs";
+import type { ChangedFile } from "@shared/types";
+import type { DiffOptions } from "../types";
+import type { PrCommentThread } from "../utils/prCommentAnnotations";
+import { PatchRow, RemoteRow, UntrackedRow } from "./ReviewRows";
+import type { ReviewListItem } from "./ReviewShell";
+
+interface BuildPatchReviewItemsArgs {
+  files: ReturnType<typeof parsePatchFiles>[number]["files"];
+  staged?: boolean;
+  alsoStagedPaths?: Set<string>;
+  repoPath: string;
+  taskId: string;
+  diffOptions: DiffOptions;
+  collapsedFiles: Set<string>;
+  toggleFile: (key: string) => void;
+  openFile: (taskId: string, path: string, preview: boolean) => void;
+  prUrl: string | null;
+  commentThreads?: Map<number, PrCommentThread>;
+}
+
+export function buildPatchReviewItems({
+  files,
+  staged = false,
+  alsoStagedPaths,
+  repoPath,
+  taskId,
+  diffOptions,
+  collapsedFiles,
+  toggleFile,
+  openFile,
+  prUrl,
+  commentThreads,
+}: BuildPatchReviewItemsArgs): ReviewListItem[] {
+  return files.map((fileDiff) => {
+    const filePath = fileDiff.name ?? fileDiff.prevName ?? "";
+    const key = makeFileKey(staged, filePath);
+    const isCollapsed = collapsedFiles.has(key);
+    const skipExpansion = staged || (alsoStagedPaths?.has(filePath) ?? false);
+
+    return {
+      key,
+      scrollKey: key,
+      node: (
+        <PatchRow
+          itemKey={key}
+          filePath={filePath}
+          fileDiff={fileDiff}
+          repoPath={repoPath}
+          taskId={taskId}
+          diffOptions={diffOptions}
+          collapsed={isCollapsed}
+          skipExpansion={skipExpansion}
+          toggleFile={toggleFile}
+          openFile={openFile}
+          prUrl={prUrl}
+          commentThreads={commentThreads}
+        />
+      ),
+    };
+  });
+}
+
+interface BuildUntrackedReviewItemsArgs {
+  files: ChangedFile[];
+  repoPath: string;
+  taskId: string;
+  diffOptions: DiffOptions;
+  collapsedFiles: Set<string>;
+  toggleFile: (key: string) => void;
+}
+
+export function buildUntrackedReviewItems({
+  files,
+  repoPath,
+  taskId,
+  diffOptions,
+  collapsedFiles,
+  toggleFile,
+}: BuildUntrackedReviewItemsArgs): ReviewListItem[] {
+  return files.map((file) => {
+    const key = makeFileKey(file.staged, file.path);
+    const isCollapsed = collapsedFiles.has(key);
+
+    return {
+      key,
+      scrollKey: key,
+      node: (
+        <UntrackedRow
+          itemKey={key}
+          file={file}
+          repoPath={repoPath}
+          taskId={taskId}
+          diffOptions={diffOptions}
+          collapsed={isCollapsed}
+          toggleFile={toggleFile}
+        />
+      ),
+    };
+  });
+}
+
+interface BuildRemoteReviewItemsArgs {
+  files: ChangedFile[];
+  taskId: string;
+  prUrl?: string | null;
+  options: DiffOptions;
+  collapsedFiles: Set<string>;
+  toggleFile: (path: string) => void;
+  commentThreads?: Map<number, PrCommentThread>;
+}
+
+export function buildRemoteReviewItems({
+  files,
+  taskId,
+  prUrl,
+  options,
+  collapsedFiles,
+  toggleFile,
+  commentThreads,
+}: BuildRemoteReviewItemsArgs): ReviewListItem[] {
+  return files.map((file) => {
+    const isCollapsed = collapsedFiles.has(file.path);
+    const githubFileUrl = prUrl
+      ? `${prUrl}/files#diff-${file.path.replaceAll("/", "-")}`
+      : undefined;
+
+    return {
+      key: file.path,
+      scrollKey: file.path,
+      node: (
+        <RemoteRow
+          file={file}
+          taskId={taskId}
+          prUrl={prUrl}
+          options={options}
+          collapsed={isCollapsed}
+          toggleFile={toggleFile}
+          commentThreads={commentThreads}
+          externalUrl={githubFileUrl}
+        />
+      ),
+    };
+  });
+}
diff --git a/apps/code/src/renderer/features/code-review/constants.ts b/apps/code/src/renderer/features/code-review/constants.ts
new file mode 100644
index 000000000..cd757bb50
--- /dev/null
+++ b/apps/code/src/renderer/features/code-review/constants.ts
@@ -0,0 +1,13 @@
+export const REVIEW_FILE_CACHE_TIME_MS = 5 * 60_000;
+export const REVIEW_PREFETCH_ROOT_MARGIN = "1500px 0px";
+export const REVIEW_MAX_FILE_LINES = 5_000;
+export const REVIEW_LIST_BUFFER_PX = 1_600;
+export const REVIEW_LIST_ESTIMATED_ITEM_SIZE = 320;
+
+export const DIFF_METRICS = {
+  hunkLineCount: 50,
+  lineHeight: 20,
+  diffHeaderHeight: 31,
+  hunkSeparatorHeight: 32,
+  fileGap: 8,
+} as const;
diff --git a/apps/code/src/renderer/features/code-review/hooks/useDiffStatsToggle.ts b/apps/code/src/renderer/features/code-review/hooks/useDiffStatsToggle.ts
new file mode 100644
index 000000000..b15b3aac7
--- /dev/null
+++ b/apps/code/src/renderer/features/code-review/hooks/useDiffStatsToggle.ts
@@ -0,0 +1,43 @@
+import { useReviewNavigationStore } from "@renderer/features/code-review/stores/reviewNavigationStore";
+import type { Task } from "@shared/types";
+import { useCallback } from "react";
+import type { ReviewMode } from "../stores/reviewNavigationStore";
+import { useTaskDiffSummaryStats } from "./useTaskDiffSummaryStats";
+
+interface DiffStatsToggleResult {
+  filesChanged: number;
+  linesAdded: number;
+  linesRemoved: number;
+  hasChanges: boolean;
+  isOpen: boolean;
+  toggle: () => void;
+}
+
+export function useDiffStatsToggle(
+  task: Task,
+  openMode: ReviewMode = "split",
+): DiffStatsToggleResult {
+  const taskId = task.id;
+  const { filesChanged, linesAdded, linesRemoved } =
+    useTaskDiffSummaryStats(task);
+
+  const reviewMode = useReviewNavigationStore(
+    (s) => s.reviewModes[taskId] ?? "closed",
+  );
+  const setReviewMode = useReviewNavigationStore((s) => s.setReviewMode);
+
+  const isOpen = reviewMode !== "closed";
+  const toggle = useCallback(
+    () => setReviewMode(taskId, isOpen ? "closed" : openMode),
+    [setReviewMode, taskId, isOpen, openMode],
+  );
+
+  return {
+    filesChanged,
+    linesAdded,
+    linesRemoved,
+    hasChanges: filesChanged > 0,
+    isOpen,
+    toggle,
+  };
+}
diff --git a/apps/code/src/renderer/features/code-review/hooks/useEffectiveDiffSource.ts b/apps/code/src/renderer/features/code-review/hooks/useEffectiveDiffSource.ts
index f0291f586..37a21a86f 100644
--- a/apps/code/src/renderer/features/code-review/hooks/useEffectiveDiffSource.ts
+++ b/apps/code/src/renderer/features/code-review/hooks/useEffectiveDiffSource.ts
@@ -1,9 +1,10 @@
 import { useDiffViewerStore } from "@features/code-editor/stores/diffViewerStore";
-import { useGitQueries } from "@features/git-interaction/hooks/useGitQueries";
 import { useLinkedBranchPrUrl } from "@features/git-interaction/hooks/useLinkedBranchPrUrl";
 import type { DiffStats } from "@features/git-interaction/utils/diffStats";
 import { useCwd } from "@features/sidebar/hooks/useCwd";
 import { useWorkspace } from "@features/workspace/hooks/useWorkspace";
+import { useTRPC } from "@renderer/trpc";
+import { useQuery } from "@tanstack/react-query";
 import {
   type ResolvedDiffSource,
   resolveDiffSource,
@@ -20,21 +21,55 @@ export interface EffectiveDiffSource {
   diffStats: DiffStats;
 }
 
-/**
- * Resolves which diff source should be shown for a local task, plus all the
- * context needed to actually fetch that source. Callers (review panel, diff
- * stats badge) share one source-of-truth so UI surfaces never disagree.
- */
 export function useEffectiveDiffSource(taskId: string): EffectiveDiffSource {
+  const trpc = useTRPC();
   const repoPath = useCwd(taskId);
   const workspace = useWorkspace(taskId);
   const linkedBranch = workspace?.linkedBranch ?? null;
 
   const configured = useDiffViewerStore((s) => s.diffSource[taskId] ?? null);
 
-  const { repoInfo, aheadOfDefault, defaultBranch, changedFiles, diffStats } =
-    useGitQueries(repoPath);
-  const hasLocalChanges = changedFiles.length > 0;
+  const enabled = !!repoPath;
+  const emptyDiffStats: DiffStats = {
+    filesChanged: 0,
+    linesAdded: 0,
+    linesRemoved: 0,
+  };
+
+  const { data: syncStatus } = useQuery(
+    trpc.git.getGitSyncStatus.queryOptions(
+      { directoryPath: repoPath as string },
+      {
+        enabled,
+        staleTime: 30_000,
+      },
+    ),
+  );
+
+  const { data: repoInfo } = useQuery(
+    trpc.git.getGitRepoInfo.queryOptions(
+      { directoryPath: repoPath as string },
+      {
+        enabled,
+        staleTime: 60_000,
+      },
+    ),
+  );
+
+  const { data: diffStats = emptyDiffStats } = useQuery(
+    trpc.git.getDiffStats.queryOptions(
+      { directoryPath: repoPath as string },
+      {
+        enabled,
+        staleTime: 30_000,
+        placeholderData: (prev) => prev ?? emptyDiffStats,
+      },
+    ),
+  );
+
+  const aheadOfDefault = syncStatus?.aheadOfDefault ?? 0;
+  const defaultBranch = repoInfo?.defaultBranch ?? null;
+  const hasLocalChanges = diffStats.filesChanged > 0;
   const branchSourceAvailable = !!linkedBranch && aheadOfDefault > 0;
 
   const prUrl = useLinkedBranchPrUrl(taskId);
diff --git a/apps/code/src/renderer/features/code-review/hooks/useExpandableFileDiff.ts b/apps/code/src/renderer/features/code-review/hooks/useExpandableFileDiff.ts
index bd30522db..8eb106370 100644
--- a/apps/code/src/renderer/features/code-review/hooks/useExpandableFileDiff.ts
+++ b/apps/code/src/renderer/features/code-review/hooks/useExpandableFileDiff.ts
@@ -2,37 +2,69 @@ import type { FileDiffMetadata } from "@pierre/diffs";
 import { useTRPC } from "@renderer/trpc/client";
 import { useQuery } from "@tanstack/react-query";
 import { useMemo } from "react";
+import { REVIEW_FILE_CACHE_TIME_MS } from "../constants";
 import {
   buildExpandedFileDiff,
   canExpandFileDiff,
 } from "../utils/fileDiffExpansion";
+import { useReadRepoFileBounded } from "./useReadRepoFileBounded";
+
+export interface ExpandableFileDiffResult {
+  fileDiff: FileDiffMetadata;
+  tooLarge: boolean;
+  pending: boolean;
+}
 
 export function useExpandableFileDiff(
   patchFileDiff: FileDiffMetadata,
   repoPath: string | undefined,
   skip: boolean,
-): FileDiffMetadata {
+  inView = true,
+): ExpandableFileDiffResult {
   const trpc = useTRPC();
   const filePath = patchFileDiff.name ?? patchFileDiff.prevName ?? "";
   const prevPath = patchFileDiff.prevName ?? filePath;
-  const enabled = canExpandFileDiff(patchFileDiff, repoPath, skip);
+  const canExpand = canExpandFileDiff(patchFileDiff, repoPath, skip);
+  const enabled = canExpand && inView;
 
   const { data: headContent } = useQuery(
     trpc.git.getFileAtHead.queryOptions(
       { directoryPath: repoPath ?? "", filePath: prevPath },
-      { enabled, staleTime: 30_000 },
+      {
+        enabled,
+        staleTime: 30_000,
+        gcTime: REVIEW_FILE_CACHE_TIME_MS,
+      },
     ),
   );
 
-  const { data: workingContent } = useQuery(
-    trpc.fs.readRepoFile.queryOptions(
-      { repoPath: repoPath ?? "", filePath },
-      { enabled, staleTime: 30_000 },
-    ),
+  const { data: workingResult } = useReadRepoFileBounded(
+    repoPath ?? "",
+    filePath,
+    enabled,
   );
 
   return useMemo(() => {
-    if (!enabled) return patchFileDiff;
-    return buildExpandedFileDiff(patchFileDiff, headContent, workingContent);
-  }, [enabled, patchFileDiff, headContent, workingContent]);
+    if (!canExpand) {
+      return { fileDiff: patchFileDiff, tooLarge: false, pending: false };
+    }
+    if (!workingResult || headContent === undefined) {
+      return { fileDiff: patchFileDiff, tooLarge: false, pending: true };
+    }
+    if (workingResult.kind === "too-large") {
+      return { fileDiff: patchFileDiff, tooLarge: true, pending: false };
+    }
+    if (workingResult.kind === "missing") {
+      return { fileDiff: patchFileDiff, tooLarge: false, pending: false };
+    }
+    return {
+      fileDiff: buildExpandedFileDiff(
+        patchFileDiff,
+        headContent,
+        workingResult.content,
+      ),
+      tooLarge: false,
+      pending: false,
+    };
+  }, [canExpand, patchFileDiff, headContent, workingResult]);
 }
diff --git a/apps/code/src/renderer/features/code-review/hooks/useReadRepoFileBounded.ts b/apps/code/src/renderer/features/code-review/hooks/useReadRepoFileBounded.ts
new file mode 100644
index 000000000..28d44b229
--- /dev/null
+++ b/apps/code/src/renderer/features/code-review/hooks/useReadRepoFileBounded.ts
@@ -0,0 +1,21 @@
+import { useTRPC } from "@renderer/trpc/client";
+import { useQuery } from "@tanstack/react-query";
+import { REVIEW_FILE_CACHE_TIME_MS, REVIEW_MAX_FILE_LINES } from "../constants";
+
+export function useReadRepoFileBounded(
+  repoPath: string,
+  filePath: string,
+  enabled: boolean,
+) {
+  const trpc = useTRPC();
+  return useQuery(
+    trpc.fs.readRepoFileBounded.queryOptions(
+      { repoPath, filePath, maxLines: REVIEW_MAX_FILE_LINES },
+      {
+        enabled,
+        staleTime: 30_000,
+        gcTime: REVIEW_FILE_CACHE_TIME_MS,
+      },
+    ),
+  );
+}
diff --git a/apps/code/src/renderer/features/code-review/hooks/useReviewDiffs.ts b/apps/code/src/renderer/features/code-review/hooks/useReviewDiffs.ts
index 35f10631a..d21a64ac7 100644
--- a/apps/code/src/renderer/features/code-review/hooks/useReviewDiffs.ts
+++ b/apps/code/src/renderer/features/code-review/hooks/useReviewDiffs.ts
@@ -6,13 +6,16 @@ import { parsePatchFiles } from "@pierre/diffs";
 import { useTRPC } from "@renderer/trpc/client";
 import { useQuery } from "@tanstack/react-query";
 import { useCallback, useMemo } from "react";
+import { contentHash } from "../utils/contentHash";
 
 export function useReviewDiffs(
   repoPath: string | undefined,
   isActive: boolean,
 ) {
   const trpc = useTRPC();
-  const { changedFiles, changesLoading } = useGitQueries(repoPath);
+  const { changedFiles, changesLoading } = useGitQueries(repoPath, {
+    enabled: isActive,
+  });
   const hideWhitespace = useDiffViewerStore((s) => s.hideWhitespaceChanges);
 
   const hasStagedFiles = useMemo(
@@ -30,6 +33,7 @@ export function useReviewDiffs(
       {
         enabled: isActive && !!repoPath && hasStagedFiles,
         staleTime: 30_000,
+        gcTime: 0,
         refetchOnMount: "always",
       },
     ),
@@ -45,6 +49,7 @@ export function useReviewDiffs(
       {
         enabled: isActive && !!repoPath,
         staleTime: 30_000,
+        gcTime: 0,
         refetchOnMount: "always",
       },
     ),
@@ -56,7 +61,10 @@ export function useReviewDiffs(
   const stagedParsedFiles = useMemo(
     () =>
       rawDiffCached
-        ? parsePatchFiles(rawDiffCached).flatMap((p) => p.files)
+        ? parsePatchFiles(
+            rawDiffCached,
+            `staged:${contentHash(rawDiffCached)}`,
+          ).flatMap((p) => p.files)
         : [],
     [rawDiffCached],
   );
@@ -64,13 +72,16 @@ export function useReviewDiffs(
   const unstagedParsedFiles = useMemo(
     () =>
       rawDiffUnstaged
-        ? parsePatchFiles(rawDiffUnstaged).flatMap((p) => p.files)
+        ? parsePatchFiles(
+            rawDiffUnstaged,
+            `unstaged:${contentHash(rawDiffUnstaged)}`,
+          ).flatMap((p) => p.files)
         : [],
     [rawDiffUnstaged],
   );
 
   const untrackedFiles = useMemo(
-    () => changedFiles.filter((f) => f.status === "untracked"),
+    () => changedFiles.filter((f) => f.status === "untracked").slice(0, 1000),
     [changedFiles],
   );
 
diff --git a/apps/code/src/renderer/features/code-review/hooks/useTaskDiffStats.ts b/apps/code/src/renderer/features/code-review/hooks/useTaskDiffSummaryStats.ts
similarity index 80%
rename from apps/code/src/renderer/features/code-review/hooks/useTaskDiffStats.ts
rename to apps/code/src/renderer/features/code-review/hooks/useTaskDiffSummaryStats.ts
index c055739e7..68f880e32 100644
--- a/apps/code/src/renderer/features/code-review/hooks/useTaskDiffStats.ts
+++ b/apps/code/src/renderer/features/code-review/hooks/useTaskDiffSummaryStats.ts
@@ -13,7 +13,13 @@ import type { Task } from "@shared/types";
 import { useMemo } from "react";
 import { useEffectiveDiffSource } from "./useEffectiveDiffSource";
 
-export function useTaskDiffStats(task: Task): DiffStats {
+const EMPTY_DIFF_STATS: DiffStats = {
+  filesChanged: 0,
+  linesAdded: 0,
+  linesRemoved: 0,
+};
+
+export function useTaskDiffSummaryStats(task: Task): DiffStats {
   const taskId = task.id;
   const workspace = useWorkspace(taskId);
   const isCloud =
@@ -39,11 +45,11 @@ export function useTaskDiffStats(task: Task): DiffStats {
 
   return useMemo<DiffStats>(() => {
     if (isCloud) return computeDiffStats(reviewFiles);
-    if (effectiveSource === "branch" && branchFiles) {
-      return computeDiffStats(branchFiles);
+    if (effectiveSource === "branch") {
+      return branchFiles ? computeDiffStats(branchFiles) : EMPTY_DIFF_STATS;
     }
-    if (effectiveSource === "pr" && prFiles) {
-      return computeDiffStats(prFiles);
+    if (effectiveSource === "pr") {
+      return prFiles ? computeDiffStats(prFiles) : EMPTY_DIFF_STATS;
     }
     return localDiffStats;
   }, [
diff --git a/apps/code/src/renderer/features/code-review/utils/contentHash.ts b/apps/code/src/renderer/features/code-review/utils/contentHash.ts
new file mode 100644
index 000000000..2641ddba3
--- /dev/null
+++ b/apps/code/src/renderer/features/code-review/utils/contentHash.ts
@@ -0,0 +1,17 @@
+export function contentHash(input: string): string {
+  let h1 = 0xdeadbeef;
+  let h2 = 0x41c6ce57;
+  for (let i = 0, len = input.length; i < len; i++) {
+    const ch = input.charCodeAt(i);
+    h1 = Math.imul(h1 ^ ch, 2654435761);
+    h2 = Math.imul(h2 ^ ch, 1597334677);
+  }
+  h1 = Math.imul(h1 ^ (h1 >>> 16), 2246822507);
+  h1 ^= Math.imul(h2 ^ (h2 >>> 13), 3266489909);
+  h2 = Math.imul(h2 ^ (h2 >>> 16), 2246822507);
+  h2 ^= Math.imul(h1 ^ (h1 >>> 13), 3266489909);
+  return (
+    (h2 >>> 0).toString(16).padStart(8, "0") +
+    (h1 >>> 0).toString(16).padStart(8, "0")
+  );
+}
diff --git a/apps/code/src/renderer/features/git-interaction/hooks/useGitQueries.ts b/apps/code/src/renderer/features/git-interaction/hooks/useGitQueries.ts
index c2cae954f..2653bd1d3 100644
--- a/apps/code/src/renderer/features/git-interaction/hooks/useGitQueries.ts
+++ b/apps/code/src/renderer/features/git-interaction/hooks/useGitQueries.ts
@@ -8,9 +8,16 @@ const GIT_QUERY_DEFAULTS = {
   staleTime: 30_000,
 } as const;
 
-export function useGitQueries(repoPath?: string) {
+interface UseGitQueriesOptions {
+  enabled?: boolean;
+}
+
+export function useGitQueries(
+  repoPath?: string,
+  options?: UseGitQueriesOptions,
+) {
   const trpc = useTRPC();
-  const enabled = !!repoPath;
+  const enabled = !!repoPath && (options?.enabled ?? true);
 
   const { data: isRepo = false, isLoading: isRepoLoading } = useQuery(
     trpc.git.validateRepo.queryOptions(
diff --git a/apps/code/src/renderer/features/git-interaction/utils/gitCacheKeys.ts b/apps/code/src/renderer/features/git-interaction/utils/gitCacheKeys.ts
index fb29935e5..cf4e3a5c0 100644
--- a/apps/code/src/renderer/features/git-interaction/utils/gitCacheKeys.ts
+++ b/apps/code/src/renderer/features/git-interaction/utils/gitCacheKeys.ts
@@ -27,3 +27,17 @@ export function invalidateGitBranchQueries(repoPath: string) {
     trpc.git.getLocalBranchChangedFiles.pathFilter(),
   );
 }
+
+export function clearGitReviewQueries() {
+  queryClient.removeQueries(trpc.git.getDiffCached.pathFilter());
+  queryClient.removeQueries(trpc.git.getDiffUnstaged.pathFilter());
+  queryClient.removeQueries(trpc.git.getFileAtHead.pathFilter());
+  queryClient.removeQueries(trpc.fs.readRepoFile.pathFilter());
+  queryClient.removeQueries(trpc.fs.readRepoFiles.pathFilter());
+  queryClient.removeQueries(trpc.fs.readRepoFileBounded.pathFilter());
+  queryClient.removeQueries(trpc.fs.readRepoFilesBounded.pathFilter());
+  queryClient.removeQueries(trpc.git.getLocalBranchChangedFiles.pathFilter());
+  queryClient.removeQueries(trpc.git.getPrChangedFiles.pathFilter());
+  queryClient.removeQueries(trpc.git.getPrDetailsByUrl.pathFilter());
+  queryClient.removeQueries(trpc.git.getPrReviewComments.pathFilter());
+}
diff --git a/apps/code/src/renderer/features/sessions/components/DiffStatsChip.tsx b/apps/code/src/renderer/features/sessions/components/DiffStatsChip.tsx
index cc8519836..2a412c60f 100644
--- a/apps/code/src/renderer/features/sessions/components/DiffStatsChip.tsx
+++ b/apps/code/src/renderer/features/sessions/components/DiffStatsChip.tsx
@@ -1,6 +1,5 @@
 import { Tooltip } from "@components/ui/Tooltip";
-import { useTaskDiffStats } from "@features/code-review/hooks/useTaskDiffStats";
-import { useReviewNavigationStore } from "@features/code-review/stores/reviewNavigationStore";
+import { useDiffStatsToggle } from "@features/code-review/hooks/useDiffStatsToggle";
 import { GitDiff } from "@phosphor-icons/react";
 import { Flex, Text } from "@radix-ui/themes";
 import {
@@ -14,22 +13,11 @@ interface DiffStatsChipProps {
 }
 
 export function DiffStatsChip({ task }: DiffStatsChipProps) {
-  const taskId = task.id;
-  const { filesChanged, linesAdded, linesRemoved } = useTaskDiffStats(task);
-
-  const reviewMode = useReviewNavigationStore(
-    (s) => s.reviewModes[taskId] ?? "closed",
-  );
-  const setReviewMode = useReviewNavigationStore((s) => s.setReviewMode);
+  const { filesChanged, linesAdded, linesRemoved, isOpen, toggle } =
+    useDiffStatsToggle(task, "expanded");
 
   if (filesChanged === 0) return null;
 
-  const isOpen = reviewMode !== "closed";
-
-  const handleClick = () => {
-    setReviewMode(taskId, isOpen ? "closed" : "expanded");
-  };
-
   return (
     <Tooltip
       content={isOpen ? "Close review" : "Open review"}
@@ -39,7 +27,7 @@ export function DiffStatsChip({ task }: DiffStatsChipProps) {
       <Flex
         align="center"
         gap="1"
-        onClick={handleClick}
+        onClick={toggle}
         className="cursor-pointer select-none text-[13px] text-gray-10 tabular-nums hover:text-gray-12"
       >
         <GitDiff size={12} className="shrink-0" />
diff --git a/apps/code/src/renderer/features/task-detail/components/ChangesPanel.tsx b/apps/code/src/renderer/features/task-detail/components/ChangesPanel.tsx
index dcf64daa3..c5d9bcf1a 100644
--- a/apps/code/src/renderer/features/task-detail/components/ChangesPanel.tsx
+++ b/apps/code/src/renderer/features/task-detail/components/ChangesPanel.tsx
@@ -54,11 +54,9 @@ interface ChangedFileItemProps {
   file: ChangedFile;
   taskId: string;
   isActive: boolean;
-  /** When provided, enables the hover toolbar (discard, open-with, context menu) */
   repoPath?: string;
   mainRepoPath?: string;
   onStageToggle?: (file: ChangedFile) => void;
-  /** Tree indentation depth (0 = flat list) */
   depth?: number;
 }
 
@@ -140,8 +138,8 @@ function ChangedFileItem({
   const { detectedApps } = useExternalApps();
   const workspace = useWorkspace(taskId);
 
-  const [isDropdownOpen, setIsDropdownOpen] = useState(false);
   const [isHovered, setIsHovered] = useState(false);
+  const [isDropdownOpen, setIsDropdownOpen] = useState(false);
 
   const isLocal = !!repoPath;
   const isToolbarVisible = isLocal && (isHovered || isDropdownOpen);
diff --git a/apps/code/src/renderer/features/task-detail/components/TaskDetail.tsx b/apps/code/src/renderer/features/task-detail/components/TaskDetail.tsx
index da7c3fc53..20728945b 100644
--- a/apps/code/src/renderer/features/task-detail/components/TaskDetail.tsx
+++ b/apps/code/src/renderer/features/task-detail/components/TaskDetail.tsx
@@ -2,6 +2,7 @@ import { CloudReviewPage } from "@features/code-review/components/CloudReviewPag
 import { ReviewPage } from "@features/code-review/components/ReviewPage";
 import { useReviewNavigationStore } from "@features/code-review/stores/reviewNavigationStore";
 import { FilePicker } from "@features/command/components/FilePicker";
+import { clearGitReviewQueries } from "@features/git-interaction/utils/gitCacheKeys";
 import { PanelLayout } from "@features/panels";
 import { usePanelLayoutStore } from "@features/panels/store/panelLayoutStore";
 import {
@@ -174,6 +175,11 @@ export function TaskDetail({ task: initialTask }: TaskDetailProps) {
   const isReviewOpen = reviewMode !== "closed";
   const isExpanded = reviewMode === "expanded";
 
+  useEffect(() => {
+    if (isReviewOpen) return;
+    clearGitReviewQueries();
+  }, [isReviewOpen]);
+
   const containerRef = useRef<HTMLDivElement>(null);
   const [reviewWidth, setReviewWidth] = useState<number | null>(null);
   const isDragging = useRef(false);
@@ -234,28 +240,26 @@ export function TaskDetail({ task: initialTask }: TaskDetailProps) {
           />
         )}
 
-        <Box
-          style={{
-            flex: isExpanded ? 1 : undefined,
-            width: isReviewOpen
-              ? isExpanded
+        {isReviewOpen && (
+          <Box
+            style={{
+              flex: isExpanded ? 1 : undefined,
+              width: isExpanded
                 ? undefined
                 : reviewWidth
                   ? `${reviewWidth}px`
-                  : "50%"
-              : "0px",
-            minWidth: isReviewOpen ? `${MIN_REVIEW_WIDTH}px` : "0px",
-            overflow: isReviewOpen ? undefined : "hidden",
-            visibility: isReviewOpen ? undefined : "hidden",
-          }}
-          className="h-full"
-        >
-          {isCloud ? (
-            <CloudReviewPage task={task} />
-          ) : (
-            <ReviewPage task={task} />
-          )}
-        </Box>
+                  : "50%",
+              minWidth: `${MIN_REVIEW_WIDTH}px`,
+            }}
+            className="h-full"
+          >
+            {isCloud ? (
+              <CloudReviewPage task={task} />
+            ) : (
+              <ReviewPage task={task} />
+            )}
+          </Box>
+        )}
       </Flex>
       <FilePicker
         open={filePickerOpen}
diff --git a/apps/code/src/renderer/hooks/useFileWatcher.ts b/apps/code/src/renderer/hooks/useFileWatcher.ts
index 74cb7d41e..9ed8837f2 100644
--- a/apps/code/src/renderer/hooks/useFileWatcher.ts
+++ b/apps/code/src/renderer/hooks/useFileWatcher.ts
@@ -41,6 +41,12 @@ export function useFileWatcher(repoPath: string | null, taskId?: string) {
             filePath: relativePath,
           }),
         );
+        queryClient.invalidateQueries(
+          trpc.fs.readRepoFileBounded.queryFilter({
+            repoPath,
+            filePath: relativePath,
+          }),
+        );
         invalidateGitWorkingTreeQueries(repoPath);
       },
     }),
diff --git a/apps/code/src/renderer/hooks/useInView.ts b/apps/code/src/renderer/hooks/useInView.ts
new file mode 100644
index 000000000..f5ba8e5a3
--- /dev/null
+++ b/apps/code/src/renderer/hooks/useInView.ts
@@ -0,0 +1,32 @@
+import { useEffect, useRef, useState } from "react";
+
+interface UseInViewOptions {
+  rootMargin?: string;
+  once?: boolean;
+}
+
+export function useInView<T extends HTMLElement = HTMLDivElement>(
+  options: UseInViewOptions = {},
+) {
+  const { rootMargin = "1500px 0px", once = false } = options;
+  const ref = useRef<T | null>(null);
+  const [inView, setInView] = useState(false);
+
+  useEffect(() => {
+    const el = ref.current;
+    if (!el) return;
+
+    const observer = new IntersectionObserver(
+      ([entry]) => {
+        const visible = entry.isIntersecting;
+        setInView(visible);
+        if (visible && once) observer.disconnect();
+      },
+      { rootMargin },
+    );
+    observer.observe(el);
+    return () => observer.disconnect();
+  }, [rootMargin, once]);
+
+  return [ref, inView] as const;
+}
diff --git a/apps/code/src/renderer/main.tsx b/apps/code/src/renderer/main.tsx
index c0aabb2c4..c3a7fce92 100644
--- a/apps/code/src/renderer/main.tsx
+++ b/apps/code/src/renderer/main.tsx
@@ -2,11 +2,33 @@ import "reflect-metadata";
 // Side effect: attaches window focus/visibility listeners so `focused` is accurate before inbox queries mount.
 import "@stores/rendererWindowFocusStore";
 import { Providers } from "@components/Providers";
+import { preloadHighlighter } from "@pierre/diffs";
 import App from "@renderer/App";
 import React from "react";
 import ReactDOM from "react-dom/client";
 import "./styles/globals.css";
 
+void preloadHighlighter({
+  themes: ["github-dark", "github-light"],
+  langs: [
+    "typescript",
+    "tsx",
+    "javascript",
+    "jsx",
+    "json",
+    "css",
+    "html",
+    "markdown",
+    "python",
+    "ruby",
+    "go",
+    "rust",
+    "shell",
+    "yaml",
+    "sql",
+  ],
+});
+
 // HACK(@posthog/hedgehog-mode): The package bundles react-dom 18 code that
 // accesses React 18 internals at module scope. React 19 moved these to
 // __CLIENT_INTERNALS and removed the old names. Shim the old structure so the
diff --git a/packages/git/src/client.ts b/packages/git/src/client.ts
index ab91a2cf6..5f8fe1861 100644
--- a/packages/git/src/client.ts
+++ b/packages/git/src/client.ts
@@ -6,16 +6,26 @@ export interface CreateGitClientOptions extends Partial<SimpleGitOptions> {
   abortSignal?: AbortSignal;
 }
 
+const PERFORMANCE_CONFIG = [
+  "core.untrackedCache=true",
+  "core.fsmonitor=true",
+  "core.preloadIndex=true",
+];
+
 export function createGitClient(
   baseDir?: string,
   options?: CreateGitClientOptions,
 ): GitClient {
-  const { abortSignal: signal, ...rest } = options ?? {};
+  const { abortSignal: signal, config: callerConfig, ...rest } = options ?? {};
+  const config = callerConfig
+    ? [...PERFORMANCE_CONFIG, ...callerConfig]
+    : PERFORMANCE_CONFIG;
   return simpleGit({
     baseDir,
     maxConcurrentProcesses: 6,
     trimmed: true,
     abort: signal,
+    config,
     ...rest,
   });
 }
diff --git a/packages/git/src/queries.ts b/packages/git/src/queries.ts
index 2f8a81914..dc4cdcf82 100644
--- a/packages/git/src/queries.ts
+++ b/packages/git/src/queries.ts
@@ -2,6 +2,7 @@ import * as fs from "node:fs/promises";
 import * as path from "node:path";
 import type { CreateGitClientOptions } from "./client";
 import { getGitOperationManager } from "./operation-manager";
+import { streamGitStatus } from "./status-stream";
 
 export interface WorktreeListEntry {
   path: string;
@@ -20,6 +21,9 @@ export interface GitStatus {
   modified: string[];
   deleted: string[];
   untracked: string[];
+  overflowedDirs?: string[];
+  totalUntrackedSeen?: number;
+  totalUntrackedTruncated?: boolean;
 }
 
 type GitLike = {
@@ -139,21 +143,19 @@ export async function getStatus(
   baseDir: string,
   options?: CreateGitClientOptions,
 ): Promise<GitStatus> {
-  const manager = getGitOperationManager();
-  return manager.executeRead(
-    baseDir,
-    async (git) => {
-      const status = await git.status(["--untracked-files=all"]);
-      return {
-        isClean: status.isClean(),
-        staged: status.staged,
-        modified: status.modified,
-        deleted: status.deleted,
-        untracked: status.not_added,
-      };
-    },
-    { signal: options?.abortSignal },
-  );
+  const status = await streamGitStatus(baseDir, {
+    signal: options?.abortSignal,
+  });
+  return {
+    isClean: status.isClean,
+    staged: status.staged,
+    modified: status.modified,
+    deleted: status.deleted,
+    untracked: status.untracked,
+    overflowedDirs: status.overflowedDirs,
+    totalUntrackedSeen: status.totalUntrackedSeen,
+    totalUntrackedTruncated: status.totalUntrackedTruncated,
+  };
 }
 
 export async function hasChanges(
@@ -338,14 +340,17 @@ export async function getChangedFiles(
             }
           } catch {}
         }
+      } catch {}
 
-        const status = await git.status(["--untracked-files=all"]);
+      try {
+        const status = await streamGitStatus(baseDir, {
+          signal: options?.abortSignal,
+        });
         for (const file of [
           ...status.modified,
           ...status.created,
           ...status.deleted,
-          ...status.renamed.map((r) => r.to),
-          ...status.not_added,
+          ...status.untracked,
         ]) {
           changedFiles.add(file);
         }
@@ -418,6 +423,26 @@ async function countFileLines(filePath: string): Promise<number> {
   }
 }
 
+async function mapWithConcurrency<T, R>(
+  items: readonly T[],
+  concurrency: number,
+  mapper: (item: T) => Promise<R>,
+): Promise<R[]> {
+  if (items.length === 0) return [];
+  const results = new Array<R>(items.length);
+  let index = 0;
+  const worker = async () => {
+    while (index < items.length) {
+      const i = index++;
+      results[i] = await mapper(items[i]);
+    }
+  };
+  await Promise.all(
+    Array.from({ length: Math.min(concurrency, items.length) }, () => worker()),
+  );
+  return results;
+}
+
 export async function getChangedFilesDetailed(
   baseDir: string,
   options?: GetChangedFilesDetailedOptions,
@@ -432,9 +457,12 @@ export async function getChangedFilesDetailed(
         const [stagedSummary, unstagedSummary, status] = await Promise.all([
           git.diffSummary(["--cached", "-M", "HEAD"]),
           git.diffSummary(["-M"]),
-          git.status(["--untracked-files=all"]),
+          streamGitStatus(baseDir, { signal: gitOptions?.abortSignal }),
         ]);
 
+        const deletedSet = new Set(status.deleted);
+        const createdSet = new Set(status.created);
+
         const diffSeenPaths = new Set<string>();
         const excludedPaths = new Set<string>();
         const files: ChangedFileInfo[] = [];
@@ -456,9 +484,9 @@ export async function getChangedFilesDetailed(
             path: file.file,
             status: hasFrom
               ? "renamed"
-              : status.deleted.includes(file.file)
+              : deletedSet.has(file.file)
                 ? "deleted"
-                : status.created.includes(file.file)
+                : createdSet.has(file.file)
                   ? "added"
                   : "modified",
             originalPath: hasFrom ? (file.from as string) : undefined,
@@ -481,22 +509,27 @@ export async function getChangedFilesDetailed(
           pushDiffFile(file, false);
         }
 
-        const MAX_UNTRACKED_FILES = 10_000;
-        let untrackedProcessed = 0;
-        for (const file of status.not_added) {
-          if (untrackedProcessed >= MAX_UNTRACKED_FILES) break;
+        const untrackedToCount: string[] = [];
+        for (const file of status.untracked) {
           if (diffSeenPaths.has(file) || excludedPaths.has(file)) continue;
           if (excludePatterns && matchesExcludePattern(file, excludePatterns)) {
             continue;
           }
-          const lineCount = await countFileLines(path.join(baseDir, file));
+          untrackedToCount.push(file);
+        }
+
+        const untrackedLineCounts = await mapWithConcurrency(
+          untrackedToCount,
+          16,
+          (file) => countFileLines(path.join(baseDir, file)),
+        );
+        for (let i = 0; i < untrackedToCount.length; i++) {
           files.push({
-            path: file,
+            path: untrackedToCount[i],
             status: "untracked",
-            linesAdded: lineCount,
+            linesAdded: untrackedLineCounts[i],
             linesRemoved: 0,
           });
-          untrackedProcessed++;
         }
 
         return files;
diff --git a/packages/git/src/status-stream.test.ts b/packages/git/src/status-stream.test.ts
new file mode 100644
index 000000000..6004ddcfd
--- /dev/null
+++ b/packages/git/src/status-stream.test.ts
@@ -0,0 +1,101 @@
+import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { afterEach, describe, expect, it } from "vitest";
+import { createGitClient } from "./client";
+import { streamGitStatus } from "./status-stream";
+
+async function setupRepo(): Promise<string> {
+  const dir = await mkdtemp(path.join(tmpdir(), "posthog-code-status-stream-"));
+  const git = createGitClient(dir);
+  await git.init(["--initial-branch", "main"]);
+  await git.addConfig("user.name", "Test");
+  await git.addConfig("user.email", "test@example.com");
+  await git.addConfig("commit.gpgsign", "false");
+  await writeFile(path.join(dir, "file.txt"), "content\n");
+  await git.add(["file.txt"]);
+  await git.commit("initial");
+  return dir;
+}
+
+describe("streamGitStatus", () => {
+  let repoDir: string;
+
+  afterEach(async () => {
+    if (repoDir) await rm(repoDir, { recursive: true, force: true });
+  });
+
+  it("returns clean status for an unmodified repo", async () => {
+    repoDir = await setupRepo();
+    const status = await streamGitStatus(repoDir);
+    expect(status.isClean).toBe(true);
+    expect(status.untracked).toEqual([]);
+    expect(status.overflowedDirs).toEqual([]);
+  });
+
+  it("collapses a directory whose untracked file count exceeds the per-dir cap", async () => {
+    repoDir = await setupRepo();
+    const heavy = path.join(repoDir, "node_modules", "pkg");
+    await mkdir(heavy, { recursive: true });
+    await Promise.all(
+      Array.from({ length: 50 }, (_, i) =>
+        writeFile(path.join(heavy, `f${i}.js`), "x"),
+      ),
+    );
+    await writeFile(path.join(repoDir, "feature.ts"), "ok\n");
+
+    const status = await streamGitStatus(repoDir, { perDirUntrackedCap: 10 });
+
+    expect(status.untracked).toContain("feature.ts");
+    expect(status.overflowedDirs.length).toBeGreaterThan(0);
+    const filesUnderHeavy = status.untracked.filter((f) =>
+      f.startsWith("node_modules/"),
+    );
+    expect(filesUnderHeavy.length).toBeLessThanOrEqual(10);
+    expect(status.totalUntrackedSeen).toBeGreaterThanOrEqual(51);
+  });
+
+  it("keeps a folder fully expanded when its untracked count is within the cap", async () => {
+    repoDir = await setupRepo();
+    const feature = path.join(repoDir, "apps", "new-feature");
+    await mkdir(feature, { recursive: true });
+    await Promise.all(
+      Array.from({ length: 8 }, (_, i) =>
+        writeFile(path.join(feature, `mod-${i}.ts`), "x"),
+      ),
+    );
+
+    const status = await streamGitStatus(repoDir, { perDirUntrackedCap: 1000 });
+
+    const featureFiles = status.untracked.filter((f) =>
+      f.startsWith("apps/new-feature/"),
+    );
+    expect(featureFiles).toHaveLength(8);
+    expect(status.overflowedDirs).toEqual([]);
+  });
+
+  it("reports modified, staged, and deleted entries", async () => {
+    repoDir = await setupRepo();
+    const git = createGitClient(repoDir);
+    await writeFile(path.join(repoDir, "staged.txt"), "s\n");
+    await git.add(["staged.txt"]);
+    await writeFile(path.join(repoDir, "file.txt"), "modified\n");
+    await rm(path.join(repoDir, "file.txt"));
+
+    const status = await streamGitStatus(repoDir);
+
+    expect(status.staged).toContain("staged.txt");
+    expect(status.created).toContain("staged.txt");
+    expect(status.deleted).toContain("file.txt");
+    expect(status.isClean).toBe(false);
+  });
+
+  it("rejects when aborted", async () => {
+    repoDir = await setupRepo();
+    const controller = new AbortController();
+    controller.abort();
+    await expect(
+      streamGitStatus(repoDir, { signal: controller.signal }),
+    ).rejects.toThrow();
+  });
+});
diff --git a/packages/git/src/status-stream.ts b/packages/git/src/status-stream.ts
new file mode 100644
index 000000000..526dbcdb9
--- /dev/null
+++ b/packages/git/src/status-stream.ts
@@ -0,0 +1,206 @@
+import { spawn } from "node:child_process";
+import { getCleanEnv } from "./operation-manager";
+
+export interface StreamedGitStatus {
+  isClean: boolean;
+  staged: string[];
+  modified: string[];
+  created: string[];
+  deleted: string[];
+  untracked: string[];
+  overflowedDirs: string[];
+  totalUntrackedSeen: number;
+  totalUntrackedTruncated: boolean;
+}
+
+export interface StreamStatusOptions {
+  signal?: AbortSignal;
+  perDirUntrackedCap?: number;
+  totalUntrackedCap?: number;
+  gitBinary?: string;
+}
+
+const DEFAULT_PER_DIR_CAP = 1_000;
+const DEFAULT_TOTAL_CAP = 50_000;
+
+export function streamGitStatus(
+  baseDir: string,
+  options: StreamStatusOptions = {},
+): Promise<StreamedGitStatus> {
+  const perDirCap = options.perDirUntrackedCap ?? DEFAULT_PER_DIR_CAP;
+  const totalCap = options.totalUntrackedCap ?? DEFAULT_TOTAL_CAP;
+  const binary = options.gitBinary ?? "git";
+
+  return new Promise((resolve, reject) => {
+    const args = [
+      "-c",
+      "core.untrackedCache=true",
+      "-c",
+      "core.fsmonitor=true",
+      "-c",
+      "core.preloadIndex=true",
+      "status",
+      "--porcelain=v1",
+      "-z",
+      "--untracked-files=all",
+      "--no-renames",
+    ];
+
+    const child = spawn(binary, args, {
+      cwd: baseDir,
+      env: { ...getCleanEnv(), GIT_OPTIONAL_LOCKS: "0" },
+    });
+
+    const staged: string[] = [];
+    const modified: string[] = [];
+    const created: string[] = [];
+    const deleted: string[] = [];
+    const untracked: string[] = [];
+    const dirCounts = new Map<string, number>();
+    const collapsedDirs = new Set<string>();
+    let totalUntrackedSeen = 0;
+    let totalUntrackedTruncated = false;
+
+    let buffer = "";
+    let stderr = "";
+    let settled = false;
+
+    const settle = (fn: () => void) => {
+      if (settled) return;
+      settled = true;
+      fn();
+    };
+
+    const onAbort = () => {
+      child.kill("SIGTERM");
+    };
+
+    if (options.signal) {
+      if (options.signal.aborted) {
+        child.kill("SIGTERM");
+        settle(() => reject(new DOMException("Aborted", "AbortError")));
+        return;
+      }
+      options.signal.addEventListener("abort", onAbort, { once: true });
+    }
+
+    const consumeEntry = (entry: string) => {
+      if (entry.length < 3) return;
+      const x = entry[0];
+      const y = entry[1];
+      const filePath = entry.slice(3);
+      if (!filePath) return;
+
+      if (x === "?" && y === "?") {
+        totalUntrackedSeen++;
+        if (untracked.length >= totalCap) {
+          totalUntrackedTruncated = true;
+          return;
+        }
+        if (isUnderCollapsed(filePath, collapsedDirs)) return;
+
+        const ancestors = ancestorDirs(filePath);
+        let triggered: string | null = null;
+        for (const dir of ancestors) {
+          const count = (dirCounts.get(dir) ?? 0) + 1;
+          dirCounts.set(dir, count);
+          if (count > perDirCap && !triggered) {
+            triggered = dir;
+          }
+        }
+        if (triggered) {
+          collapsedDirs.add(triggered);
+          return;
+        }
+        untracked.push(filePath);
+        return;
+      }
+
+      if (x === "A") created.push(filePath);
+      if (x === "D" || y === "D") deleted.push(filePath);
+      if (y === "M" || y === "T") modified.push(filePath);
+      if (x !== " " && x !== "?") staged.push(filePath);
+    };
+
+    child.stdout.setEncoding("utf8");
+    child.stdout.on("data", (chunk: string) => {
+      buffer += chunk;
+      while (true) {
+        const nullIdx = buffer.indexOf("\0");
+        if (nullIdx === -1) break;
+        const entry = buffer.slice(0, nullIdx);
+        buffer = buffer.slice(nullIdx + 1);
+        if (entry) consumeEntry(entry);
+      }
+    });
+
+    child.stderr.setEncoding("utf8");
+    child.stderr.on("data", (chunk: string) => {
+      stderr += chunk;
+    });
+
+    child.on("error", (err) => {
+      options.signal?.removeEventListener("abort", onAbort);
+      settle(() => reject(err));
+    });
+
+    child.on("close", (code) => {
+      options.signal?.removeEventListener("abort", onAbort);
+      if (options.signal?.aborted) {
+        settle(() => reject(new DOMException("Aborted", "AbortError")));
+        return;
+      }
+      if (code !== 0) {
+        settle(() =>
+          reject(
+            new Error(
+              `git status exited with code ${code}: ${stderr.trim() || "unknown error"}`,
+            ),
+          ),
+        );
+        return;
+      }
+      const isClean =
+        staged.length === 0 &&
+        modified.length === 0 &&
+        created.length === 0 &&
+        deleted.length === 0 &&
+        untracked.length === 0 &&
+        collapsedDirs.size === 0;
+      settle(() =>
+        resolve({
+          isClean,
+          staged,
+          modified,
+          created,
+          deleted,
+          untracked,
+          overflowedDirs: [...collapsedDirs],
+          totalUntrackedSeen,
+          totalUntrackedTruncated,
+        }),
+      );
+    });
+  });
+}
+
+function ancestorDirs(filePath: string): string[] {
+  const result: string[] = [];
+  let idx = filePath.indexOf("/");
+  while (idx !== -1) {
+    result.push(filePath.slice(0, idx));
+    idx = filePath.indexOf("/", idx + 1);
+  }
+  return result;
+}
+
+function isUnderCollapsed(
+  filePath: string,
+  collapsedDirs: Set<string>,
+): boolean {
+  if (collapsedDirs.size === 0) return false;
+  for (const dir of ancestorDirs(filePath)) {
+    if (collapsedDirs.has(dir)) return true;
+  }
+  return false;
+}
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index c60b7de31..a491010fc 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -155,8 +155,8 @@ importers:
         specifier: ^2.1.10
         version: 2.1.10(react-dom@19.1.0(react@19.1.0))(react@19.1.0)
       '@pierre/diffs':
-        specifier: ^1.1.7
-        version: 1.1.7(react-dom@19.1.0(react@19.1.0))(react@19.1.0)
+        specifier: ^1.1.21
+        version: 1.1.21(react-dom@19.1.0(react@19.1.0))(react@19.1.0)
       '@posthog/agent':
         specifier: workspace:*
         version: link:../../packages/agent
@@ -3597,14 +3597,14 @@ packages:
       react: '>= 16.8'
       react-dom: '>= 16.8'
 
-  '@pierre/diffs@1.1.7':
-    resolution: {integrity: sha512-FWs2hHrjZPXmJl6ewnfFzOjNEM3aeSH1CB8ynZg4SOg95Wc5AxomeyJJhXf44PK9Cc+PNm1CgsJ1IvOdfgHyHA==}
+  '@pierre/diffs@1.1.21':
+    resolution: {integrity: sha512-4vz4YRg1qZEiVwx6EnaYlMSIIDOq1CvtcBEc4b/gNxDbQtlvGJof+IWH5cv/bwgDre377Txe/ML4zoSp78yWWw==}
     peerDependencies:
       react: ^18.3.1 || ^19.0.0
       react-dom: ^18.3.1 || ^19.0.0
 
-  '@pierre/theme@0.0.22':
-    resolution: {integrity: sha512-ePUIdQRNGjrveELTU7fY89Xa7YGHHEy5Po5jQy/18lm32eRn96+tnYJEtFooGdffrx55KBUtOXfvVy/7LDFFhA==}
+  '@pierre/theme@0.0.28':
+    resolution: {integrity: sha512-1j/H/fECBuc9dEvntdWI+l435HZapw+RCJTlqCA6BboQ5TjlnE005j/ROWutXIs8aq5OAc82JI2Kwk4A1WWBgw==}
     engines: {vscode: ^1.0.0}
 
   '@pixi/colord@2.9.6':
@@ -15230,9 +15230,9 @@ snapshots:
       react: 19.1.0
       react-dom: 19.1.0(react@19.1.0)
 
-  '@pierre/diffs@1.1.7(react-dom@19.1.0(react@19.1.0))(react@19.1.0)':
+  '@pierre/diffs@1.1.21(react-dom@19.1.0(react@19.1.0))(react@19.1.0)':
     dependencies:
-      '@pierre/theme': 0.0.22
+      '@pierre/theme': 0.0.28
       '@shikijs/transformers': 3.23.0
       diff: 8.0.3
       hast-util-to-html: 9.0.5
@@ -15241,7 +15241,7 @@ snapshots:
       react-dom: 19.1.0(react@19.1.0)
       shiki: 3.23.0
 
-  '@pierre/theme@0.0.22': {}
+  '@pierre/theme@0.0.28': {}
 
   '@pixi/colord@2.9.6': {}
 
diff --git a/pnpm-workspace.yaml b/pnpm-workspace.yaml
index bb9c29cf6..d6dda2de9 100644
--- a/pnpm-workspace.yaml
+++ b/pnpm-workspace.yaml
@@ -11,6 +11,7 @@ minimumReleaseAge: 1440
 minimumReleaseAgeExclude:
   - '@agentclientprotocol/sdk'
   - '@anthropic-ai/claude-agent-sdk'
+  - '@pierre/diffs'
   - '@posthog/quill'
   - '@posthog/quill-tokens'