pi-diff-review 0.1.25 → 0.1.27

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-diff-review",
-  "version": "0.1.25",
+  "version": "0.1.27",
   "description": "Local diff review TUI extension for pi",
   "license": "MIT",
   "type": "module",
@@ -34,13 +34,13 @@
     "typecheck": "tsc --noEmit"
   },
   "devDependencies": {
-    "@earendil-works/pi-ai": "^0.74.0",
-    "@earendil-works/pi-coding-agent": "^0.74.1",
-    "@earendil-works/pi-tui": "^0.74.1",
-    "@types/node": "^24.12.4",
-    "prettier": "^3.5.3",
-    "tsx": "^4.22.1",
-    "typescript": "^6.0.3"
+    "@earendil-works/pi-ai": "^0.85.1",
+    "@earendil-works/pi-coding-agent": "^0.85.1",
+    "@earendil-works/pi-tui": "^0.85.1",
+    "@types/node": "^26.5.1",
+    "prettier": "^3.9.6",
+    "tsx": "^4.23.13",
+    "typescript": "^7.0.2"
   },
   "peerDependencies": {
     "@earendil-works/pi-ai": "*",
@@ -65,6 +65,6 @@
     "image": "https://github.com/user-attachments/assets/3fd00163-5d19-489b-94ed-3d4816c6cad3"
   },
   "dependencies": {
-    "@pierre/diffs": "^1.1.21"
+    "@pierre/diffs": "^1.4.2"
   }
 }

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/explanation/explainer.ts

@@ -1,4 +1,3 @@
-import { streamSimple } from "@earendil-works/pi-ai";
 import type { ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
 import type { AssistantMessage, Context } from "@earendil-works/pi-ai";
 
@@ -90,6 +89,11 @@ export class PiModelDiffExplainer implements DiffExplainer {
       throw new Error(auth.error);
     }
 
+    const provider = this.ctx.modelRegistry.getProvider(model.provider);
+    if (!provider) {
+      throw new Error(`No provider is registered for ${model.provider}.`);
+    }
+
     const context: Context = {
       systemPrompt:
         "You explain code clearly and concisely for review. Focus on intent, behavior, and risk. Avoid restating every line.",
@@ -105,7 +109,7 @@ export class PiModelDiffExplainer implements DiffExplainer {
     };
 
     let streamedText = "";
-    const stream = streamSimple(model, context, {
+    const stream = provider.streamSimple(model, context, {
       apiKey: auth.apiKey,
       headers: auth.headers,
       signal: options.signal,

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,
@@ -71,6 +77,7 @@ 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"],
@@ -136,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(
@@ -400,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);
@@ -488,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"}`;
@@ -1290,13 +1307,12 @@ export class ReviewComponent {
     index: number,
     width: number,
   ): string[] {
-    const hasComment = this.getCommentKeysForLine(index).length > 0;
-    const commentMark = hasComment ? this.theme.fg("borderAccent", "│") : " ";
+    const lineMark = this.getLineMark(line, index);
     const numbers = `${lineNumberCell(line.oldLineNumber)} ${lineNumberCell(line.newLineNumber)}`;
-    const prefix = this.styleDiffPrefix(line, `${commentMark} ${numbers} `);
+    const prefix = this.styleDiffPrefix(line, `${lineMark} ${numbers} `);
     const continuationPrefix = this.styleDiffPrefix(
       line,
-      `${commentMark} ${lineNumberCell()} ${lineNumberCell()} `,
+      `${lineMark} ${lineNumberCell()} ${lineNumberCell()} `,
     );
     return this.wrapDiffContentSegments(
       this.getRenderedDiffContent(line, index),
@@ -1312,17 +1328,16 @@ export class ReviewComponent {
     side: "left" | "right",
   ): string[] {
     const { line, index } = cell;
-    const hasComment = this.getCommentKeysForLine(index).length > 0;
-    const commentMark = hasComment ? this.theme.fg("borderAccent", "│") : " ";
+    const lineMark = this.getLineMark(line, index);
     const lineNumber =
       side === "left" ? line.oldLineNumber : line.newLineNumber;
     const prefix = this.styleDiffPrefix(
       line,
-      `${commentMark} ${lineNumberCell(lineNumber)} `,
+      `${lineMark} ${lineNumberCell(lineNumber)} `,
     );
     const continuationPrefix = this.styleDiffPrefix(
       line,
-      `${commentMark} ${lineNumberCell()} `,
+      `${lineMark} ${lineNumberCell()} `,
     );
     return this.wrapDiffContentSegments(
       this.getRenderedDiffContent(line, index),
@@ -1360,6 +1375,46 @@ export class ReviewComponent {
     }
   }
 
+  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,
@@ -1793,6 +1848,9 @@ export class ReviewComponent {
     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));
     }
@@ -1831,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,
@@ -1924,6 +1991,9 @@ export class ReviewComponent {
       " ".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/types.ts

@@ -25,11 +25,11 @@ export type ReviewLine = {
   newLineNumber?: number;
   commentable: boolean;
   hunkLabel?: string;
+  reviewedOverlay?: boolean;
 };
 
 export type ReviewResult =
-  | { action: "submit"; comments: ReviewComment[] }
-  | { action: "cancel" };
+  { action: "submit"; comments: ReviewComment[] } | { action: "cancel" };
 
 export type SelectionBounds = {
   start: number;
@@ -40,8 +40,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;