pi-diff-review 0.1.24 → 0.1.26

package/README.md

@@ -1,10 +1,12 @@
-<img width="1400" height="225" alt="pi-diff-review" src="https://github.com/user-attachments/assets/049b2df9-ec38-4a9a-a824-8d682e77dae1" />
-
-# pi-diff-review
-
-Embedded code reviews and AI summaries directly within [pi](https://pi.dev/).
-
-<img width="1986" height="1556" alt="pi-diff-review-screenshot" src="https://github.com/user-attachments/assets/5ddd7226-28d4-4617-8c5c-35b4b6af68dc" />
+<div align="center">
+  <div>
+    <img height="96" alt="pi-diff-review" src="https://github.com/user-attachments/assets/7b97e6a2-9dc3-49f8-b932-f8a90a59bfcf" />
+  </div>
+  <b><i>Embedded code reviews and explanations directly within <a href="https://pi.dev">pi</a>.</i></b>
+  <div>
+    <img width="728" alt="image" src="https://github.com/user-attachments/assets/6bb72e25-369e-446b-888d-1561005c427e" />
+  </div>
+</div>
 
 ## Install
 
@@ -57,6 +59,18 @@ Review a single file by using a git pathspec after `--`. Pi path autocomplete wo
 
 `/diff <git-diff-args>` is passed through to `git diff`, so these examples are equivalent to running `git diff`, `git diff --cached`, and `git diff main...HEAD` locally before opening the review UI.
 
+Experimental: track reviewed turns while keeping the full overall diff visible:
+
+```text
+/diff --turn-based
+/diff --cached --turn-based
+/diff main...HEAD --turn-based -- @src/index.ts
+```
+
+Press `M` in a turn-based review to toggle the current hunk as reviewed. Later
+runs show the requested overall diff and render reviewed changed lines with a
+muted blue overlay.
+
 Open one or more files or folders with `/view`:
 
 ```text
@@ -79,6 +93,7 @@ Open one or more files or folders with `/view`:
 - `/diff --cached` reviews staged changes
 - `/diff main...HEAD` reviews changes on the current branch relative to `main`
 - `/diff <git-diff-args>` passes arguments through to `git diff`
+- `/diff --turn-based` enables experimental reviewed-turn overlays with `M`
 - `h` toggles the command help modal
 - `j/k` or arrow keys to move
 - `g/G` to jump to the top or bottom of the diff
@@ -88,6 +103,7 @@ Open one or more files or folders with `/view`:
 - `ctrl-u` / `ctrl-d` to move up/down by half a page
 - `s` toggles inline comments/explanations
 - `v` toggles the diff between unified and side-by-side split rendering
+- `w` toggles line wrap for long diff lines
 - `?` toggles an AI-generated explanation for the current hunk
 - `/` searches visible diff text, highlights matches, and `n/N` moves between them while a search is active
 - `J/K` to extend a highlighted selection into a comment range

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-diff-review",
-  "version": "0.1.24",
+  "version": "0.1.26",
   "description": "Local diff review TUI extension for pi",
   "license": "MIT",
   "type": "module",

package/src/diff/source.ts

@@ -12,23 +12,77 @@ export function parseDiffSource(args: string): DiffSource {
     };
   }
 
-  const gitArgs = tokenizeDiffArgs(trimmed);
+  const { gitArgs, turnBased } = parseDiffArgs(trimmed);
+  if (!turnBased) {
+    return {
+      label: `git diff ${trimmed}`,
+      promptLabel: `\`git diff ${trimmed}\``,
+      args: gitArgs,
+    };
+  }
+
+  const gitDiffLabel =
+    gitArgs.length > 0 ? `git diff ${gitArgs.join(" ")}` : "unstaged git diff";
+  const promptLabel =
+    gitArgs.length > 0
+      ? `\`git diff ${gitArgs.join(" ")}\``
+      : "the current unstaged git diff";
+
   return {
-    label: `git diff ${trimmed}`,
-    promptLabel: `\`git diff ${trimmed}\``,
+    label: `${gitDiffLabel} with turn-based review overlay`,
+    promptLabel,
     args: gitArgs,
+    turnBased: true,
   };
 }
 
-function tokenizeDiffArgs(input: string): string[] {
+function parseDiffArgs(input: string): {
+  gitArgs: string[];
+  turnBased: boolean;
+} {
   try {
-    return normalizeDiffPathspecs(tokenizeShellArgs(input));
+    const tokens = tokenizeShellArgs(input);
+    const { args, turnBased } = extractDiffReviewFlags(tokens);
+    return {
+      gitArgs: normalizeDiffPathspecs(args),
+      turnBased,
+    };
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
     throw new Error(message.replace(/in arguments$/, "in git diff args"));
   }
 }
 
+function extractDiffReviewFlags(tokens: string[]): {
+  args: string[];
+  turnBased: boolean;
+} {
+  const args: string[] = [];
+  let turnBased = false;
+  let passthrough = false;
+
+  for (let index = 0; index < tokens.length; index++) {
+    const token = tokens[index]!;
+    if (token === "--") {
+      passthrough = true;
+      args.push(token);
+      continue;
+    }
+
+    if (!passthrough && token === "--turn-based") {
+      if (turnBased) {
+        throw new Error("--turn-based can only be provided once");
+      }
+      turnBased = true;
+      continue;
+    }
+
+    args.push(token);
+  }
+
+  return { args, turnBased };
+}
+
 function normalizeDiffPathspecs(args: string[]): string[] {
   const separatorIndex = args.indexOf("--");
   if (separatorIndex < 0) return args;

package/src/diff/turn-based-overlay.ts

@@ -0,0 +1,93 @@
+import type { ReviewLine, ReviewSnapshotLine } from "../review/types.ts";
+
+export function applyReviewedOverlay(
+  targetLines: ReviewLine[],
+  reviewedLines: ReviewSnapshotLine[],
+): number {
+  const reviewedKeys = new Set(
+    reviewedLines.flatMap((line) => getChangedLineKeys(line)),
+  );
+  let marked = 0;
+
+  for (const line of targetLines) {
+    if (getChangedLineKeys(line).some((key) => reviewedKeys.has(key))) {
+      line.reviewedOverlay = true;
+      marked++;
+    }
+  }
+
+  return marked;
+}
+
+export function markChangedLinesReviewed(lines: ReviewLine[]): number {
+  let marked = 0;
+
+  for (const line of lines) {
+    if (getChangedLineKeys(line).length === 0) continue;
+    if (!line.reviewedOverlay) marked++;
+    line.reviewedOverlay = true;
+  }
+
+  return marked;
+}
+
+export function clearReviewedOverlay(lines: ReviewLine[]): number {
+  let cleared = 0;
+
+  for (const line of lines) {
+    if (!line.reviewedOverlay) continue;
+    line.reviewedOverlay = false;
+    cleared++;
+  }
+
+  return cleared;
+}
+
+export function areAllChangedLinesReviewed(lines: ReviewLine[]): boolean {
+  const changedLines = lines.filter(
+    (line) => getChangedLineKeys(line).length > 0,
+  );
+  return (
+    changedLines.length > 0 &&
+    changedLines.every((line) => line.reviewedOverlay)
+  );
+}
+
+export function getReviewedLines(lines: ReviewLine[]): ReviewLine[] {
+  return lines.filter(
+    (line) => line.reviewedOverlay && getChangedLineKeys(line).length > 0,
+  );
+}
+
+function getChangedLineKeys(line: ReviewLine | ReviewSnapshotLine): string[] {
+  if (!line.filePath) return [];
+  if (line.kind === "add" && line.newLineNumber != null) {
+    return [
+      [
+        line.filePath,
+        line.kind,
+        String(line.newLineNumber),
+        getComparableText(line),
+      ].join("\0"),
+    ];
+  }
+
+  if (line.kind === "remove" && line.oldLineNumber != null) {
+    return [
+      [
+        line.filePath,
+        line.kind,
+        String(line.oldLineNumber),
+        getComparableText(line),
+      ].join("\0"),
+    ];
+  }
+
+  return [];
+}
+
+function getComparableText(line: ReviewLine | ReviewSnapshotLine): string {
+  return line.kind === "add" || line.kind === "remove"
+    ? line.text.slice(1)
+    : line.text;
+}

package/src/index.ts

@@ -5,11 +5,14 @@ import type {
 } from "@earendil-works/pi-coding-agent";
 import { getDiff, parseDiffSource } from "./diff/source.ts";
 import { parseDiff } from "./diff/parser.ts";
+import { applyReviewedOverlay } from "./diff/turn-based-overlay.ts";
 import { PiModelDiffExplainer } from "./explanation/explainer.ts";
 import {
+  getLastReviewSnapshot,
   getCachedAsk,
   getCachedComments,
   getCachedExplanations,
+  persistLastReviewSnapshot,
   persistCachedAsk,
   persistCachedComments,
   persistCachedExplanations,
@@ -30,6 +33,10 @@ function getReviewCacheKey(cwd: string, label: string, text: string): string {
   return `${cwd}\0${label}\0${hash}`;
 }
 
+function getReviewScopeKey(cwd: string, args: string[]): string {
+  return `${cwd}\0diff\0${JSON.stringify(args)}`;
+}
+
 export function registerDiffReviewCommand(pi: ExtensionAPI): void {
   pi.registerCommand("diff", {
     description: "Review a git diff in a custom TUI (/diff [git diff args])",
@@ -51,11 +58,34 @@ export function registerDiffReviewCommand(pi: ExtensionAPI): void {
       }
 
       const reviewLines = parseDiff(diffText);
+      const turnBasedScopeKey = source.turnBased
+        ? getReviewScopeKey(ctx.cwd, source.args)
+        : undefined;
+      if (turnBasedScopeKey) {
+        const previousLines = getLastReviewSnapshot(ctx, turnBasedScopeKey);
+        if (previousLines) {
+          const marked = applyReviewedOverlay(reviewLines, previousLines);
+          ctx.ui.notify(
+            `Marked ${marked} reviewed line${marked === 1 ? "" : "s"}.`,
+            "info",
+          );
+        } else {
+          ctx.ui.notify(
+            "No reviewed baseline found. Press M to toggle the current hunk as reviewed.",
+            "info",
+          );
+        }
+      }
       await openReview(pi, ctx, {
         title: source.label,
         promptLabel: source.promptLabel,
         cacheKey: getReviewCacheKey(ctx.cwd, source.label, diffText),
         reviewLines,
+        markReviewed:
+          turnBasedScopeKey == null
+            ? undefined
+            : (reviewedLines) =>
+                persistLastReviewSnapshot(pi, turnBasedScopeKey, reviewedLines),
         buildPrompt: (comments) =>
           buildReviewPrompt(comments, source.promptLabel),
       });
@@ -113,6 +143,7 @@ async function openReview(
     cacheKey: string;
     reviewLines: ReviewLine[];
     buildPrompt: (comments: ReviewComment[]) => string;
+    markReviewed?: (reviewedLines: ReviewLine[]) => void;
     workspaceStore?: WorkspaceCommentStore;
   },
 ): Promise<void> {
@@ -202,6 +233,9 @@ async function openReview(
           persistCachedAsk(pi, options.cacheKey, updatedAsk);
         },
         () => summary(),
+        options.markReviewed
+          ? (reviewedLines) => options.markReviewed?.(reviewedLines)
+          : undefined,
       );
     },
   );

package/src/review/cache.ts

@@ -2,11 +2,17 @@ import type {
   ExtensionAPI,
   ExtensionCommandContext,
 } from "@earendil-works/pi-coding-agent";
-import type { PersistedAsk, ReviewComment } from "./types.ts";
+import type {
+  PersistedAsk,
+  ReviewComment,
+  ReviewLine,
+  ReviewSnapshotLine,
+} from "./types.ts";
 
 const REVIEW_COMMENT_CACHE_ENTRY = "pi-diff-review-cache";
 const REVIEW_EXPLANATION_CACHE_ENTRY = "pi-diff-review-explanation-cache";
 const REVIEW_ASK_CACHE_ENTRY = "pi-diff-review-ask-cache";
+const REVIEW_SNAPSHOT_CACHE_ENTRY = "pi-diff-review-snapshot-cache";
 
 type ReviewCommentCacheEntry = {
   cacheKey: string;
@@ -26,6 +32,12 @@ type ReviewAskCacheEntry = {
   updatedAt: number;
 };
 
+type ReviewSnapshotCacheEntry = {
+  scopeKey: string;
+  lines: ReviewSnapshotLine[];
+  updatedAt: number;
+};
+
 export function getCachedComments(
   ctx: ExtensionCommandContext,
   cacheKey: string,
@@ -169,3 +181,62 @@ export function persistCachedAsk(
     updatedAt: Date.now(),
   } satisfies ReviewAskCacheEntry);
 }
+
+export function getLastReviewSnapshot(
+  ctx: ExtensionCommandContext,
+  scopeKey: string,
+): ReviewSnapshotLine[] | undefined {
+  let latest: ReviewSnapshotCacheEntry | undefined;
+  for (const entry of ctx.sessionManager.getEntries()) {
+    if (
+      entry.type !== "custom" ||
+      entry.customType !== REVIEW_SNAPSHOT_CACHE_ENTRY
+    ) {
+      continue;
+    }
+
+    const data = entry.data as Partial<ReviewSnapshotCacheEntry> | undefined;
+    if (data?.scopeKey !== scopeKey || !Array.isArray(data.lines)) continue;
+
+    const lines = data.lines.filter(isReviewSnapshotLine);
+    if (!latest || (data.updatedAt ?? 0) >= latest.updatedAt) {
+      latest = {
+        scopeKey: data.scopeKey,
+        lines,
+        updatedAt: data.updatedAt ?? 0,
+      };
+    }
+  }
+
+  return latest?.lines;
+}
+
+export function persistLastReviewSnapshot(
+  pi: ExtensionAPI,
+  scopeKey: string,
+  lines: ReviewLine[] | ReviewSnapshotLine[],
+): void {
+  pi.appendEntry(REVIEW_SNAPSHOT_CACHE_ENTRY, {
+    scopeKey,
+    lines: lines.map((line) => ({
+      kind: line.kind,
+      text: line.text,
+      filePath: line.filePath,
+      oldLineNumber: line.oldLineNumber,
+      newLineNumber: line.newLineNumber,
+    })),
+    updatedAt: Date.now(),
+  } satisfies ReviewSnapshotCacheEntry);
+}
+
+function isReviewSnapshotLine(value: unknown): value is ReviewSnapshotLine {
+  if (!value || typeof value !== "object") return false;
+  const line = value as Partial<ReviewSnapshotLine>;
+  return (
+    typeof line.kind === "string" &&
+    typeof line.text === "string" &&
+    (line.filePath == null || typeof line.filePath === "string") &&
+    (line.oldLineNumber == null || typeof line.oldLineNumber === "number") &&
+    (line.newLineNumber == null || typeof line.newLineNumber === "number")
+  );
+}

package/src/review/component.ts

@@ -31,6 +31,12 @@ import { ReviewSearchState } from "./search.ts";
 import { buildReviewFileIndex, type ReviewFileSection } from "./files.ts";
 import { padToWidth, lineNumberCell } from "../render/utils.ts";
 import { buildSplitDiffRows } from "../diff/split.ts";
+import {
+  areAllChangedLinesReviewed,
+  clearReviewedOverlay,
+  getReviewedLines,
+  markChangedLinesReviewed,
+} from "../diff/turn-based-overlay.ts";
 import type {
   DiffRenderMode,
   PersistedAsk,
@@ -55,8 +61,8 @@ type InlineBoxRow = {
 
 type AnnotatedDiffRow =
   | { kind: "file-header"; file: ReviewFileSection }
-  | { kind: "diff"; lineIndex: number }
-  | { kind: "split"; splitRowIndex: number }
+  | { kind: "diff"; lineIndex: number; segmentIndex: number }
+  | { kind: "split"; splitRowIndex: number; segmentIndex: number }
   | InlineBoxRow;
 
 const HELP_COMMANDS = [
@@ -71,12 +77,14 @@ const HELP_COMMANDS = [
   ["/", "search diff lines"],
   ["n / N", "jump between search matches"],
   ["J / K", "extend highlighted selection"],
+  ["M", "toggle current hunk reviewed"],
   ["c", "add or edit a line or range comment"],
   ["C", "add or edit an overall diff comment"],
   ["x", "delete the current line or range comment"],
   ["t", "toggle the file sidebar"],
   ["s", "toggle inline comments and explanations"],
   ["v", "toggle unified or split rendering"],
+  ["w", "toggle line wrap for long diff lines"],
   ["?", "toggle AI explanation for current hunk"],
   ["a", "ask a question about the current hunk"],
   ["Enter", "submit comments, save edits, or jump to search result"],
@@ -114,6 +122,7 @@ export class ReviewComponent {
   private annotatedRowsEditMode = false;
   private annotatedRowsEditingCommentKey?: string;
   private annotatedRowsMode?: DiffRenderMode;
+  private annotatedRowsLineWrapEnabled = false;
   private annotatedRowsInlineAnnotationsVisible = true;
   private annotatedRowsVisibleExplanationCount = 0;
   private annotatedRowByLineIndex?: number[];
@@ -134,6 +143,7 @@ export class ReviewComponent {
     private getWorkspaceCommentSummary?: (
       comments: Map<string, ReviewComment>,
     ) => WorkspaceCommentSummary | undefined,
+    private onMarkReviewed?: (reviewedLines: ReviewLine[]) => void,
   ) {
     const firstCommentable = this.lines.findIndex((line) => line.commentable);
     this.navigation = new ReviewNavigationState(
@@ -258,6 +268,10 @@ export class ReviewComponent {
     return this.navigation.diffRenderMode;
   }
 
+  private get lineWrapEnabled(): boolean {
+    return this.navigation.lineWrapEnabled;
+  }
+
   handleInput(data: string): void {
     if (this.helpVisible) {
       if (data === "h" || matchesKey(data, "escape")) {
@@ -330,6 +344,10 @@ export class ReviewComponent {
       this.toggleDiffRenderMode();
       return;
     }
+    if (data === "w") {
+      this.toggleLineWrap();
+      return;
+    }
     if (data === "?") {
       this.toggleExplanationPane();
       return;
@@ -390,6 +408,10 @@ export class ReviewComponent {
       this.extendSelection(-1);
       return;
     }
+    if (data === "M") {
+      this.markCurrentDiffReviewed();
+      return;
+    }
     if (data === "n") {
       if (this.search.query) {
         this.jumpSearch(1);
@@ -478,7 +500,12 @@ export class ReviewComponent {
   ): string {
     const visibleLineCount = this.getVisibleLineIndexes().length;
     const summaryCount = this.explanationController.explanations.size;
-    const base = `${visibleLineCount}/${this.lines.length} lines • ${this.fileIndex.sections.length} files • ${this.comments.size} comments • ${summaryCount} summaries${this.formatWorkspaceSummary(workspaceSummary)}`;
+    const reviewedOverlayCount = this.lines.filter(
+      (line) => line.reviewedOverlay,
+    ).length;
+    const reviewedOverlayText =
+      reviewedOverlayCount > 0 ? ` • ${reviewedOverlayCount} reviewed` : "";
+    const base = `${visibleLineCount}/${this.lines.length} lines • ${this.fileIndex.sections.length} files • ${this.comments.size} comments • ${summaryCount} summaries${reviewedOverlayText}${this.formatWorkspaceSummary(workspaceSummary)}`;
 
     if (this.editMode) {
       return `${base} • editing ${this.editingCommentKey === GLOBAL_COMMENT_KEY ? "overall comment" : "inline comment"}`;
@@ -626,6 +653,7 @@ export class ReviewComponent {
           this.renderDiffLine(
             line,
             index,
+            annotated.segmentIndex,
             width,
             index === this.selected,
             this.getSelectionBounds(),
@@ -635,7 +663,13 @@ export class ReviewComponent {
       }
 
       if (annotated.kind === "split") {
-        output.push(this.renderSplitDiffRowAt(annotated.splitRowIndex, width));
+        output.push(
+          this.renderSplitDiffRowAt(
+            annotated.splitRowIndex,
+            annotated.segmentIndex,
+            width,
+          ),
+        );
         continue;
       }
 
@@ -653,6 +687,7 @@ export class ReviewComponent {
       this.annotatedRowsEditMode === this.editMode &&
       this.annotatedRowsEditingCommentKey === this.editingCommentKey &&
       this.annotatedRowsMode === this.diffRenderMode &&
+      this.annotatedRowsLineWrapEnabled === this.lineWrapEnabled &&
       this.annotatedRowsInlineAnnotationsVisible ===
         this.inlineAnnotationsVisible &&
       this.annotatedRowsVisibleExplanationCount ===
@@ -682,6 +717,7 @@ export class ReviewComponent {
     this.annotatedRowsEditMode = this.editMode;
     this.annotatedRowsEditingCommentKey = this.editingCommentKey;
     this.annotatedRowsMode = this.diffRenderMode;
+    this.annotatedRowsLineWrapEnabled = this.lineWrapEnabled;
     this.annotatedRowsInlineAnnotationsVisible = this.inlineAnnotationsVisible;
     this.annotatedRowsVisibleExplanationCount =
       this.visibleExplanationKeys.size;
@@ -702,7 +738,18 @@ export class ReviewComponent {
         index++
       ) {
         rowByLineIndex[index] = rows.length;
-        rows.push({ kind: "diff", lineIndex: index });
+        const segmentCount = this.getDiffRowSegmentCount(
+          this.lines[index]!,
+          index,
+          width,
+        );
+        for (
+          let segmentIndex = 0;
+          segmentIndex < segmentCount;
+          segmentIndex++
+        ) {
+          rows.push({ kind: "diff", lineIndex: index, segmentIndex });
+        }
 
         if (!this.inlineAnnotationsVisible) continue;
 
@@ -736,7 +783,14 @@ export class ReviewComponent {
           rowByLineIndex[lineIndex] = rows.length;
         }
 
-        rows.push({ kind: "split", splitRowIndex });
+        const segmentCount = this.getSplitRowSegmentCount(splitRow, width);
+        for (
+          let segmentIndex = 0;
+          segmentIndex < segmentCount;
+          segmentIndex++
+        ) {
+          rows.push({ kind: "split", splitRowIndex, segmentIndex });
+        }
         if (!this.inlineAnnotationsVisible) continue;
 
         for (const lineIndex of lineIndexes) {
@@ -1183,7 +1237,11 @@ export class ReviewComponent {
     );
   }
 
-  private renderSplitDiffRowAt(splitRowIndex: number, width: number): string {
+  private renderSplitDiffRowAt(
+    splitRowIndex: number,
+    segmentIndex: number,
+    width: number,
+  ): string {
     const splitRow = this.getSplitDiffRows()[splitRowIndex];
     if (!splitRow) return " ".repeat(width);
 
@@ -1191,6 +1249,7 @@ export class ReviewComponent {
       return this.renderDiffLine(
         splitRow.cell.line,
         splitRow.cell.index,
+        segmentIndex,
         width,
         splitRow.cell.index === this.selected,
         this.getSelectionBounds(),
@@ -1201,10 +1260,15 @@ export class ReviewComponent {
     const leftWidth = Math.max(10, Math.floor((width - separatorWidth) / 2));
     const rightWidth = Math.max(10, width - leftWidth - separatorWidth);
     const left = splitRow.left
-      ? this.renderSplitDiffCell(splitRow.left, leftWidth, "left")
+      ? this.renderSplitDiffCell(splitRow.left, leftWidth, "left", segmentIndex)
       : " ".repeat(leftWidth);
     const right = splitRow.right
-      ? this.renderSplitDiffCell(splitRow.right, rightWidth, "right")
+      ? this.renderSplitDiffCell(
+          splitRow.right,
+          rightWidth,
+          "right",
+          segmentIndex,
+        )
       : " ".repeat(rightWidth);
     return truncateToWidth(
       `${padToWidth(left, leftWidth)}${this.theme.fg("borderMuted", " │ ")}${padToWidth(right, rightWidth)}`,
@@ -1212,6 +1276,175 @@ export class ReviewComponent {
     );
   }
 
+  private getDiffRowSegmentCount(
+    line: ReviewLine,
+    index: number,
+    width: number,
+  ): number {
+    return this.getDiffRowSegments(line, index, width).length;
+  }
+
+  private getSplitRowSegmentCount(row: SplitDiffRow, width: number): number {
+    if (row.kind === "full") {
+      return this.getDiffRowSegmentCount(row.cell.line, row.cell.index, width);
+    }
+
+    const separatorWidth = 3;
+    const leftWidth = Math.max(10, Math.floor((width - separatorWidth) / 2));
+    const rightWidth = Math.max(10, width - leftWidth - separatorWidth);
+    return Math.max(
+      row.left
+        ? this.getSplitDiffCellSegments(row.left, leftWidth, "left").length
+        : 1,
+      row.right
+        ? this.getSplitDiffCellSegments(row.right, rightWidth, "right").length
+        : 1,
+    );
+  }
+
+  private getDiffRowSegments(
+    line: ReviewLine,
+    index: number,
+    width: number,
+  ): string[] {
+    const lineMark = this.getLineMark(line, index);
+    const numbers = `${lineNumberCell(line.oldLineNumber)} ${lineNumberCell(line.newLineNumber)}`;
+    const prefix = this.styleDiffPrefix(line, `${lineMark} ${numbers} `);
+    const continuationPrefix = this.styleDiffPrefix(
+      line,
+      `${lineMark} ${lineNumberCell()} ${lineNumberCell()} `,
+    );
+    return this.wrapDiffContentSegments(
+      this.getRenderedDiffContent(line, index),
+      prefix,
+      continuationPrefix,
+      width,
+    );
+  }
+
+  private getSplitDiffCellSegments(
+    cell: SplitDiffCell,
+    width: number,
+    side: "left" | "right",
+  ): string[] {
+    const { line, index } = cell;
+    const lineMark = this.getLineMark(line, index);
+    const lineNumber =
+      side === "left" ? line.oldLineNumber : line.newLineNumber;
+    const prefix = this.styleDiffPrefix(
+      line,
+      `${lineMark} ${lineNumberCell(lineNumber)} `,
+    );
+    const continuationPrefix = this.styleDiffPrefix(
+      line,
+      `${lineMark} ${lineNumberCell()} `,
+    );
+    return this.wrapDiffContentSegments(
+      this.getRenderedDiffContent(line, index),
+      prefix,
+      continuationPrefix,
+      width,
+    );
+  }
+
+  private getRenderedDiffContent(line: ReviewLine, index: number): string {
+    switch (line.kind) {
+      case "add":
+      case "remove":
+      case "context":
+        return this.getHighlightedDisplayText(line, index);
+      case "hunk":
+        return this.theme.fg("accent", this.getDisplayText(line));
+      default:
+        return this.theme.fg("muted", this.getDisplayText(line));
+    }
+  }
+
+  private styleDiffPrefix(line: ReviewLine, text: string): string {
+    switch (line.kind) {
+      case "add":
+        return this.theme.fg("toolDiffAdded", text);
+      case "remove":
+        return this.theme.fg("toolDiffRemoved", text);
+      case "context":
+        return this.theme.fg("toolDiffContext", text);
+      case "hunk":
+        return this.theme.fg("accent", text);
+      default:
+        return this.theme.fg("muted", text);
+    }
+  }
+
+  private getLineMark(line: ReviewLine, index: number): string {
+    const hasComment = this.getCommentKeysForLine(index).length > 0;
+    if (hasComment) return this.theme.fg("borderAccent", "│");
+    return " ";
+  }
+
+  private markCurrentDiffReviewed(): void {
+    if (!this.onMarkReviewed) return;
+    const range = this.getCurrentHunkRange();
+    if (!range) return;
+
+    const hunkLines = this.lines.slice(range.start, range.end + 1);
+    if (areAllChangedLinesReviewed(hunkLines)) {
+      clearReviewedOverlay(hunkLines);
+    } else {
+      markChangedLinesReviewed(hunkLines);
+    }
+
+    this.onMarkReviewed(getReviewedLines(this.lines));
+    this.invalidateAnnotatedRows();
+    this.tui.requestRender(true);
+  }
+
+  private getCurrentHunkRange(): SelectionBounds | undefined {
+    const selectedLine = this.lines[this.selected];
+    if (!selectedLine?.filePath || !selectedLine.hunkLabel) return undefined;
+
+    let start = this.selected;
+    while (
+      start > 0 &&
+      this.lines[start - 1]?.filePath === selectedLine.filePath &&
+      this.lines[start - 1]?.hunkLabel === selectedLine.hunkLabel
+    ) {
+      start--;
+    }
+
+    const end = this.getHunkEndIndex(this.selected);
+    return end == null ? undefined : { start, end };
+  }
+
+  private wrapDiffContentSegments(
+    content: string,
+    prefix: string,
+    continuationPrefix: string,
+    width: number,
+  ): string[] {
+    const firstLineWidth = Math.max(1, width - visibleWidth(prefix));
+    const continuationWidth = Math.max(
+      1,
+      width - visibleWidth(continuationPrefix),
+    );
+
+    if (!this.lineWrapEnabled) {
+      return [`${prefix}${truncateToWidth(content, firstLineWidth)}`];
+    }
+
+    const firstSegments = wrapTextWithAnsi(content, firstLineWidth);
+    if (firstSegments.length === 0) return [prefix];
+    if (firstSegments.length === 1) return [`${prefix}${firstSegments[0]}`];
+
+    const [firstSegment, ...remaining] = firstSegments;
+    const wrapped = [`${prefix}${firstSegment}`];
+    for (const segment of remaining) {
+      for (const continuation of wrapTextWithAnsi(segment, continuationWidth)) {
+        wrapped.push(`${continuationPrefix}${continuation}`);
+      }
+    }
+    return wrapped;
+  }
+
   private getContentHeight(): number {
     const terminalRows = this.tui.terminal?.rows ?? 24;
     const headerHeight = 3;
@@ -1326,6 +1559,12 @@ export class ReviewComponent {
     this.tui.requestRender(true);
   }
 
+  private toggleLineWrap(): void {
+    this.navigation.toggleLineWrap();
+    this.invalidateAnnotatedRows();
+    this.tui.requestRender(true);
+  }
+
   private toggleInlineAnnotations(): void {
     this.inlineAnnotationsVisible = !this.inlineAnnotationsVisible;
     this.invalidateAnnotatedRows();
@@ -1600,19 +1839,18 @@ export class ReviewComponent {
     cell: SplitDiffCell,
     width: number,
     side: "left" | "right",
+    segmentIndex: number,
   ): string {
     const { line, index } = cell;
-    const hasComment = this.getCommentKeysForLine(index).length > 0;
-    const commentMark = hasComment ? this.theme.fg("borderAccent", "│") : " ";
-    const lineNumber =
-      side === "left" ? line.oldLineNumber : line.newLineNumber;
-    const prefix = `${commentMark} ${lineNumberCell(lineNumber)} `;
-    let styled = this.renderDiffRowContent(line, prefix, index);
-
-    styled = truncateToWidth(styled, width);
+    const styled =
+      this.getSplitDiffCellSegments(cell, width, side)[segmentIndex] ??
+      " ".repeat(width);
     const selection = this.getSelectionBounds();
     const inSelection =
       selection != null && index >= selection.start && index <= selection.end;
+    if (line.reviewedOverlay) {
+      return this.applyReviewedBackground(styled, width);
+    }
     if (index === this.selected || inSelection) {
       return this.theme.bg("selectedBg", padToWidth(styled, width));
     }
@@ -1651,15 +1889,24 @@ export class ReviewComponent {
     styled: string,
     width: number,
   ): string {
+    if (line.reviewedOverlay) {
+      return this.applyReviewedBackground(styled, width);
+    }
+
+    const padded = padToWidth(styled, width);
     if (line.kind === "add") {
-      return this.theme.bg("toolSuccessBg", padToWidth(styled, width));
+      return this.theme.bg("toolSuccessBg", padded);
     }
     if (line.kind === "remove") {
-      return this.theme.bg("toolErrorBg", padToWidth(styled, width));
+      return this.theme.bg("toolErrorBg", padded);
     }
     return styled;
   }
 
+  private applyReviewedBackground(styled: string, width: number): string {
+    return `\x1b[48;2;38;68;92m${padToWidth(styled, width)}\x1b[49m`;
+  }
+
   private renderDiffRowContent(
     line: ReviewLine,
     prefix: string,
@@ -1734,19 +1981,19 @@ export class ReviewComponent {
   private renderDiffLine(
     line: ReviewLine,
     index: number,
+    segmentIndex: number,
     width: number,
     selected: boolean,
     selection?: SelectionBounds,
   ): string {
-    const hasComment = this.getCommentKeysForLine(index).length > 0;
-    const commentMark = hasComment ? this.theme.fg("borderAccent", "│") : " ";
-    const numbers = `${lineNumberCell(line.oldLineNumber)} ${lineNumberCell(line.newLineNumber)}`;
-    const prefix = `${commentMark} ${numbers} `;
-    let styled = this.renderDiffRowContent(line, prefix, index);
-
-    styled = truncateToWidth(styled, width);
+    const styled =
+      this.getDiffRowSegments(line, index, width)[segmentIndex] ??
+      " ".repeat(width);
     const inSelection =
       selection != null && index >= selection.start && index <= selection.end;
+    if (line.reviewedOverlay) {
+      return this.applyReviewedBackground(styled, width);
+    }
     if (selected || inSelection) {
       return this.theme.bg("selectedBg", padToWidth(styled, width));
     }

package/src/review/navigation.ts

@@ -10,6 +10,7 @@ export class ReviewNavigationState {
   scrollTop = 0;
   selectionAnchor?: number;
   diffRenderMode: DiffRenderMode = "unified";
+  lineWrapEnabled = false;
 
   constructor(
     private readonly lineCount: number,
@@ -84,6 +85,12 @@ export class ReviewNavigationState {
     return this.diffRenderMode;
   }
 
+  toggleLineWrap(): boolean {
+    this.lineWrapEnabled = !this.lineWrapEnabled;
+    this.scrollTop = 0;
+    return this.lineWrapEnabled;
+  }
+
   ensureScroll(
     viewportHeight: number,
     selectedDisplayRow: number,

package/src/review/types.ts

@@ -25,6 +25,7 @@ export type ReviewLine = {
   newLineNumber?: number;
   commentable: boolean;
   hunkLabel?: string;
+  reviewedOverlay?: boolean;
 };
 
 export type ReviewResult =
@@ -40,8 +41,14 @@ export type DiffSource = {
   label: string;
   promptLabel: string;
   args: string[];
+  turnBased?: boolean;
 };
 
+export type ReviewSnapshotLine = Pick<
+  ReviewLine,
+  "kind" | "text" | "filePath" | "oldLineNumber" | "newLineNumber"
+>;
+
 export type PersistedAsk = {
   scopeKey: string;
   anchorLineId: string;