@cueloop/client 0.1.0-alpha.33 → 0.1.0-alpha.35

package/src/index.ts

@@ -1,4 +1,12 @@
 export { runClient, type RunClientOptions } from "./run";
 export { serveClient, type ServeHandle, type ServeOptions } from "./serve";
 export { App, type AppProps } from "./App";
-export { collaboratorAnnotations, publishShare, pullShare, pushShare, shareIdFromLine, type ShareResult, type ShareTarget } from "./share";
+export {
+  collaboratorAnnotations,
+  publishShare,
+  pullShare,
+  pushShare,
+  shareIdFromLine,
+  type ShareResult,
+  type ShareTarget,
+} from "./share";

package/src/integrations.ts

@@ -18,7 +18,9 @@ export interface BundledExporter {
 }
 
 /** Load the bundled integrations from config as generic exporters. */
-export async function loadBundledExporters(integrations: IntegrationsConfig): Promise<BundledExporter[]> {
+export async function loadBundledExporters(
+  integrations: IntegrationsConfig,
+): Promise<BundledExporter[]> {
   const registry = new Registry();
   const obsidian = integrations.obsidian;
   const record = await registry.load("obsidian", createObsidianExtension(obsidian));

package/src/intent-dispatch.test.ts

@@ -21,14 +21,16 @@ function sessionWith(annotationIds: string[]): ReviewSession {
   } as unknown as ReviewSession;
 }
 
-/** A deps bag where every effect is a mock and every read has a plain default. */
-function makeDeps(overrides: Partial<IntentDispatchDeps> = {}): IntentDispatchDeps {
-  const controller = {
+/** A controller where every verb is a mock; annotate returns undefined by default. */
+function baseController() {
+  return {
     setStatus: mock(),
     open: mock(),
     deleteSession: mock(),
     setSelfName: mock(),
     cut: mock(),
+    curationItems: mock(() => []),
+    restoreCuration: mock(),
     annotate: mock(),
     updateAnnotation: mock(),
     removeAnnotation: mock(),
@@ -43,6 +45,11 @@ function makeDeps(overrides: Partial<IntentDispatchDeps> = {}): IntentDispatchDe
     dismissCompletion: mock(),
     saveReviewPanel: mock(),
   };
+}
+
+/** A deps bag where every effect is a mock and every read has a plain default. */
+function makeDeps(overrides: Partial<IntentDispatchDeps> = {}): IntentDispatchDeps {
+  const controller = baseController();
   return {
     controller: controller as unknown as IntentDispatchDeps["controller"],
     onExit: mock(),
@@ -58,7 +65,9 @@ function makeDeps(overrides: Partial<IntentDispatchDeps> = {}): IntentDispatchDe
     reviewWidth: 34,
     terminalWidth: 120,
     focusedAnnotationId: undefined,
+    selectedCurationId: undefined,
     authorNames: {},
+    quickActions: [],
     renameAuthor: mock(),
     liveInput: { current: "" },
     reviewWidthRef: { current: 34 },
@@ -70,6 +79,7 @@ function makeDeps(overrides: Partial<IntentDispatchDeps> = {}): IntentDispatchDe
     setReviewWidth: mock(),
     setRailTab: mock(),
     setFocusedAnnotationId: mock(),
+    setSelectedCurationId: mock(),
     setPulsedAnnotationId: mock(),
     selectCardFromDocument: mock(),
     runEditorHandOff: mock(),
@@ -88,7 +98,9 @@ describe("move", () => {
     dispatch({ type: "move", to: "down" });
 
     // Assert
-    const advance = (deps.setCursor as ReturnType<typeof mock>).mock.calls[0]![0] as (current: number) => number;
+    const advance = (deps.setCursor as ReturnType<typeof mock>).mock.calls[0]![0] as (
+      current: number,
+    ) => number;
     expect(advance(2)).toBe(2); // already at the end, stays
     expect(advance(0)).toBe(1);
   });
@@ -134,7 +146,10 @@ describe("annotation navigation", () => {
   test("cycling skips annotations a revision already addressed", () => {
     // Arrange: a2 is addressed, so next from a1 lands on a3
     const session = sessionWith(["a1", "a2", "a3"]);
-    (session.annotations[1] as { resolution?: object }).resolution = { revision: 2, source: "agent" };
+    (session.annotations[1] as { resolution?: object }).resolution = {
+      revision: 2,
+      source: "agent",
+    };
     const deps = makeDeps({ session, focusedAnnotationId: "a1" });
     const dispatch = createIntentDispatch(deps);
 
@@ -156,7 +171,105 @@ describe("cycleVerdict", () => {
     dispatch({ type: "cycleVerdict", direction: 1 });
 
     // Assert
-    expect(deps.setMode).toHaveBeenCalledWith({ type: "submit", verdict: "request_changes", summary: "" });
+    expect(deps.setMode).toHaveBeenCalledWith({
+      type: "submit",
+      verdict: "request_changes",
+      summary: "",
+    });
+  });
+});
+
+describe("marker-actions popover", () => {
+  const span = { displayIndex: 3, wordIndex: 0, wordEnd: 0, start: 2, end: 9 };
+
+  test("spanCut cuts the span's block and closes the popover", () => {
+    // Arrange
+    const deps = makeDeps({ mode: { type: "span", span } });
+    const dispatch = createIntentDispatch(deps);
+
+    // Act
+    dispatch({ type: "spanCut" });
+
+    // Assert
+    expect(deps.controller.cut).toHaveBeenCalledWith(3);
+    expect(deps.setMode).toHaveBeenCalledWith({ type: "normal" });
+  });
+
+  test("openSpanActions enters the list at index 0", () => {
+    // Arrange
+    const deps = makeDeps({ mode: { type: "span", span } });
+    const dispatch = createIntentDispatch(deps);
+
+    // Act
+    dispatch({ type: "openSpanActions" });
+
+    // Assert
+    expect(deps.setMode).toHaveBeenCalledWith({ type: "spanActions", span, index: 0 });
+  });
+
+  test("moveSpanAction clamps within the actions list", () => {
+    // Arrange
+    const deps = makeDeps({
+      mode: { type: "spanActions", span, index: 1 },
+      quickActions: [{ prompt: "one" }, { prompt: "two" }],
+    });
+    const dispatch = createIntentDispatch(deps);
+
+    // Act
+    dispatch({ type: "moveSpanAction", direction: 1 });
+
+    // Assert - already at the last row, so the index holds
+    expect(deps.setMode).toHaveBeenCalledWith({ type: "spanActions", span, index: 1 });
+  });
+
+  test("pickSpanAction inserts the preset comment and returns to normal", () => {
+    // Arrange
+    const annotate = mock(() => "an_new");
+    const deps = makeDeps({
+      mode: { type: "spanActions", span, index: 1 },
+      session: sessionWith([]),
+      quickActions: [{ prompt: "Needs a test" }, { prompt: "YAGNI", metadata: "cut scope" }],
+      controller: { ...baseController(), annotate } as unknown as IntentDispatchDeps["controller"],
+    });
+    const dispatch = createIntentDispatch(deps);
+
+    // Act
+    dispatch({ type: "pickSpanAction" });
+
+    // Assert - metadata joins the prompt with a blank line
+    expect(annotate).toHaveBeenCalledWith("comment", 3, 2, 9, "YAGNI\n\ncut scope");
+    expect(deps.setFocusedAnnotationId).toHaveBeenCalledWith("an_new");
+    expect(deps.setMode).toHaveBeenCalledWith({ type: "normal" });
+  });
+
+  test("pickSpanAction honors an explicit index (mouse click)", () => {
+    // Arrange
+    const annotate = mock(() => "an_new");
+    const deps = makeDeps({
+      mode: { type: "spanActions", span, index: 0 },
+      session: sessionWith([]),
+      quickActions: [{ prompt: "Needs a test" }, { prompt: "Extract the duplication" }],
+      controller: { ...baseController(), annotate } as unknown as IntentDispatchDeps["controller"],
+    });
+    const dispatch = createIntentDispatch(deps);
+
+    // Act
+    dispatch({ type: "pickSpanAction", index: 1 });
+
+    // Assert
+    expect(annotate).toHaveBeenCalledWith("comment", 3, 2, 9, "Extract the duplication");
+  });
+
+  test("closeSpanActions returns to the span toolbar", () => {
+    // Arrange
+    const deps = makeDeps({ mode: { type: "spanActions", span, index: 2 } });
+    const dispatch = createIntentDispatch(deps);
+
+    // Act
+    dispatch({ type: "closeSpanActions" });
+
+    // Assert
+    expect(deps.setMode).toHaveBeenCalledWith({ type: "span", span });
   });
 });
 
@@ -202,6 +315,65 @@ describe("share", () => {
   });
 });
 
+describe("restoreCuration", () => {
+  const items = [
+    {
+      id: "diff:f#0#hunk",
+      source: "diff" as const,
+      label: "f:1 - hunk",
+      preview: [],
+      revealIndex: 1,
+    },
+    {
+      id: "diff:f#1#2",
+      source: "diff" as const,
+      label: "f:9 - change",
+      preview: [],
+      revealIndex: 9,
+    },
+  ];
+
+  test("restores the selected item and clears the selection", () => {
+    // Arrange
+    const deps = makeDeps({ selectedCurationId: "diff:f#1#2" });
+    (deps.controller.curationItems as ReturnType<typeof mock>).mockReturnValue(items);
+    const dispatch = createIntentDispatch(deps);
+
+    // Act
+    dispatch({ type: "restoreCuration" });
+
+    // Assert
+    expect(deps.controller.restoreCuration).toHaveBeenCalledWith("diff:f#1#2");
+    expect(deps.setSelectedCurationId).toHaveBeenCalledWith(undefined);
+  });
+
+  test("with nothing selected, undoes the last removal", () => {
+    // Arrange
+    const deps = makeDeps({ selectedCurationId: undefined });
+    (deps.controller.curationItems as ReturnType<typeof mock>).mockReturnValue(items);
+    const dispatch = createIntentDispatch(deps);
+
+    // Act
+    dispatch({ type: "restoreCuration" });
+
+    // Assert
+    expect(deps.controller.restoreCuration).toHaveBeenCalledWith("diff:f#1#2");
+  });
+
+  test("does nothing when there is nothing curated out", () => {
+    // Arrange
+    const deps = makeDeps();
+    (deps.controller.curationItems as ReturnType<typeof mock>).mockReturnValue([]);
+    const dispatch = createIntentDispatch(deps);
+
+    // Act
+    dispatch({ type: "restoreCuration" });
+
+    // Assert
+    expect(deps.controller.restoreCuration).not.toHaveBeenCalled();
+  });
+});
+
 describe("exit", () => {
   test("calls the exit hook with 0", () => {
     // Arrange
@@ -226,7 +398,11 @@ describe("inbox delete", () => {
     createIntentDispatch(deps)({ type: "requestDeleteSession" });
 
     // Assert
-    expect(deps.setMode).toHaveBeenCalledWith({ type: "confirmDelete", sessionId: "ses_1", title: "Plan A" });
+    expect(deps.setMode).toHaveBeenCalledWith({
+      type: "confirmDelete",
+      sessionId: "ses_1",
+      title: "Plan A",
+    });
   });
 
   test("confirmDialog deletes the session and closes", () => {
@@ -246,13 +422,21 @@ describe("rename author", () => {
   test("openRename seeds the prompt with the author's current local name", () => {
     // Arrange
     const session = { annotations: [{ id: "a1", author: "SHA256:x" }] } as never;
-    const deps = makeDeps({ session, focusedAnnotationId: "a1", authorNames: { "SHA256:x": "Alex" } });
+    const deps = makeDeps({
+      session,
+      focusedAnnotationId: "a1",
+      authorNames: { "SHA256:x": "Alex" },
+    });
 
     // Act
     createIntentDispatch(deps)({ type: "openRename" });
 
     // Assert
-    expect(deps.setMode).toHaveBeenCalledWith({ type: "rename", authorId: "SHA256:x", text: "Alex" });
+    expect(deps.setMode).toHaveBeenCalledWith({
+      type: "rename",
+      authorId: "SHA256:x",
+      text: "Alex",
+    });
   });
 
   test("openRename on your own note does nothing but explain", () => {

package/src/intent-dispatch.ts

@@ -13,32 +13,55 @@ import { displayText, spanKey, startSpan, type DisplayBlock, type SpanState } fr
 import type { DiffRow } from "./view-diff";
 import type { ReviewController } from "./session-controller";
 import type { Intent } from "./keymap";
+import type { QuickAction } from "./config";
 import type { PlanSheetHandle } from "./components/PlanSheet";
 import { VERDICTS } from "./components/ConfirmCard";
-import { REVIEW_RESIZE_STEP, cycleReviewPanelMode, resolveReviewWidth, type ReviewPanelMode } from "./review-panel";
+import {
+  REVIEW_RESIZE_STEP,
+  cycleReviewPanelMode,
+  resolveReviewWidth,
+  type ReviewPanelMode,
+} from "./review-panel";
 
 /** The one overlay/mode the TUI is in; every compose/submit/edit flow is a variant. */
 export type Mode =
   | { type: "normal" }
   | { type: "span"; span: SpanState }
-  | { type: "compose"; kind: "comment" | "suggestion"; displayIndex: number; start: number; end: number; text: string }
+  | { type: "spanActions"; span: SpanState; index: number }
+  | {
+      type: "compose";
+      kind: "comment";
+      displayIndex: number;
+      start: number;
+      end: number;
+      text: string;
+    }
   | { type: "railEdit"; id: string; text: string }
   | { type: "submit"; verdict: VerdictKind; summary: string }
   | { type: "confirmDelete"; sessionId: string; title: string }
   | { type: "rename"; authorId: string; text: string }
   | { type: "nameSelf"; text: string };
 
+/** The marked span for span mode and its quick-actions sub-mode; null otherwise. */
+export function activeSpanState(mode: Mode): SpanState | null {
+  return mode.type === "span" || mode.type === "spanActions" ? mode.span : null;
+}
+
 /**
  * Annotations that still count as feedback: agent notes never do, and an
  * annotation a revision already addressed is settled - it neither blocks the
  * verdict default nor re-enters the next feedback document.
  */
 export function reviewerAnnotations(session: ReviewSession) {
-  return session.annotations.filter((annotation) => !isAgentNote(annotation) && !isAddressed(annotation));
+  return session.annotations.filter(
+    (annotation) => !isAgentNote(annotation) && !isAddressed(annotation),
+  );
 }
 
 export function defaultVerdict(session: ReviewSession): VerdictKind {
-  return reviewerAnnotations(session).length || session.workingCopy !== undefined ? "request_changes" : "approve";
+  return reviewerAnnotations(session).length || session.workingCopy !== undefined
+    ? "request_changes"
+    : "approve";
 }
 
 /**
@@ -63,8 +86,12 @@ export interface IntentDispatchDeps {
   reviewWidth: number;
   terminalWidth: number;
   focusedAnnotationId: string | undefined;
+  /** The curation item selected in the rail, if any; the undo target when set. */
+  selectedCurationId: string | undefined;
   /** Planner-local author renames, for seeding the rename prompt. */
   authorNames: Record<string, string>;
+  /** Marker-popover quick actions, in list order; picking one inserts a preset comment. */
+  quickActions: QuickAction[];
   /** Persist an author rename and update the live overrides (App-owned). */
   renameAuthor: (id: string, name: string) => void;
 
@@ -79,6 +106,7 @@ export interface IntentDispatchDeps {
   setReviewWidth: Dispatch<SetStateAction<number>>;
   setRailTab: Dispatch<SetStateAction<"review" | "agent">>;
   setFocusedAnnotationId: Dispatch<SetStateAction<string | undefined>>;
+  setSelectedCurationId: Dispatch<SetStateAction<string | undefined>>;
   setPulsedAnnotationId: Dispatch<SetStateAction<string | null>>;
 
   selectCardFromDocument: (annotationId: string) => void;
@@ -103,7 +131,9 @@ export function createIntentDispatch(deps: IntentDispatchDeps): (intent: Intent)
     reviewWidth,
     terminalWidth,
     focusedAnnotationId,
+    selectedCurationId,
     authorNames,
+    quickActions,
     renameAuthor,
     liveInput,
     reviewWidthRef,
@@ -115,6 +145,7 @@ export function createIntentDispatch(deps: IntentDispatchDeps): (intent: Intent)
     setReviewWidth,
     setRailTab,
     setFocusedAnnotationId,
+    setSelectedCurationId,
     setPulsedAnnotationId,
     selectCardFromDocument,
     runEditorHandOff,
@@ -137,7 +168,11 @@ export function createIntentDispatch(deps: IntentDispatchDeps): (intent: Intent)
       }
       case "inboxMove": {
         const navigableCount = inbox?.length ?? 0;
-        setInboxCursor((current) => (intent.to === "down" ? Math.min(navigableCount - 1, current + 1) : Math.max(0, current - 1)));
+        setInboxCursor((current) =>
+          intent.to === "down"
+            ? Math.min(navigableCount - 1, current + 1)
+            : Math.max(0, current - 1),
+        );
         return;
       }
       case "openSession": {
@@ -147,13 +182,25 @@ export function createIntentDispatch(deps: IntentDispatchDeps): (intent: Intent)
       }
       case "requestDeleteSession": {
         const selected = inbox?.[inboxCursor];
-        if (selected) setMode({ type: "confirmDelete", sessionId: selected.id, title: selected.artifact.meta.title ?? selected.id });
+        if (selected)
+          setMode({
+            type: "confirmDelete",
+            sessionId: selected.id,
+            title: selected.artifact.meta.title ?? selected.id,
+          });
         return;
       }
       case "openRename": {
-        const focused = session?.annotations.find((annotation) => annotation.id === focusedAnnotationId);
-        if (!focused?.author) return void controller.setStatus("that is your own note - nothing to rename");
-        return void setMode({ type: "rename", authorId: focused.author, text: authorNames[focused.author] ?? "" });
+        const focused = session?.annotations.find(
+          (annotation) => annotation.id === focusedAnnotationId,
+        );
+        if (!focused?.author)
+          return void controller.setStatus("that is your own note - nothing to rename");
+        return void setMode({
+          type: "rename",
+          authorId: focused.author,
+          text: authorNames[focused.author] ?? "",
+        });
       }
       case "confirmDialog": {
         if (mode.type === "confirmDelete") controller.deleteSession(mode.sessionId);
@@ -170,10 +217,52 @@ export function createIntentDispatch(deps: IntentDispatchDeps): (intent: Intent)
       }
       case "spanKey":
         if (mode.type === "span") {
-          const span = spanKey(mode.span, intent.name, displayText(display[mode.span.displayIndex]!));
+          const span = spanKey(
+            mode.span,
+            intent.name,
+            displayText(display[mode.span.displayIndex]!),
+          );
           setMode({ type: "span", span });
         }
         return;
+      case "spanCut":
+        // the block the span sits in, cut whole (partial-span cut is not modeled)
+        if (mode.type === "span") {
+          controller.cut(mode.span.displayIndex);
+          setMode({ type: "normal" });
+        }
+        return;
+      case "openSpanActions":
+        if (mode.type === "span") setMode({ type: "spanActions", span: mode.span, index: 0 });
+        return;
+      case "moveSpanAction":
+        if (mode.type === "spanActions") {
+          const index = Math.max(
+            0,
+            Math.min(quickActions.length - 1, mode.index + intent.direction),
+          );
+          setMode({ ...mode, index });
+        }
+        return;
+      case "closeSpanActions":
+        if (mode.type === "spanActions") setMode({ type: "span", span: mode.span });
+        return;
+      case "pickSpanAction": {
+        if (mode.type !== "spanActions") return;
+        const action = quickActions[intent.index ?? mode.index];
+        if (session && action) {
+          const body = action.metadata ? `${action.prompt}\n\n${action.metadata}` : action.prompt;
+          const annotationId = controller.annotate(
+            "comment",
+            mode.span.displayIndex,
+            mode.span.start,
+            mode.span.end,
+            body,
+          );
+          if (annotationId) setFocusedAnnotationId(annotationId);
+        }
+        return void setMode({ type: "normal" });
+      }
       case "openCompose": {
         liveInput.current = "";
         if (intent.from === "span" && mode.type === "span") {
@@ -187,7 +276,15 @@ export function createIntentDispatch(deps: IntentDispatchDeps): (intent: Intent)
           });
         } else if (isDiff) {
           const row = rows[cursor];
-          if (row) setMode({ type: "compose", kind: intent.kind, displayIndex: cursor, start: 0, end: row.text.length, text: "" });
+          if (row)
+            setMode({
+              type: "compose",
+              kind: intent.kind,
+              displayIndex: cursor,
+              start: 0,
+              end: row.text.length,
+              text: "",
+            });
         } else {
           // a mouse drag leaves a native selection; it wins over the cursor block
           const native = planSheetRef.current?.readSelection() ?? null;
@@ -195,7 +292,15 @@ export function createIntentDispatch(deps: IntentDispatchDeps): (intent: Intent)
             setMode({ type: "compose", kind: intent.kind, ...native, text: "" });
           } else {
             const block = display[cursor];
-            if (block) setMode({ type: "compose", kind: intent.kind, displayIndex: cursor, start: 0, end: displayText(block).length, text: "" });
+            if (block)
+              setMode({
+                type: "compose",
+                kind: intent.kind,
+                displayIndex: cursor,
+                start: 0,
+                end: displayText(block).length,
+                text: "",
+              });
           }
         }
         return;
@@ -213,6 +318,19 @@ export function createIntentDispatch(deps: IntentDispatchDeps): (intent: Intent)
         return controller.share();
       case "cut":
         return controller.cut(cursor);
+      case "rejectHunk":
+        return controller.toggleRejectHunk(cursor);
+      case "rejectChange":
+        return controller.toggleRejectChange(cursor);
+      case "restoreCuration": {
+        // undo the selected curated-out item, or the last rejected when none is
+        // selected, so a bare `u` reads as "undo my last curation"
+        const items = controller.curationItems();
+        if (!items.length) return;
+        const targetId = selectedCurationId ?? items[items.length - 1]!.id;
+        controller.restoreCuration(targetId);
+        return void setSelectedCurationId(undefined);
+      }
       case "edit":
         return runEditorHandOff();
       case "editCard":
@@ -221,13 +339,18 @@ export function createIntentDispatch(deps: IntentDispatchDeps): (intent: Intent)
       case "nextAnnotation":
       case "prevAnnotation": {
         // cycle open cards only - addressed ones are out of the rail
-        const annotations = (session?.annotations ?? []).filter((annotation) => !isAddressed(annotation));
+        const annotations = (session?.annotations ?? []).filter(
+          (annotation) => !isAddressed(annotation),
+        );
         if (!annotations.length) return;
-        const focusedIndex = annotations.findIndex((annotation) => annotation.id === focusedAnnotationId);
+        const focusedIndex = annotations.findIndex(
+          (annotation) => annotation.id === focusedAnnotationId,
+        );
         const nextIndex =
           focusedIndex === -1
             ? 0
-            : (focusedIndex + (intent.type === "nextAnnotation" ? 1 : -1) + annotations.length) % annotations.length;
+            : (focusedIndex + (intent.type === "nextAnnotation" ? 1 : -1) + annotations.length) %
+              annotations.length;
         return void selectCardFromDocument(annotations[nextIndex]!.id);
       }
       case "walkStart":
@@ -259,7 +382,13 @@ export function createIntentDispatch(deps: IntentDispatchDeps): (intent: Intent)
         }
         if (mode.type !== "compose") return;
         if (session && body) {
-          const annotationId = controller.annotate(mode.kind, mode.displayIndex, mode.start, mode.end, body);
+          const annotationId = controller.annotate(
+            mode.kind,
+            mode.displayIndex,
+            mode.start,
+            mode.end,
+            body,
+          );
           if (annotationId) setFocusedAnnotationId(annotationId);
         }
         return void setMode({ type: "normal" });
@@ -269,7 +398,8 @@ export function createIntentDispatch(deps: IntentDispatchDeps): (intent: Intent)
         return void setMode({ type: "normal" });
       case "cycleVerdict": {
         if (mode.type !== "submit") return;
-        const verdictIndex = (VERDICTS.indexOf(mode.verdict) + intent.direction + VERDICTS.length) % VERDICTS.length;
+        const verdictIndex =
+          (VERDICTS.indexOf(mode.verdict) + intent.direction + VERDICTS.length) % VERDICTS.length;
         return void setMode({ ...mode, verdict: VERDICTS[verdictIndex]! });
       }
       case "finishReview":
@@ -285,7 +415,10 @@ export function createIntentDispatch(deps: IntentDispatchDeps): (intent: Intent)
       }
       case "resizeReviewPanel": {
         if (reviewMode !== "expanded") return;
-        const next = resolveReviewWidth(reviewWidth + intent.direction * REVIEW_RESIZE_STEP, terminalWidth);
+        const next = resolveReviewWidth(
+          reviewWidth + intent.direction * REVIEW_RESIZE_STEP,
+          terminalWidth,
+        );
         reviewWidthRef.current = next;
         setReviewWidth(next);
         return controller.saveReviewPanel({ width: next });