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

package/src/intent-dispatch.test.ts

@@ -11,6 +11,7 @@ import { SCHEMA_VERSION, type Annotation, type ReviewSession } from "@cueloop/sc
 import { createIntentDispatch, type IntentDispatchDeps } from "./intent-dispatch";
 import type { ControllerSnapshot, CurationItem, ReviewController } from "./session-controller";
 import type { DisplayBlock } from "./view-plan";
+import type { TreeRow } from "./tree-view";
 
 function block(text: string): DisplayBlock {
   return { type: "same", kind: "p", work: { kind: "p", text, lineStart: 0, lineEnd: 0 } };
@@ -56,7 +57,7 @@ const EMPTY_SNAPSHOT: ControllerSnapshot = {
   walk: null,
 };
 
-/** A controller where every verb is a mock; annotate returns undefined by default. */
+/** A controller where every primitive is a mock; annotate returns undefined by default. */
 function baseController(): ReviewController {
   return {
     readOnly: false,
@@ -83,6 +84,7 @@ function baseController(): ReviewController {
     restoreCuration: mock(),
     edit: mock(),
     annotate: mock(() => undefined),
+    reply: mock(() => undefined),
     annotatePrototype: mock(() => undefined),
     updateAnnotation: mock(),
     removeAnnotation: mock(),
@@ -93,8 +95,14 @@ function baseController(): ReviewController {
     walkLeave: mock(),
     submit: mock(),
     share: mock(),
+    treeRows: mock(() => []),
+    goToEntry: mock(),
+    branch: mock(),
+    labelTip: mock(),
+    fork: mock(),
+    forkAndShare: mock(),
     pullShared: mock(() => Promise.resolve()),
-    startSharePoll: mock(() => () => {}),
+    startShareSync: mock(() => () => {}),
     finishReview: mock(),
     dismissCompletion: mock(),
     optInAutoClose: mock(),
@@ -120,18 +128,20 @@ function makeDeps(overrides: Partial<IntentDispatchDeps> = {}): IntentDispatchDe
     terminalWidth: 120,
     focusedAnnotationId: undefined,
     selectedCurationId: undefined,
+    railTab: "review",
+    selectedEntryId: undefined,
     authorNames: {},
     quickActions: [],
     renameAuthor: mock(),
     liveInput: { current: "" },
     reviewWidthRef: { current: 34 },
-    planSheetRef: { current: null },
     setCursor: mock(),
     setInboxCursor: mock(),
     setMode: mock(),
     setReviewMode: mock(),
     setReviewWidth: mock(),
     setRailTab: mock(),
+    setSelectedEntryId: mock(),
     setFocusedAnnotationId: mock(),
     setSelectedCurationId: mock(),
     setPulsedAnnotationId: mock(),
@@ -544,3 +554,126 @@ describe("collaborator self-name", () => {
     expect(deps.setMode).toHaveBeenCalledWith({ type: "normal" });
   });
 });
+
+describe("tree intents", () => {
+  const rows: TreeRow[] = [
+    {
+      entryId: "e1",
+      depth: 0,
+      glyph: "◉",
+      text: "revision 1",
+      onPath: true,
+      tips: [],
+      isCurrentTip: false,
+    },
+    {
+      entryId: "e2",
+      depth: 0,
+      glyph: "·",
+      text: "comment",
+      onPath: true,
+      tips: ["main"],
+      isCurrentTip: false,
+    },
+    {
+      entryId: "e3",
+      depth: 1,
+      glyph: "·",
+      text: "comment",
+      onPath: false,
+      tips: ["alt"],
+      isCurrentTip: true,
+    },
+  ];
+
+  function treeDeps(overrides: Partial<IntentDispatchDeps> = {}): IntentDispatchDeps {
+    const deps = makeDeps({ railTab: "tree", ...overrides });
+
+    deps.controller.treeRows = mock(() => rows);
+
+    return deps;
+  }
+
+  test("toggleTree shows the Tree tab and hides it again", () => {
+    // Arrange
+    const shown = makeDeps({ railTab: "review" });
+    const hidden = makeDeps({ railTab: "tree" });
+
+    // Act
+    createIntentDispatch(shown)({ type: "toggleTree" });
+    createIntentDispatch(hidden)({ type: "toggleTree" });
+
+    // Assert
+    expect(shown.setRailTab).toHaveBeenCalledWith("tree");
+    expect(hidden.setRailTab).toHaveBeenCalledWith("review");
+  });
+
+  test("treeMove starts from the current tip and stays inside the rows", () => {
+    // Arrange
+    const fromTip = treeDeps();
+    const atTop = treeDeps({ selectedEntryId: "e1" });
+
+    // Act
+    createIntentDispatch(fromTip)({ type: "treeMove", direction: -1 });
+    createIntentDispatch(atTop)({ type: "treeMove", direction: -1 });
+
+    // Assert
+    expect(fromTip.setSelectedEntryId).toHaveBeenCalledWith("e2");
+    expect(atTop.setSelectedEntryId).toHaveBeenCalledWith("e1");
+  });
+
+  test("treeGo: the tip answers, a tip of another branch switches, an inner entry asks for a summary", () => {
+    // Arrange
+    const atTip = treeDeps({ selectedEntryId: "e3" });
+    const toTip = treeDeps({ selectedEntryId: "e2" });
+    const inner = treeDeps({ selectedEntryId: "e1" });
+
+    // Act
+    createIntentDispatch(atTip)({ type: "treeGo" });
+    createIntentDispatch(toTip)({ type: "treeGo" });
+    createIntentDispatch(inner)({ type: "treeGo" });
+
+    // Assert
+    expect(atTip.controller.setStatus).toHaveBeenCalledWith("already at the tip");
+    expect(toTip.controller.goToEntry).toHaveBeenCalledWith("e2");
+    expect(inner.setMode).toHaveBeenCalledWith({
+      type: "treePrompt",
+      ask: "navigate",
+      entryId: "e1",
+      text: "",
+    });
+  });
+
+  test("the prompts confirm into branch, label, and a move back with the typed summary", () => {
+    // Arrange
+    const branch = treeDeps({ mode: { type: "treePrompt", ask: "branch", text: "alt" } });
+    const label = treeDeps({ mode: { type: "treePrompt", ask: "label", text: "start" } });
+    const navigate = treeDeps({
+      mode: { type: "treePrompt", ask: "navigate", entryId: "e1", text: " too early " },
+    });
+
+    // Act
+    createIntentDispatch(branch)({ type: "confirmDialog" });
+    createIntentDispatch(label)({ type: "confirmDialog" });
+    createIntentDispatch(navigate)({ type: "confirmDialog" });
+
+    // Assert
+    expect(branch.controller.branch).toHaveBeenCalledWith("alt");
+    expect(label.controller.labelTip).toHaveBeenCalledWith("start");
+    expect(navigate.controller.goToEntry).toHaveBeenCalledWith("e1", "too early");
+    expect(navigate.setMode).toHaveBeenCalledWith({ type: "normal" });
+  });
+
+  test("treeFork and treeForkShare reach the controller", () => {
+    // Arrange
+    const deps = treeDeps();
+
+    // Act
+    createIntentDispatch(deps)({ type: "treeFork" });
+    createIntentDispatch(deps)({ type: "treeForkShare" });
+
+    // Assert
+    expect(deps.controller.fork).toHaveBeenCalledTimes(1);
+    expect(deps.controller.forkAndShare).toHaveBeenCalledTimes(1);
+  });
+});

package/src/intent-dispatch.ts

@@ -7,14 +7,15 @@
  * into React beyond the setters it is given.
  */
 
-import type { Dispatch, MutableRefObject, RefObject, SetStateAction } from "react";
+import type { Dispatch, MutableRefObject, SetStateAction } from "react";
 import { isAddressed, isAgentNote, type ReviewSession, type VerdictKind } from "@cueloop/schema";
 import { displayText, spanKey, startSpan, type DisplayBlock, type SpanState } from "./view-plan";
 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 type { PlanSheetHandle } from "./components/PlanSheet";
 import { VERDICTS } from "./components/ConfirmCard";
 import {
   REVIEW_RESIZE_STEP,
@@ -40,7 +41,11 @@ export type Mode =
   | { type: "submit"; verdict: VerdictKind; summary: string }
   | { type: "confirmDelete"; sessionId: string; title: string }
   | { type: "rename"; authorId: string; text: string }
-  | { type: "nameSelf"; text: string };
+  | { type: "nameSelf"; text: string }
+  | { type: "treePrompt"; ask: TreeAsk; entryId?: string; text: string };
+
+/** What a tree prompt asks for: a branch name, a checkpoint name, or the summary a move back leaves. */
+export type TreeAsk = "branch" | "label" | "navigate";
 
 /** The marked span for span mode and its quick-actions sub-mode; null otherwise. */
 export function activeSpanState(mode: Mode): SpanState | null {
@@ -88,6 +93,9 @@ export interface IntentDispatchDeps {
   focusedAnnotationId: string | undefined;
   /** The curation item selected in the rail, if any; the undo target when set. */
   selectedCurationId: string | undefined;
+  railTab: RailTab;
+  /** The tree row selected in the rail's Tree tab; the target of go. */
+  selectedEntryId: 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. */
@@ -97,14 +105,14 @@ export interface IntentDispatchDeps {
 
   liveInput: MutableRefObject<string>;
   reviewWidthRef: MutableRefObject<number>;
-  planSheetRef: RefObject<PlanSheetHandle | null>;
 
   setCursor: Dispatch<SetStateAction<number>>;
   setInboxCursor: Dispatch<SetStateAction<number>>;
   setMode: Dispatch<SetStateAction<Mode>>;
   setReviewMode: Dispatch<SetStateAction<ReviewPanelMode>>;
   setReviewWidth: Dispatch<SetStateAction<number>>;
-  setRailTab: Dispatch<SetStateAction<"review" | "agent">>;
+  setRailTab: Dispatch<SetStateAction<RailTab>>;
+  setSelectedEntryId: Dispatch<SetStateAction<string | undefined>>;
   setFocusedAnnotationId: Dispatch<SetStateAction<string | undefined>>;
   setSelectedCurationId: Dispatch<SetStateAction<string | undefined>>;
   setPulsedAnnotationId: Dispatch<SetStateAction<string | null>>;
@@ -187,6 +195,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 === "nameSelf") controller.setSelfName(mode.text.trim());
+  else if (mode.type === "treePrompt") confirmTreePrompt(mode, deps);
   deps.setMode({ type: "normal" });
 }
 
@@ -307,24 +316,17 @@ function handleOpenCompose(intent: IntentOfType<"openCompose">, deps: IntentDisp
         text: "",
       });
   } else {
-    // a mouse drag leaves a native selection; it wins over the cursor block
-    const native = deps.planSheetRef.current?.readSelection() ?? null;
-
-    if (native) {
-      deps.setMode({ type: "compose", kind: intent.kind, ...native, text: "" });
-    } else {
-      const block = deps.display[deps.cursor];
-
-      if (block)
-        deps.setMode({
-          type: "compose",
-          kind: intent.kind,
-          displayIndex: deps.cursor,
-          start: 0,
-          end: displayText(block).length,
-          text: "",
-        });
-    }
+    const block = deps.display[deps.cursor];
+
+    if (block)
+      deps.setMode({
+        type: "compose",
+        kind: intent.kind,
+        displayIndex: deps.cursor,
+        start: 0,
+        end: displayText(block).length,
+        text: "",
+      });
   }
 }
 
@@ -429,7 +431,6 @@ function handleRemoveAnnotation(
 }
 
 function handleDeselect(_intent: IntentOfType<"deselect">, deps: IntentDispatchDeps): void {
-  deps.planSheetRef.current?.clearSelection();
   deps.setFocusedAnnotationId(undefined);
   deps.setPulsedAnnotationId(null);
 }
@@ -526,6 +527,66 @@ function handleResizeReviewPanel(
   deps.controller.saveReviewPanel({ width: next });
 }
 
+function confirmTreePrompt(
+  mode: Extract<Mode, { type: "treePrompt" }>,
+  deps: IntentDispatchDeps,
+): void {
+  if (mode.ask === "branch") deps.controller.branch(mode.text);
+  else if (mode.ask === "label") deps.controller.labelTip(mode.text);
+  else if (mode.entryId !== undefined) deps.controller.goToEntry(mode.entryId, mode.text.trim());
+}
+
+function handleToggleTree(_intent: IntentOfType<"toggleTree">, deps: IntentDispatchDeps): void {
+  deps.setRailTab(deps.railTab === "tree" ? "review" : "tree");
+}
+
+/** The tree rows in drawing order; the selection falls back to the current tip. */
+function selectedTreeIndex(deps: IntentDispatchDeps, rows: TreeRow[]): number {
+  const byId = rows.findIndex((row) => row.entryId === deps.selectedEntryId);
+
+  return byId === -1 ? rows.findIndex((row) => row.isCurrentTip) : byId;
+}
+
+function handleTreeMove(intent: IntentOfType<"treeMove">, deps: IntentDispatchDeps): void {
+  const rows = deps.controller.treeRows();
+
+  if (rows.length === 0) return;
+  const current = selectedTreeIndex(deps, rows);
+  const next = Math.min(rows.length - 1, Math.max(0, current + intent.direction));
+
+  deps.setSelectedEntryId(rows[next]!.entryId);
+}
+
+function handleTreeGo(_intent: IntentOfType<"treeGo">, deps: IntentDispatchDeps): void {
+  const rows = deps.controller.treeRows();
+  const row = rows[selectedTreeIndex(deps, rows)];
+
+  if (!row) return deps.controller.setStatus("select an entry in the tree first");
+  if (row.isCurrentTip) return deps.controller.setStatus("already at the tip");
+  // a switch needs no summary; a move back may leave one, so it asks
+  if (row.tips.length > 0) return deps.controller.goToEntry(row.entryId);
+  deps.setMode({ type: "treePrompt", ask: "navigate", entryId: row.entryId, text: "" });
+}
+
+function handleTreeBranch(_intent: IntentOfType<"treeBranch">, deps: IntentDispatchDeps): void {
+  deps.setMode({ type: "treePrompt", ask: "branch", text: "" });
+}
+
+function handleTreeLabel(_intent: IntentOfType<"treeLabel">, deps: IntentDispatchDeps): void {
+  deps.setMode({ type: "treePrompt", ask: "label", text: "" });
+}
+
+function handleTreeFork(_intent: IntentOfType<"treeFork">, deps: IntentDispatchDeps): void {
+  deps.controller.fork();
+}
+
+function handleTreeForkShare(
+  _intent: IntentOfType<"treeForkShare">,
+  deps: IntentDispatchDeps,
+): void {
+  deps.controller.forkAndShare();
+}
+
 type IntentHandlers = {
   [Kind in Intent["type"]]: (intent: IntentOfType<Kind>, deps: IntentDispatchDeps) => void;
 };
@@ -572,6 +633,13 @@ const intentHandlers: IntentHandlers = {
   dismissCompletion: handleDismissCompletion,
   cycleReviewPanel: handleCycleReviewPanel,
   resizeReviewPanel: handleResizeReviewPanel,
+  toggleTree: handleToggleTree,
+  treeMove: handleTreeMove,
+  treeGo: handleTreeGo,
+  treeBranch: handleTreeBranch,
+  treeLabel: handleTreeLabel,
+  treeFork: handleTreeFork,
+  treeForkShare: handleTreeForkShare,
 };
 
 function dispatchIntent<Kind extends Intent["type"]>(

package/src/key-bindings.test.ts

@@ -43,7 +43,7 @@ describe("grammar-layer resolution", () => {
 });
 
 describe("mode layers own their keys", () => {
-  test("span mode resolves the span verbs, not the grammar", () => {
+  test("span mode resolves the span primitives, not the grammar", () => {
     // Arrange
     const resolver = bindings({ spanMode: true });
 

package/src/keymap.test.ts

@@ -224,7 +224,7 @@ describe("plan normal mode", () => {
     });
   }
 
-  test("resolved sessions guard the mutating verbs", () => {
+  test("resolved sessions guard the mutating primitives", () => {
     // Arrange
     const resolvedState = state({ resolved: true });
 
@@ -386,9 +386,9 @@ describe("diff mode", () => {
     ["p", [{ type: "prevAnnotation" }]],
     ["backspace", [{ type: "removeAnnotation" }]],
     ["return", [{ type: "openSubmit" }]],
-    ["v", [{ type: "status", message: "plan-only verb - diff review uses c on a line" }]],
+    ["v", [{ type: "status", message: "plan-only primitive - diff review uses c on a line" }]],
     ["x", [{ type: "rejectChange" }]],
-    ["e", [{ type: "status", message: "plan-only verb - diff review uses c on a line" }]],
+    ["e", [{ type: "status", message: "plan-only primitive - diff review uses c on a line" }]],
     ["q", [{ type: "exit" }]],
   ];
 
@@ -514,7 +514,7 @@ describe("review panel controls", () => {
     expect(reduceKey(observer, key("]"))).toEqual([{ type: "resizeReviewPanel", direction: 1 }]);
   });
 
-  test("span mode still owns b as a span verb, not a panel cycle", () => {
+  test("span mode still owns b as a span primitive, not a panel cycle", () => {
     // Assert
     expect(reduceKey(state({ spanMode: true }), key("b"))).toEqual([
       { type: "spanKey", name: "b" },

package/src/keymap.ts

@@ -1,7 +1,7 @@
 /**
  * The keyboard grammar as a pure reducer: view state in, intents out.
  * App builds a KeyState per key event, calls reduceKey, and dispatches the
- * intents to controller verbs and view-state setters - no branch bodies live
+ * intents to controller primitives and view-state setters - no branch bodies live
  * in the key handler. Diff and plan reviews share one path for annotation
  * navigation, deletion, and submit; the read-only rule is one gate here.
  */
@@ -49,7 +49,14 @@ export type Intent =
   | { type: "optInAutoClose" }
   | { type: "dismissCompletion" }
   | { type: "cycleReviewPanel" }
-  | { type: "resizeReviewPanel"; direction: -1 | 1 };
+  | { type: "resizeReviewPanel"; direction: -1 | 1 }
+  | { type: "toggleTree" }
+  | { type: "treeMove"; direction: -1 | 1 }
+  | { type: "treeGo" }
+  | { type: "treeBranch" }
+  | { type: "treeLabel" }
+  | { type: "treeFork" }
+  | { type: "treeForkShare" };
 
 export interface KeyInput {
   name: string;
@@ -63,7 +70,7 @@ export interface KeyState {
   keys: Record<string, string[]>;
   readOnly: boolean;
   /**
-   * Owner-only verbs a share collaborator lacks (undefined = owner, allowed).
+   * Owner-only primitives a share collaborator lacks (undefined = owner, allowed).
    * A collaborator annotates but cannot edit the plan (cut / $EDITOR runs on
    * the gateway) or submit an agent verdict (there is no agent on a share).
    */
@@ -95,7 +102,7 @@ export interface KeyState {
   cursorAnnotatable: boolean;
 }
 
-/** Verbs that write session state; an observer never reaches their handlers. */
+/** Primitives that write session state; an observer never reaches their handlers. */
 const MUTATING_ACTIONS = new Set([
   "comment",
   "cut",
@@ -136,7 +143,7 @@ export function reduceKey(state: KeyState, key: KeyInput, resolvedAction?: strin
 
   if (state.readOnly && mutating) return status("observer - read-only");
 
-  // share is a session-level verb: it works from any view, owner only
+  // share is a session-level primitive: it works from any view, owner only
   if (action === "share") {
     if (state.canShare === false) return status("only the plan owner can share");
 
@@ -305,7 +312,7 @@ function diffGrammar(state: KeyState, action: string | undefined): Intent[] {
 
   if (shared) return shared;
   if (action === "span" || action === "edit") {
-    return status("plan-only verb - diff review uses c on a line");
+    return status("plan-only primitive - diff review uses c on a line");
   }
 
   return [];
@@ -356,7 +363,7 @@ function planGrammar(state: KeyState, action: string | undefined, name: string):
     // the annotation and edit rewrites the card body in place
     if (state.hasFocusedAnnotation)
       return [action === "cut" ? { type: "removeAnnotation" } : { type: "editCard" }];
-    // editing the plan itself is the owner's verb; a share viewer only annotates,
+    // editing the plan itself is the owner's primitive; a share viewer only annotates,
     // and has no edit affordance, so the key is silent rather than a nag
     if (state.canEditPlan === false) return [];
 

package/src/session-controller.curate.test.ts

@@ -1,5 +1,14 @@
 import { describe, expect, mock, test } from "bun:test";
-import { SCHEMA_VERSION, type DiffFileContents, type ReviewSession } from "@cueloop/schema";
+import {
+  cutBlock,
+  parseBlocks,
+  restoreBlock,
+  SCHEMA_VERSION,
+  type DiffFileContents,
+  type HunkRejection,
+  type ReviewSession,
+} from "@cueloop/schema";
+import { curateDiff } from "@cueloop/daemon/curate";
 import type { SessionClient } from "@cueloop/daemon/client";
 import { createReviewController } from "./session-controller";
 
@@ -45,7 +54,9 @@ const unimplemented = (member: string) => () =>
   Promise.reject(new Error(`fakeClient does not implement ${member}`));
 
 /** A fake client that records the working copy the controller writes. */
-function fakeClient(session: ReviewSession, sink: WorkingCopySink): SessionClient {
+function fakeClient(initial: ReviewSession, sink: WorkingCopySink): SessionClient {
+  let session = initial;
+
   return {
     onEvent: () => () => {},
     subscribe: async () => {},
@@ -58,6 +69,50 @@ function fakeClient(session: ReviewSession, sink: WorkingCopySink): SessionClien
 
       return { ...session, workingCopy: content };
     }),
+    // the daemon's block primitives, stood in for with the same pure helpers it uses
+    sessionCutBlock: mock(async (_id: string, blockIndex: number) => {
+      const working = session.workingCopy ?? session.artifact.content;
+      const content = cutBlock(working, parseBlocks(working)[blockIndex]!);
+
+      sink.workingCopy = content;
+      session = { ...session, workingCopy: content };
+
+      return session;
+    }),
+    sessionRestoreBlock: mock(async (_id: string, baseBlockIndex: number, line?: number) => {
+      const base = session.artifact.content;
+      const working = session.workingCopy ?? base;
+      const content = restoreBlock(
+        base,
+        working,
+        parseBlocks(base)[baseBlockIndex]!,
+        line ?? working.split("\n").length,
+      );
+
+      sink.workingCopy = content;
+      session = { ...session, workingCopy: content };
+      if (content === undefined) delete session.workingCopy;
+
+      return session;
+    }),
+    // the daemon's curation, stood in for: the record carries the decisions and the patch they leave
+    sessionCurate: mock(async (_id: string, rejections: HunkRejection[]) => {
+      const content = rejections.length
+        ? curateDiff(session.artifact.files!, rejections)
+        : undefined;
+
+      sink.workingCopy = content;
+      session = { ...session, workingCopy: content };
+      if (rejections.length) session.curation = rejections;
+      else delete session.curation;
+
+      return session;
+    }),
+    sessionNavigate: unimplemented("sessionNavigate"),
+    sessionBranch: unimplemented("sessionBranch"),
+    sessionSwitch: unimplemented("sessionSwitch"),
+    sessionLabel: unimplemented("sessionLabel"),
+    sessionFork: unimplemented("sessionFork"),
     sessionSetViewed: unimplemented("sessionSetViewed"),
     sessionSetShareId: unimplemented("sessionSetShareId"),
     sessionMergeShared: unimplemented("sessionMergeShared"),
@@ -211,6 +266,23 @@ describe("diff hunk curation", () => {
     expect(controller.curationItems().length).toBe(1);
   });
 
+  test("a second decision before the daemon answers builds on the first", async () => {
+    // Arrange
+    const { controller, client } = await connected(diffSession(FILES));
+
+    // Act - reject, then restore, with no answer in between
+    controller.toggleRejectChange(4);
+    controller.toggleRejectChange(4);
+    await tick();
+
+    // Assert - the second request restores; a stale snapshot would reject again
+    expect(client.sessionCurate).toHaveBeenCalledTimes(2);
+    expect(client.sessionCurate).toHaveBeenNthCalledWith(1, "ses_diff", [
+      { path: "src/store.ts", hunkIndex: 0, changeIndex: 1 },
+    ]);
+    expect(client.sessionCurate).toHaveBeenNthCalledWith(2, "ses_diff", []);
+  });
+
   test("curation is disabled without full file contents", async () => {
     // Arrange - a legacy diff with no artifact.files
     const { controller, sink } = await connected(diffSession(undefined));
@@ -272,4 +344,19 @@ describe("plan cut removals", () => {
     expect(controller.getSnapshot().status).toContain("removal restored");
     expect(sink.workingCopy).toBeUndefined();
   });
+
+  test("a second cut before the daemon answers indexes the already-cut copy", async () => {
+    // Arrange - pristine plan: title(0), first(1), second(2)
+    const { controller, client, sink } = await connected(planSession());
+
+    // Act - cut the first paragraph, then the second, with no answer in between
+    controller.cut(1);
+    controller.cut(2);
+    await tick();
+
+    // Assert - the second paragraph is block 1 once the first is gone
+    expect(client.sessionCutBlock).toHaveBeenNthCalledWith(1, "ses_plan", 1);
+    expect(client.sessionCutBlock).toHaveBeenNthCalledWith(2, "ses_plan", 1);
+    expect(sink.workingCopy).toBe("# Title\n");
+  });
 });