@cueloop/client 0.1.0-alpha.63 → 0.1.0-alpha.65

package/src/intent-dispatch.test.ts

@@ -6,54 +6,114 @@
  */
 
 import { describe, expect, mock, test } from "bun:test";
-import type { ReviewSession } from "@cueloop/schema";
+import type { SetStateAction } from "react";
+import { SCHEMA_VERSION, type Annotation, type ReviewSession } from "@cueloop/schema";
 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 { text, kind: "text", work: true } as unknown as DisplayBlock;
+  return { type: "same", kind: "p", work: { kind: "p", text, lineStart: 0, lineEnd: 0 } };
 }
 
-function sessionWith(annotationIds: string[]): ReviewSession {
+function annotation(id: string, overrides: Partial<Annotation> = {}): Annotation {
   return {
-    annotations: annotationIds.map((id) => ({ id })),
-    workingCopy: undefined,
-  } as unknown as ReviewSession;
+    id,
+    kind: "comment",
+    anchor: { quote: "", prefix: "", suffix: "" },
+    body: "",
+    createdAt: "2026-01-01T00:00:00.000Z",
+    ...overrides,
+  };
+}
+
+function sessionWith(
+  annotations: Annotation[],
+  overrides: Partial<ReviewSession> = {},
+): ReviewSession {
+  return {
+    schemaVersion: SCHEMA_VERSION,
+    id: "ses_1",
+    workspace: { repoRoot: "/repo", branch: "main" },
+    artifact: { type: "plan", content: "# Plan\n", meta: {} },
+    revisions: [],
+    annotations,
+    verdict: null,
+    status: "pending",
+    createdAt: "2026-01-01T00:00:00.000Z",
+    ...overrides,
+  };
 }
 
-/** A controller where every verb is a mock; annotate returns undefined by default. */
-function baseController() {
+const EMPTY_SNAPSHOT: ControllerSnapshot = {
+  session: null,
+  inbox: null,
+  status: "",
+  toast: null,
+  error: null,
+  completion: { phase: "idle" },
+  editOrphanCount: 0,
+  walk: null,
+};
+
+/** A controller where every primitive is a mock; annotate returns undefined by default. */
+function baseController(): ReviewController {
   return {
+    readOnly: false,
+    subscribe: mock(() => () => {}),
+    getSnapshot: mock(() => EMPTY_SNAPSHOT),
+    connect: mock(),
+    close: mock(),
+    applyConfig: mock(),
     setStatus: mock(),
+    showToast: mock(),
+    dismissToast: mock(),
+    display: mock(() => []),
+    rows: mock(() => []),
+    files: mock(() => []),
+    working: mock(() => ""),
     open: mock(),
     deleteSession: mock(),
     setSelfName: mock(),
     cut: mock(),
+    toggleRejectHunk: mock(),
+    toggleRejectChange: mock(),
+    rejectedRows: mock(() => new Set<number>()),
     curationItems: mock(() => []),
     restoreCuration: mock(),
-    annotate: mock(),
-    annotatePrototype: mock(),
+    edit: mock(),
+    annotate: mock(() => undefined),
+    reply: mock(() => undefined),
+    annotatePrototype: mock(() => undefined),
     updateAnnotation: mock(),
     removeAnnotation: mock(),
+    setWorkingCopy: mock(),
     walkStart: mock(),
     walkForward: mock(),
     walkBack: mock(),
     walkLeave: mock(),
     submit: mock(),
     share: mock(),
+    treeRows: mock(() => []),
+    goToEntry: mock(),
+    branch: mock(),
+    labelTip: mock(),
+    fork: mock(),
+    forkAndShare: mock(),
+    pullShared: mock(() => Promise.resolve()),
+    startShareSync: mock(() => () => {}),
     finishReview: mock(),
-    optInAutoClose: mock(),
     dismissCompletion: mock(),
+    optInAutoClose: 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"],
+    controller: baseController(),
     onExit: mock(),
     isDiff: false,
     display: [],
@@ -68,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(),
@@ -90,20 +152,24 @@ function makeDeps(overrides: Partial<IntentDispatchDeps> = {}): IntentDispatchDe
   };
 }
 
+function isUpdater(action: SetStateAction<number>): action is (current: number) => number {
+  return typeof action === "function";
+}
+
 describe("move", () => {
   test("down clamps at the last row and up clamps at the first", () => {
     // Arrange
-    const deps = makeDeps({ display: [block("a"), block("b"), block("c")] });
+    const setCursor = mock((_action: SetStateAction<number>) => {});
+    const deps = makeDeps({ display: [block("a"), block("b"), block("c")], setCursor });
     const dispatch = createIntentDispatch(deps);
 
     // Act
     dispatch({ type: "move", to: "down" });
 
     // Assert
-    const advance = (deps.setCursor as ReturnType<typeof mock>).mock.calls[0]![0] as (
-      current: number,
-    ) => number;
+    const advance = setCursor.mock.calls[0]![0];
 
+    if (!isUpdater(advance)) throw new Error("expected setCursor to receive an updater");
     expect(advance(2)).toBe(2); // already at the end, stays
     expect(advance(0)).toBe(1);
   });
@@ -124,7 +190,10 @@ describe("move", () => {
 describe("annotation navigation", () => {
   test("nextAnnotation wraps from the last annotation back to the first", () => {
     // Arrange
-    const deps = makeDeps({ session: sessionWith(["a1", "a2", "a3"]), focusedAnnotationId: "a3" });
+    const deps = makeDeps({
+      session: sessionWith([annotation("a1"), annotation("a2"), annotation("a3")]),
+      focusedAnnotationId: "a3",
+    });
     const dispatch = createIntentDispatch(deps);
 
     // Act
@@ -136,7 +205,10 @@ describe("annotation navigation", () => {
 
   test("prevAnnotation wraps from the first annotation to the last", () => {
     // Arrange
-    const deps = makeDeps({ session: sessionWith(["a1", "a2", "a3"]), focusedAnnotationId: "a1" });
+    const deps = makeDeps({
+      session: sessionWith([annotation("a1"), annotation("a2"), annotation("a3")]),
+      focusedAnnotationId: "a1",
+    });
     const dispatch = createIntentDispatch(deps);
 
     // Act
@@ -148,12 +220,11 @@ 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",
-    };
+    const session = sessionWith([
+      annotation("a1"),
+      annotation("a2", { resolution: { revision: 2, source: "agent" } }),
+      annotation("a3"),
+    ]);
     const deps = makeDeps({ session, focusedAnnotationId: "a1" });
     const dispatch = createIntentDispatch(deps);
 
@@ -233,7 +304,7 @@ describe("marker-actions popover", () => {
       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"],
+      controller: { ...baseController(), annotate },
     });
     const dispatch = createIntentDispatch(deps);
 
@@ -253,7 +324,7 @@ describe("marker-actions popover", () => {
       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"],
+      controller: { ...baseController(), annotate },
     });
     const dispatch = createIntentDispatch(deps);
 
@@ -320,28 +391,15 @@ 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,
-    },
+  const items: CurationItem[] = [
+    { id: "diff:f#0#hunk", source: "diff", preview: [], revealIndex: 1 },
+    { id: "diff:f#1#2", source: "diff", 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 controller = { ...baseController(), curationItems: mock(() => items) };
+    const deps = makeDeps({ selectedCurationId: "diff:f#1#2", controller });
     const dispatch = createIntentDispatch(deps);
 
     // Act
@@ -354,9 +412,8 @@ describe("restoreCuration", () => {
 
   test("with nothing selected, undoes the last removal", () => {
     // Arrange
-    const deps = makeDeps({ selectedCurationId: undefined });
-
-    (deps.controller.curationItems as ReturnType<typeof mock>).mockReturnValue(items);
+    const controller = { ...baseController(), curationItems: mock(() => items) };
+    const deps = makeDeps({ selectedCurationId: undefined, controller });
     const dispatch = createIntentDispatch(deps);
 
     // Act
@@ -369,8 +426,6 @@ describe("restoreCuration", () => {
   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
@@ -398,7 +453,9 @@ describe("exit", () => {
 describe("inbox delete", () => {
   test("requestDeleteSession opens the confirm on the cursor row", () => {
     // Arrange
-    const inbox = [{ id: "ses_1", artifact: { meta: { title: "Plan A" } } }] as never;
+    const inbox = [
+      sessionWith([], { artifact: { type: "plan", content: "", meta: { title: "Plan A" } } }),
+    ];
     const deps = makeDeps({ inbox, inboxCursor: 0 });
 
     // Act
@@ -428,7 +485,7 @@ describe("inbox delete", () => {
 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 session = sessionWith([annotation("a1", { author: "SHA256:x" })]);
     const deps = makeDeps({
       session,
       focusedAnnotationId: "a1",
@@ -448,7 +505,7 @@ describe("rename author", () => {
 
   test("openRename on your own note does nothing but explain", () => {
     // Arrange
-    const session = { annotations: [{ id: "a1" }] } as never;
+    const session = sessionWith([annotation("a1")]);
     const deps = makeDeps({ session, focusedAnnotationId: "a1" });
 
     // Act
@@ -497,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,9 +527,71 @@ function handleResizeReviewPanel(
   deps.controller.saveReviewPanel({ width: next });
 }
 
-const intentHandlers: {
+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;
-} = {
+};
+
+const intentHandlers: IntentHandlers = {
   exit: handleExit,
   status: handleStatus,
   move: handleMove,
@@ -570,16 +633,23 @@ const 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"]>(
+  intent: IntentOfType<Kind>,
+  deps: IntentDispatchDeps,
+): void {
+  intentHandlers[intent.type](intent, deps);
+}
+
 /** Build the intent handler for one render from its dependency bag. */
 export function createIntentDispatch(deps: IntentDispatchDeps): (intent: Intent) => void {
-  return (intent: Intent): void => {
-    const handler = intentHandlers[intent.type] as (
-      intent: Intent,
-      deps: IntentDispatchDeps,
-    ) => void;
-
-    handler(intent, deps);
-  };
+  return (intent: Intent): void => dispatchIntent(intent, deps);
 }

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 });