@cueloop/client 0.1.0-alpha.66 → 0.1.0-alpha.67

package/src/diff-fold.test.ts

@@ -0,0 +1,78 @@
+/** Per-file collapse and full-file weave over the flat diff rows. */
+
+import { describe, expect, test } from "bun:test";
+import type { DiffRow } from "./view-diff";
+import { applyFold, weaveFullFileRows } from "./diff-fold";
+
+function row(kind: DiffRow["kind"], text: string, extra: Partial<DiffRow> = {}): DiffRow {
+  return { kind, text, file: "a.ts", ...extra };
+}
+
+// a two-line change in a four-line file: line 2 swapped, lines 1/3/4 unchanged
+const base: DiffRow[] = [
+  row("file", "a.ts"),
+  row("hunk", "@@ -1,3 +1,3 @@"),
+  row("ctx", "line one", { oldLine: 1, newLine: 1 }),
+  row("del", "old two", { oldLine: 2 }),
+  row("add", "new two", { newLine: 2 }),
+  row("ctx", "line three", { oldLine: 3, newLine: 3 }),
+];
+
+const contents = {
+  path: "a.ts",
+  oldContents: "line one\nold two\nline three\nline four\n",
+  newContents: "line one\nnew two\nline three\nline four\n",
+};
+
+describe("applyFold", () => {
+  test("with no fold state it returns the base rows unchanged", () => {
+    expect(applyFold(base, new Set(), new Set(), [contents])).toBe(base);
+  });
+
+  test("a collapsed file keeps only its file band", () => {
+    // Act
+    const folded = applyFold(base, new Set(["a.ts"]), new Set(), [contents]);
+
+    // Assert
+    expect(folded).toHaveLength(1);
+    expect(folded[0]).toEqual(row("file", "a.ts"));
+  });
+
+  test("an expanded file weaves the unchanged tail line the hunk never showed", () => {
+    // Act
+    const folded = applyFold(base, new Set(), new Set(["a.ts"]), [contents]);
+
+    // Assert - the hunk header is gone and "line four" (outside the hunk) now shows
+    expect(folded.some((r) => r.kind === "hunk")).toBe(false);
+    const four = folded.find((r) => r.text === "line four");
+
+    expect(four).toEqual(row("ctx", "line four", { oldLine: 4, newLine: 4 }));
+  });
+
+  test("expand is a no-op without the file's full contents", () => {
+    // Act - no contents entry, so the file keeps its hunks
+    const folded = applyFold(base, new Set(), new Set(["a.ts"]), undefined);
+
+    // Assert
+    expect(folded).toEqual(base);
+  });
+});
+
+describe("weaveFullFileRows", () => {
+  test("keeps the change rows and fills every unchanged line as context in order", () => {
+    // Arrange - the file's code rows (no headers)
+    const codeRows = base.slice(2);
+
+    // Act
+    const woven = weaveFullFileRows("a.ts", codeRows, contents.newContents);
+
+    // Assert - full file: ctx1, del, add, ctx3, ctx4
+    expect(woven.map((r) => `${r.kind}:${r.text}`)).toEqual([
+      "ctx:line one",
+      "del:old two",
+      "add:new two",
+      "ctx:line three",
+      "ctx:line four",
+    ]);
+  });
+});

package/src/diff-fold.ts

@@ -0,0 +1,126 @@
+/**
+ * Per-file fold state for the diff sheet, applied over the flat diff rows so the
+ * cursor, curation, and rendering all read one array. A collapsed file shows only
+ * its file band; an expanded file shows its whole contents with the diff woven in
+ * (unchanged lines become context rows), matching VSCode's "expand all lines".
+ */
+
+import type { DiffRow } from "./view-diff";
+
+/** The full old/new contents a diff carries per file (curatable diffs do). */
+export interface FileContents {
+  path: string;
+  newContents: string;
+  oldContents: string;
+}
+
+/** Split file contents into lines, dropping the single trailing newline the file carries. */
+function contentLines(contents: string): string[] {
+  if (contents === "") return [];
+
+  return contents.replace(/\n$/, "").split("\n");
+}
+
+/**
+ * Weave a file's hunk rows into its full contents: unchanged lines between and
+ * around the hunks become context rows, so the whole file renders with the diff
+ * inline. `codeRows` are the file's ctx/add/del rows in order (no headers).
+ */
+export function weaveFullFileRows(
+  fileName: string,
+  codeRows: DiffRow[],
+  newContents: string,
+): DiffRow[] {
+  const newLines = contentLines(newContents);
+  const woven: DiffRow[] = [];
+  // the next unchanged old/new line numbers to emit while filling gaps between hunks
+  let newCursor = 1;
+  let oldCursor = 1;
+  const fillTo = (newLine: number): void => {
+    while (newCursor < newLine) {
+      woven.push({
+        kind: "ctx",
+        text: newLines[newCursor - 1] ?? "",
+        file: fileName,
+        oldLine: oldCursor,
+        newLine: newCursor,
+      });
+      newCursor += 1;
+      oldCursor += 1;
+    }
+  };
+
+  for (const row of codeRows) {
+    if (row.newLine !== undefined) {
+      fillTo(row.newLine);
+      woven.push(row);
+      newCursor = row.newLine + 1;
+      if (row.kind === "ctx") oldCursor = (row.oldLine ?? oldCursor) + 1;
+    } else {
+      // a deletion consumes an old line only; it keeps its place before the additions
+      woven.push(row);
+      oldCursor = (row.oldLine ?? oldCursor) + 1;
+    }
+  }
+  // the unchanged tail after the last hunk
+  while (newCursor <= newLines.length) {
+    woven.push({
+      kind: "ctx",
+      text: newLines[newCursor - 1] ?? "",
+      file: fileName,
+      oldLine: oldCursor,
+      newLine: newCursor,
+    });
+    newCursor += 1;
+    oldCursor += 1;
+  }
+
+  return woven;
+}
+
+/**
+ * Rebuild the diff rows with per-file fold state. A collapsed file keeps only its
+ * file band; an expanded file with known contents shows its whole file woven; every
+ * other file keeps its hunks. Row order and the file bands themselves are preserved.
+ */
+export function applyFold(
+  base: DiffRow[],
+  collapsed: ReadonlySet<string>,
+  expanded: ReadonlySet<string>,
+  files: readonly FileContents[] | undefined,
+): DiffRow[] {
+  if (collapsed.size === 0 && expanded.size === 0) return base;
+  const contentsByPath = new Map((files ?? []).map((file) => [file.path, file]));
+  const out: DiffRow[] = [];
+  let index = 0;
+
+  while (index < base.length) {
+    const row = base[index]!;
+
+    if (row.kind !== "file") {
+      out.push(row);
+      index += 1;
+      continue;
+    }
+    out.push(row);
+    const file = row.file;
+    let end = index + 1;
+
+    while (end < base.length && base[end]!.kind !== "file") end += 1;
+    const body = base.slice(index + 1, end);
+    const contents = contentsByPath.get(file);
+
+    if (collapsed.has(file)) {
+      // only the file band; the body is hidden
+    } else if (expanded.has(file) && contents) {
+      const codeRows = body.filter((bodyRow) => bodyRow.kind !== "hunk");
+
+      out.push(...weaveFullFileRows(file, codeRows, contents.newContents));
+    } else {
+      out.push(...body);
+    }
+    index = end;
+  }
+
+  return out;
+}

package/src/diff-syntax.test.ts

@@ -41,6 +41,22 @@ describe("spansByLine", () => {
     expect(lineSpans[1]).toEqual([{ start: 0, end: 2, group: "comment" }]);
   });
 
+  test("a capture ending past the source clamps to its end instead of walking forever", () => {
+    // Arrange - offsets past the string, as byte offsets over a multi-byte line report
+    const source = "a│b\ncc";
+    const highlights: SimpleHighlight[] = [
+      [0, 9, "string"],
+      [12, 20, "comment"],
+    ];
+
+    // Act
+    const lineSpans = spansByLine(source, highlights);
+
+    // Assert - the covered text is colored to the end and the second capture paints nothing
+    expect(lineSpans[0]).toEqual([{ start: 0, end: 3, group: "string" }]);
+    expect(lineSpans[1]).toEqual([{ start: 0, end: 2, group: "string" }]);
+  });
+
   test("resolves overlapping captures with later winning", () => {
     // Arrange
     const source = "foo";

package/src/diff-syntax.ts

@@ -111,10 +111,13 @@ export function spansByLine(source: string, highlights: SimpleHighlight[]): Synt
     return Array.from({ length: Math.max(0, end - start) }, () => undefined);
   });
 
-  for (const [start, end, group] of highlights) {
+  for (const [start, rawEnd, group] of highlights) {
     // A capture can span newlines (block comments, template literals); color the
-    // covered columns on every line it crosses, not just the starting line.
-    let cursor = start;
+    // covered columns on every line it crosses, not just the starting line. Offsets
+    // past the source (byte offsets from a multi-byte line) clamp to its end, or the
+    // walk below would sit on the last line forever.
+    const end = Math.min(rawEnd, source.length);
+    let cursor = Math.max(0, start);
 
     while (cursor < end) {
       const line = lineOf(cursor);

package/src/discussions.ts

@@ -0,0 +1,79 @@
+/**
+ * Discussions: the conversations an annotated surface hosts inline. A root
+ * annotation, its replies, and the span they mark, grouped so two roots on the
+ * very same text read as one conversation. Pure over the resolved marks, so the
+ * plan thread view and the diff sheet group the same way.
+ */
+
+import type { Annotation, ReviewSession } from "@cueloop/schema";
+import type { Mark } from "./view-plan";
+import { comparePositions, type TextSpan } from "./thread-selection";
+
+/** One conversation: a root annotation, its replies, and the span they mark. */
+export interface Discussion {
+  key: string;
+  /** The annotation replies attach to. */
+  rootId: string;
+  /** The block the card renders under: where the span ends. */
+  blockIndex: number;
+  span: TextSpan;
+  annotations: Annotation[];
+}
+
+export function spanKey(span: TextSpan): string {
+  return `${span.start.blockIndex}:${span.start.char}:${span.end.blockIndex}:${span.end.char}`;
+}
+
+/**
+ * Roots group by the span they resolved to (two roots on the very same text
+ * read as one conversation); replies join the discussion their replyTo names, or
+ * stand as roots when that root is gone.
+ */
+export function discussionsFrom(session: ReviewSession, marks: Map<number, Mark[]>): Discussion[] {
+  const byId = new Map(session.annotations.map((annotation) => [annotation.id, annotation]));
+  const spanOf = new Map<string, TextSpan>();
+
+  for (const [displayIndex, blockMarks] of marks) {
+    for (const mark of blockMarks) {
+      if (!mark.annotationId || spanOf.has(mark.annotationId)) continue;
+      spanOf.set(
+        mark.annotationId,
+        mark.span ?? {
+          start: { blockIndex: displayIndex, char: mark.start },
+          end: { blockIndex: displayIndex, char: mark.end },
+        },
+      );
+    }
+  }
+  const resolved = [...spanOf.keys()].map((id) => byId.get(id)!).filter(Boolean);
+  const isRoot = (annotation: Annotation): boolean =>
+    annotation.replyTo === undefined || !spanOf.has(annotation.replyTo);
+  const grouped = new Map<string, Discussion>();
+  const discussionOfRoot = new Map<string, Discussion>();
+
+  for (const annotation of resolved.filter(isRoot)) {
+    const span = spanOf.get(annotation.id)!;
+    const key = spanKey(span);
+    const discussion = grouped.get(key) ?? {
+      key,
+      rootId: annotation.id,
+      blockIndex: span.end.blockIndex,
+      span,
+      annotations: [],
+    };
+
+    discussion.annotations.push(annotation);
+    grouped.set(key, discussion);
+    discussionOfRoot.set(annotation.id, discussion);
+  }
+  for (const annotation of resolved.filter((candidate) => !isRoot(candidate))) {
+    discussionOfRoot.get(annotation.replyTo!)?.annotations.push(annotation);
+  }
+  for (const discussion of grouped.values()) {
+    discussion.annotations.sort((left, right) => left.createdAt.localeCompare(right.createdAt));
+  }
+
+  return [...grouped.values()].toSorted((left, right) =>
+    comparePositions(left.span.start, right.span.start),
+  );
+}

package/src/intent-dispatch.test.ts

@@ -71,10 +71,23 @@ function baseController(): ReviewController {
     dismissToast: mock(),
     display: mock(() => []),
     rows: mock(() => []),
+    setFileCollapsed: mock(),
+    isFileCollapsed: mock(() => false),
+    setFileExpanded: mock(),
+    isFileExpanded: mock(() => false),
+    canExpandFile: mock(() => false),
+    copyFilePath: mock(),
+    fileStats: mock(() => new Map()),
     files: mock(() => []),
     working: mock(() => ""),
+    projectFiles: mock(() => Promise.resolve<string[]>([])),
+    readFile: mock(() => Promise.resolve<string | null>(null)),
+    repoFiles: mock(() => Promise.resolve<string[]>([])),
+    repoReadFile: mock(() => Promise.resolve<string | null>(null)),
+    repoChanges: mock(() => Promise.resolve([])),
     open: mock(),
     deleteSession: mock(),
+    renameSession: mock(),
     setSelfName: mock(),
     cut: mock(),
     toggleRejectHunk: mock(),
@@ -106,7 +119,6 @@ function baseController(): ReviewController {
     finishReview: mock(),
     dismissCompletion: mock(),
     optInAutoClose: mock(),
-    saveReviewPanel: mock(),
   };
 }
 
@@ -123,9 +135,6 @@ function makeDeps(overrides: Partial<IntentDispatchDeps> = {}): IntentDispatchDe
     inboxCursor: 0,
     mode: { type: "normal" },
     session: null,
-    reviewMode: "expanded",
-    reviewWidth: 34,
-    terminalWidth: 120,
     focusedAnnotationId: undefined,
     selectedCurationId: undefined,
     railTab: "review",
@@ -133,13 +142,11 @@ function makeDeps(overrides: Partial<IntentDispatchDeps> = {}): IntentDispatchDe
     authorNames: {},
     quickActions: [],
     renameAuthor: mock(),
+    renameThread: mock(),
     liveInput: { current: "" },
-    reviewWidthRef: { current: 34 },
     setCursor: mock(),
     setInboxCursor: mock(),
     setMode: mock(),
-    setReviewMode: mock(),
-    setReviewWidth: mock(),
     setRailTab: mock(),
     setSelectedEntryId: mock(),
     setFocusedAnnotationId: mock(),
@@ -148,6 +155,7 @@ function makeDeps(overrides: Partial<IntentDispatchDeps> = {}): IntentDispatchDe
     selectCardFromDocument: mock(),
     runEditorHandOff: mock(),
     openCardEdit: mock(),
+    toggleDiffView: mock(),
     ...overrides,
   };
 }
@@ -349,17 +357,15 @@ describe("marker-actions popover", () => {
 });
 
 describe("openSubmit", () => {
-  test("force-opens the review rail so the confirm card can never be hidden", () => {
+  test("opens the submit confirm with the default verdict", () => {
     // Arrange
-    const deps = makeDeps({ session: sessionWith([]), reviewMode: "hidden" });
+    const deps = makeDeps({ session: sessionWith([]) });
     const dispatch = createIntentDispatch(deps);
 
     // Act
     dispatch({ type: "openSubmit" });
 
     // Assert
-    expect(deps.setReviewMode).toHaveBeenCalledWith("expanded");
-    expect(deps.setRailTab).toHaveBeenCalledWith("review");
     expect(deps.setMode).toHaveBeenCalledWith({ type: "submit", verdict: "approve", summary: "" });
   });
 
@@ -436,6 +442,20 @@ describe("restoreCuration", () => {
   });
 });
 
+describe("toggleDiffView", () => {
+  test("delegates to the App-owned toggle", () => {
+    // Arrange
+    const deps = makeDeps();
+    const dispatch = createIntentDispatch(deps);
+
+    // Act
+    dispatch({ type: "toggleDiffView" });
+
+    // Assert
+    expect(deps.toggleDiffView).toHaveBeenCalled();
+  });
+});
+
 describe("exit", () => {
   test("calls the exit hook with 0", () => {
     // Arrange

package/src/intent-dispatch.ts

@@ -14,15 +14,11 @@ import type { DiffRow } from "./view-diff";
 import type { ReviewController } from "./session-controller";
 import type { Intent } from "./keymap";
 import type { TreeRow } from "./tree-view";
-import type { RailTab } from "./components/ReviewRail";
 import { quickActionBody, type QuickAction } from "./config";
 import { VERDICTS } from "./components/ConfirmCard";
-import {
-  REVIEW_RESIZE_STEP,
-  cycleReviewPanelMode,
-  resolveReviewWidth,
-  type ReviewPanelMode,
-} from "./review-panel";
+
+/** Which pane of the session tree / review the keyboard grammar is aimed at. */
+export type RailTab = "review" | "agent" | "tree";
 
 /** The one overlay/mode the TUI is in; every compose/submit/edit flow is a variant. */
 export type Mode =
@@ -41,6 +37,7 @@ export type Mode =
   | { type: "submit"; verdict: VerdictKind; summary: string }
   | { type: "confirmDelete"; sessionId: string; title: string }
   | { type: "rename"; authorId: string; text: string }
+  | { type: "renameThread"; sessionId: string; text: string }
   | { type: "nameSelf"; text: string }
   | { type: "treePrompt"; ask: TreeAsk; entryId?: string; text: string };
 
@@ -87,14 +84,11 @@ export interface IntentDispatchDeps {
   inboxCursor: number;
   mode: Mode;
   session: ReviewSession | null;
-  reviewMode: ReviewPanelMode;
-  reviewWidth: number;
-  terminalWidth: number;
   focusedAnnotationId: string | undefined;
-  /** The curation item selected in the rail, if any; the undo target when set. */
+  /** The curation item selected for undo, if any. */
   selectedCurationId: string | undefined;
   railTab: RailTab;
-  /** The tree row selected in the rail's Tree tab; the target of go. */
+  /** The tree row selected in the session tree; the target of go. */
   selectedEntryId: string | undefined;
   /** Planner-local author renames, for seeding the rename prompt. */
   authorNames: Record<string, string>;
@@ -102,15 +96,14 @@ export interface IntentDispatchDeps {
   quickActions: QuickAction[];
   /** Persist an author rename and update the live overrides (App-owned). */
   renameAuthor: (id: string, name: string) => void;
+  /** Rename a thread's title through the daemon. */
+  renameThread: (id: string, title: string) => void;
 
   liveInput: MutableRefObject<string>;
-  reviewWidthRef: MutableRefObject<number>;
 
   setCursor: Dispatch<SetStateAction<number>>;
   setInboxCursor: Dispatch<SetStateAction<number>>;
   setMode: Dispatch<SetStateAction<Mode>>;
-  setReviewMode: Dispatch<SetStateAction<ReviewPanelMode>>;
-  setReviewWidth: Dispatch<SetStateAction<number>>;
   setRailTab: Dispatch<SetStateAction<RailTab>>;
   setSelectedEntryId: Dispatch<SetStateAction<string | undefined>>;
   setFocusedAnnotationId: Dispatch<SetStateAction<string | undefined>>;
@@ -120,6 +113,8 @@ export interface IntentDispatchDeps {
   selectCardFromDocument: (annotationId: string) => void;
   runEditorHandOff: () => void;
   openCardEdit: (annotationId: string) => void;
+  /** Flip unified/split diff and persist it (App-owned); split lays out only when zoomed. */
+  toggleDiffView: () => void;
 }
 
 type IntentOfType<Kind extends Intent["type"]> = Extract<Intent, { type: Kind }>;
@@ -132,8 +127,55 @@ function handleStatus(intent: IntentOfType<"status">, deps: IntentDispatchDeps):
   deps.controller.setStatus(intent.message);
 }
 
+/** A diff cursor rests on code lines only; file and hunk headers are structural dividers. */
+function isCodeRow(row: DiffRow | undefined): boolean {
+  return row?.kind === "ctx" || row?.kind === "add" || row?.kind === "del";
+}
+
+/**
+ * A landable diff row: any code line, plus a collapsed file's band (a file row with
+ * no body before the next file or the end) so the cursor can reach it to expand it.
+ */
+function isLandableRow(rows: DiffRow[], index: number): boolean {
+  const row = rows[index];
+
+  if (isCodeRow(row)) return true;
+  if (row?.kind !== "file") return false;
+  const next = rows[index + 1];
+
+  return next === undefined || next.kind === "file";
+}
+
+/** The next landable index in the move direction, skipping expanded headers; stays put at an edge. */
+function nextCodeRowIndex(rows: DiffRow[], from: number, to: IntentOfType<"move">["to"]): number {
+  if (to === "top") {
+    for (let index = 0; index < rows.length; index++) if (isLandableRow(rows, index)) return index;
+
+    return from;
+  }
+  if (to === "bottom") {
+    for (let index = rows.length - 1; index >= 0; index--) {
+      if (isLandableRow(rows, index)) return index;
+    }
+
+    return from;
+  }
+  const step = to === "down" ? 1 : -1;
+
+  for (let index = from + step; index >= 0 && index < rows.length; index += step) {
+    if (isLandableRow(rows, index)) return index;
+  }
+
+  return from;
+}
+
 function handleMove(intent: IntentOfType<"move">, deps: IntentDispatchDeps): void {
-  const navigableCount = deps.isDiff ? deps.rows.length : deps.display.length;
+  if (deps.isDiff) {
+    deps.setCursor((current) => nextCodeRowIndex(deps.rows, current, intent.to));
+
+    return;
+  }
+  const navigableCount = deps.display.length;
 
   if (intent.to === "down") deps.setCursor((current) => Math.min(navigableCount - 1, current + 1));
   else if (intent.to === "up") deps.setCursor((current) => Math.max(0, current - 1));
@@ -194,6 +236,7 @@ function handleConfirmDialog(
 
   if (mode.type === "confirmDelete") controller.deleteSession(mode.sessionId);
   else if (mode.type === "rename") deps.renameAuthor(mode.authorId, mode.text.trim());
+  else if (mode.type === "renameThread") deps.renameThread(mode.sessionId, mode.text.trim());
   else if (mode.type === "nameSelf") controller.setSelfName(mode.text.trim());
   else if (mode.type === "treePrompt") confirmTreePrompt(mode, deps);
   deps.setMode({ type: "normal" });
@@ -335,11 +378,6 @@ function handleOpenSubmit(_intent: IntentOfType<"openSubmit">, deps: IntentDispa
 
   if (!session) return;
   deps.liveInput.current = "";
-  // the confirm card lives in the expanded review rail; a compact or hidden
-  // panel would swallow the whole submit flow, so force the rail open (live
-  // only - the saved panel preference is left untouched)
-  deps.setReviewMode("expanded");
-  deps.setRailTab("review");
   deps.setMode({ type: "submit", verdict: defaultVerdict(session), summary: "" });
 }
 
@@ -359,6 +397,37 @@ function handleRejectChange(_intent: IntentOfType<"rejectChange">, deps: IntentD
   deps.controller.toggleRejectChange(deps.cursor);
 }
 
+function handleFoldFile(_intent: IntentOfType<"foldFile">, deps: IntentDispatchDeps): void {
+  const file = deps.rows[deps.cursor]?.file;
+
+  if (!file || deps.controller.isFileCollapsed(file)) return;
+  deps.controller.setFileCollapsed(file, true);
+  // the file band is unchanged in index by its own collapse, so land the cursor on it
+  const headerIndex = deps.controller
+    .rows()
+    .findIndex((row) => row.kind === "file" && row.file === file);
+
+  if (headerIndex >= 0) deps.setCursor(headerIndex);
+}
+
+function handleUnfoldFile(_intent: IntentOfType<"unfoldFile">, deps: IntentDispatchDeps): void {
+  const file = deps.rows[deps.cursor]?.file;
+
+  if (!file || !deps.controller.isFileCollapsed(file)) return;
+  deps.controller.setFileCollapsed(file, false);
+  // drop the cursor onto the file's first code line now that its body is back
+  const firstCode = deps.controller.rows().findIndex((row) => row.file === file && isCodeRow(row));
+
+  if (firstCode >= 0) deps.setCursor(firstCode);
+}
+
+function handleToggleDiffView(
+  _intent: IntentOfType<"toggleDiffView">,
+  deps: IntentDispatchDeps,
+): void {
+  deps.toggleDiffView();
+}
+
 function handleRestoreCuration(
   _intent: IntentOfType<"restoreCuration">,
   deps: IntentDispatchDeps,
@@ -502,31 +571,6 @@ function handleDismissCompletion(
   deps.controller.dismissCompletion();
 }
 
-function handleCycleReviewPanel(
-  _intent: IntentOfType<"cycleReviewPanel">,
-  deps: IntentDispatchDeps,
-): void {
-  const next = cycleReviewPanelMode(deps.reviewMode);
-
-  deps.setReviewMode(next);
-  deps.controller.saveReviewPanel({ mode: next });
-}
-
-function handleResizeReviewPanel(
-  intent: IntentOfType<"resizeReviewPanel">,
-  deps: IntentDispatchDeps,
-): void {
-  if (deps.reviewMode !== "expanded") return;
-  const next = resolveReviewWidth(
-    deps.reviewWidth + intent.direction * REVIEW_RESIZE_STEP,
-    deps.terminalWidth,
-  );
-
-  deps.reviewWidthRef.current = next;
-  deps.setReviewWidth(next);
-  deps.controller.saveReviewPanel({ width: next });
-}
-
 function confirmTreePrompt(
   mode: Extract<Mode, { type: "treePrompt" }>,
   deps: IntentDispatchDeps,
@@ -613,6 +657,9 @@ const intentHandlers: IntentHandlers = {
   cut: handleCut,
   rejectHunk: handleRejectHunk,
   rejectChange: handleRejectChange,
+  foldFile: handleFoldFile,
+  unfoldFile: handleUnfoldFile,
+  toggleDiffView: handleToggleDiffView,
   restoreCuration: handleRestoreCuration,
   edit: handleEdit,
   editCard: handleEditCard,
@@ -631,8 +678,6 @@ const intentHandlers: IntentHandlers = {
   finishReview: handleFinishReview,
   optInAutoClose: handleOptInAutoClose,
   dismissCompletion: handleDismissCompletion,
-  cycleReviewPanel: handleCycleReviewPanel,
-  resizeReviewPanel: handleResizeReviewPanel,
   toggleTree: handleToggleTree,
   treeMove: handleTreeMove,
   treeGo: handleTreeGo,

package/src/key-bindings.test.ts

@@ -23,7 +23,7 @@ describe("grammar-layer resolution", () => {
     ["g", true, "bottom"],
     ["v", false, "span"],
     ["c", false, "comment"],
-    ["s", false, undefined],
+    ["s", false, "split_diff"],
     ["x", false, "cut"],
     ["e", false, "edit"],
     ["n", false, "next_annotation"],