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

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

@@ -8,13 +8,16 @@ import type { SessionClient } from "@cueloop/daemon/client";
 const publishShare = mock(async () => ({ line: "ssh p_abc123xy@cueloop.dev", copied: true }));
 let remote: ReviewSession;
 const pullShare = mock(async () => remote);
-const pushShare = mock(async (_shareId: string, _annotations: Array<Omit<Annotation, "createdAt">>) => {});
+const pushShare = mock(
+  async (_shareId: string, _annotations: Array<Omit<Annotation, "createdAt">>) => {},
+);
 mock.module("./share", () => ({
   publishShare,
   pullShare,
   pushShare,
   shareIdFromLine: (line: string) => line.match(/^ssh (\S+)@/)?.[1],
-  collaboratorAnnotations: (session: ReviewSession) => session.annotations.filter((annotation) => annotation.author),
+  collaboratorAnnotations: (session: ReviewSession) =>
+    session.annotations.filter((annotation) => annotation.author),
 }));
 
 const { createReviewController, SHARE_POLL_MS } = await import("./session-controller");
@@ -35,7 +38,14 @@ function sessionFixture(overrides: Partial<ReviewSession> = {}): ReviewSession {
 }
 
 function annotation(id: string, author: string): Annotation {
-  return { id, kind: "comment", anchor: { quote: "Plan", prefix: "", suffix: "" }, body: "note", author, createdAt: "2026-01-01T00:00:00.000Z" };
+  return {
+    id,
+    kind: "comment",
+    anchor: { quote: "Plan", prefix: "", suffix: "" },
+    body: "note",
+    author,
+    createdAt: "2026-01-01T00:00:00.000Z",
+  };
 }
 
 function fakeClient(session: ReviewSession): SessionClient {
@@ -45,10 +55,13 @@ function fakeClient(session: ReviewSession): SessionClient {
     sessionGet: async () => session,
     sessionList: async () => [session],
     sessionAnnotate: mock(async () => session),
-    sessionSetShareId: mock(async (_id: string, shareId: string) => ((session.shareId = shareId), session)),
+    sessionSetShareId: mock(
+      async (_id: string, shareId: string) => ((session.shareId = shareId), session),
+    ),
     sessionMergeShared: mock(async (_id: string, incoming: { annotations: Annotation[] }) => {
       const known = new Set(session.annotations.map((existing) => existing.id));
-      for (const note of incoming.annotations) if (!known.has(note.id)) session.annotations.push(note);
+      for (const note of incoming.annotations)
+        if (!known.has(note.id)) session.annotations.push(note);
       return session;
     }),
     close: () => {},
@@ -62,7 +75,11 @@ async function connectedController(
   clock?: ManualClock,
 ): Promise<{ controller: ReturnType<typeof createReviewController>; client: SessionClient }> {
   const client = fakeClient(session);
-  const controller = createReviewController({ sessionId: session.id, openClient: async () => client, clock });
+  const controller = createReviewController({
+    sessionId: session.id,
+    openClient: async () => client,
+    clock,
+  });
   controller.connect();
   await tick();
   return { controller, client };
@@ -90,7 +107,10 @@ describe("share", () => {
     await tick();
 
     // Assert
-    expect(controller.getSnapshot().toast).toEqual({ body: "ssh p_abc123xy@cueloop.dev", title: "share link copied" });
+    expect(controller.getSnapshot().toast).toEqual({
+      body: "ssh p_abc123xy@cueloop.dev",
+      title: "share link copied",
+    });
     expect(controller.getSnapshot().status).not.toContain("ssh p_abc123xy@cueloop.dev");
   });
 });
@@ -102,7 +122,9 @@ describe("pullShared", () => {
       annotations: [annotation("a1", "SHA256:mate")],
       participants: [{ id: "SHA256:mate", provider: "ssh", name: "Sam" }],
     });
-    const { controller, client } = await connectedController(sessionFixture({ shareId: "p_abc123xy" }));
+    const { controller, client } = await connectedController(
+      sessionFixture({ shareId: "p_abc123xy" }),
+    );
 
     // Act
     controller.pullShared();
@@ -135,7 +157,9 @@ describe("mirror on annotate", () => {
   test("pushes an edited note up when the plan is shared", async () => {
     // Arrange
     pushShare.mockClear();
-    const { controller } = await connectedController(sessionFixture({ shareId: "p_abc123xy", annotations: [annotation("a1", "SHA256:me")] }));
+    const { controller } = await connectedController(
+      sessionFixture({ shareId: "p_abc123xy", annotations: [annotation("a1", "SHA256:me")] }),
+    );
 
     // Act
     controller.updateAnnotation("a1", "revised body");
@@ -144,13 +168,22 @@ describe("mirror on annotate", () => {
     // Assert
     expect(pushShare).toHaveBeenCalledTimes(1);
     expect(pushShare.mock.calls[0]?.[0]).toBe("p_abc123xy");
-    expect(pushShare.mock.calls[0]?.[1]).toEqual([{ id: "a1", kind: "comment", anchor: { quote: "Plan", prefix: "", suffix: "" }, body: "revised body" }]);
+    expect(pushShare.mock.calls[0]?.[1]).toEqual([
+      {
+        id: "a1",
+        kind: "comment",
+        anchor: { quote: "Plan", prefix: "", suffix: "" },
+        body: "revised body",
+      },
+    ]);
   });
 
   test("does not push when the plan was never shared", async () => {
     // Arrange
     pushShare.mockClear();
-    const { controller } = await connectedController(sessionFixture({ annotations: [annotation("a1", "SHA256:me")] }));
+    const { controller } = await connectedController(
+      sessionFixture({ annotations: [annotation("a1", "SHA256:me")] }),
+    );
 
     // Act
     controller.updateAnnotation("a1", "revised body");
@@ -163,7 +196,9 @@ describe("mirror on annotate", () => {
   test("does not push when the local write is rejected", async () => {
     // Arrange - the daemon write fails (e.g. a resolved session)
     pushShare.mockClear();
-    const { controller, client } = await connectedController(sessionFixture({ shareId: "p_abc123xy", annotations: [annotation("a1", "SHA256:me")] }));
+    const { controller, client } = await connectedController(
+      sessionFixture({ shareId: "p_abc123xy", annotations: [annotation("a1", "SHA256:me")] }),
+    );
     (client.sessionAnnotate as ReturnType<typeof mock>).mockImplementationOnce(async () => {
       throw new Error("session is resolved");
     });
@@ -183,7 +218,10 @@ describe("startSharePoll", () => {
     pullShare.mockClear();
     remote = sessionFixture({ annotations: [] });
     const clock = new ManualClock();
-    const { controller } = await connectedController(sessionFixture({ shareId: "p_abc123xy" }), clock);
+    const { controller } = await connectedController(
+      sessionFixture({ shareId: "p_abc123xy" }),
+      clock,
+    );
 
     // Act - immediate pull
     const stop = controller.startSharePoll();
@@ -213,9 +251,14 @@ describe("startSharePoll", () => {
     pullShare.mockClear();
     remote = sessionFixture({ annotations: [] });
     let release: () => void = () => {};
-    pullShare.mockImplementationOnce(() => new Promise<ReviewSession>((resolve) => (release = () => resolve(remote))));
+    pullShare.mockImplementationOnce(
+      () => new Promise<ReviewSession>((resolve) => (release = () => resolve(remote))),
+    );
     const clock = new ManualClock();
-    const { controller } = await connectedController(sessionFixture({ shareId: "p_abc123xy" }), clock);
+    const { controller } = await connectedController(
+      sessionFixture({ shareId: "p_abc123xy" }),
+      clock,
+    );
 
     // Act - start (pull is in flight), leave, then let the pull settle
     const stop = controller.startSharePoll();
@@ -236,9 +279,14 @@ describe("startSharePoll", () => {
     pullShare.mockClear();
     remote = sessionFixture({ annotations: [] });
     let release: () => void = () => {};
-    pullShare.mockImplementationOnce(() => new Promise<ReviewSession>((resolve) => (release = () => resolve(remote))));
+    pullShare.mockImplementationOnce(
+      () => new Promise<ReviewSession>((resolve) => (release = () => resolve(remote))),
+    );
     const clock = new ManualClock();
-    const { controller } = await connectedController(sessionFixture({ shareId: "p_abc123xy" }), clock);
+    const { controller } = await connectedController(
+      sessionFixture({ shareId: "p_abc123xy" }),
+      clock,
+    );
 
     // Act - run A starts (pull hangs), then run B restarts while A is in flight
     controller.startSharePoll();

package/src/session-controller.ts

@@ -24,13 +24,36 @@ import {
   type VerdictKind,
 } from "@cueloop/schema";
 import { loadBundledExporters, type BundledExporter } from "./integrations";
-import { collaboratorAnnotations, publishShare, pullShare, pushShare, shareIdFromLine } from "./share";
+import {
+  collaboratorAnnotations,
+  publishShare,
+  pullShare,
+  pushShare,
+  shareIdFromLine,
+} from "./share";
 import { buildDisplay, nextWorkBlock, type DisplayBlock } from "./view-plan";
 import { diffRowAnchor, diffRows, type DiffRow } from "./view-diff";
+import {
+  changeRejectionForRow,
+  curateDiff,
+  hunkRejectionForRow,
+  isRowRejected,
+  parseFileDiff,
+  rejectsWholeHunk,
+  sameRejection,
+  type HunkRejection,
+} from "./diff-hunk-curate";
+import type { FileDiffMetadata } from "@pierre/diffs";
 import { firstUnviewedIndex, walkFiles, type WalkFile } from "./walk";
 import { editInEditor } from "./editor";
 import { focusHerdrPane } from "./herdr";
-import { persistAutoClose, persistReviewState, persistReviewWidth, type AutoClose, type CueloopConfig } from "./config";
+import {
+  persistAutoClose,
+  persistReviewState,
+  persistReviewWidth,
+  type AutoClose,
+  type CueloopConfig,
+} from "./config";
 import type { ReviewPanelMode } from "./review-panel";
 
 /**
@@ -50,11 +73,44 @@ export const DEFAULT_AUTO_CLOSE = 5;
 /** How often an open shared plan re-pulls collaborator notes (ADR 0005 stage 2). */
 export const SHARE_POLL_MS = 4000;
 
+/** Shared empty set so "nothing rejected" is a stable identity for renders. */
+const EMPTY_REJECTED_ROWS: Set<number> = new Set();
+
+/** Shared empty list so "nothing curated out" is a stable identity for renders. */
+const EMPTY_CURATION_ITEMS: CurationItem[] = [];
+
+/** Status shown when a curated-out removal (diff rejection or plan cut) is restored. */
+const REMOVAL_RESTORED_STATUS = "removal restored";
+
 export interface ToastState {
   title?: string;
   body: string;
 }
 
+/**
+ * One removed piece projected for the review rail, unified across both review
+ * kinds: a diff hunk/change the owner curated out, or a plan block they cut.
+ * `source` tells restore and reveal which path to take; `preview` is the removed
+ * content (a few lines) the card renders struck through; `revealIndex` is the
+ * diff row (diff) or display block (plan) to scroll to and restore against.
+ */
+export interface CurationItem {
+  id: string;
+  source: "diff" | "plan";
+  preview: string[];
+  revealIndex: number;
+}
+
+/** Stable id for a rejection's rail item: diff:path#hunk#change (or #hunk for a whole hunk). */
+export function curationItemId(rejection: HunkRejection): string {
+  return `diff:${rejection.path}#${rejection.hunkIndex}#${rejection.changeIndex ?? "hunk"}`;
+}
+
+/** Stable id for a plan cut's rail item, keyed on its fixed base-content line range. */
+function planCutId(base: { lineStart: number; lineEnd: number }): string {
+  return `plan:${base.lineStart}-${base.lineEnd}`;
+}
+
 export interface ControllerSnapshot {
   session: ReviewSession | null;
   inbox: ReviewSession[] | null;
@@ -118,13 +174,29 @@ export interface ReviewController {
   setSelfName(name: string): void;
   /** Cut the block under the cursor, or restore a cut one. */
   cut(displayIndex: number): void;
+  /** Toggle rejection of the whole hunk under the diff cursor (owner curation). */
+  toggleRejectHunk(rowIndex: number): void;
+  /** Toggle rejection of the single change under the diff cursor (owner curation). */
+  toggleRejectChange(rowIndex: number): void;
+  /** Rendered row indices dropped by the current reject decisions (for dimming). */
+  rejectedRows(): Set<number>;
+  /** The curated-out rejections as rail items, in the order they were rejected. */
+  curationItems(): CurationItem[];
+  /** Undo one curation item by id: drop the rejection and recompute the working copy. */
+  restoreCuration(id: string): void;
   /** The $EDITOR hand-off on the working copy. */
   edit(): void;
   /**
    * Anchor and store an annotation; both plan and diff anchor constructions.
    * Returns the minted annotation id so the view can select the new card.
    */
-  annotate(kind: "comment" | "suggestion", displayIndex: number, start: number, end: number, body: string): string | undefined;
+  annotate(
+    kind: "comment",
+    displayIndex: number,
+    start: number,
+    end: number,
+    body: string,
+  ): string | undefined;
   /** Rewrite a stored annotation's body in place (the rail-card edit). */
   updateAnnotation(id: string, body: string): void;
   removeAnnotation(id: string): void;
@@ -185,11 +257,20 @@ class Controller implements ReviewController {
   private shareRun: object | null = null;
   /** Projections keyed by session identity so renders reuse one computation. */
   private derivedFor: ReviewSession | null = null;
-  private derived: { display: DisplayBlock[]; rows: DiffRow[]; files: WalkFile[] } = {
+  private derived: {
+    display: DisplayBlock[];
+    rows: DiffRow[];
+    files: WalkFile[];
+    /** Per-path parsed diff models, for hunk curation; empty when files absent. */
+    models: Map<string, FileDiffMetadata>;
+  } = {
     display: [],
     rows: [],
     files: [],
+    models: new Map(),
   };
+  /** The owner's per-hunk/change reject decisions for the open diff session. */
+  private rejections: HunkRejection[] = [];
 
   constructor(private readonly options: ReviewControllerOptions) {
     this.readOnly = options.readOnly ?? false;
@@ -211,7 +292,9 @@ class Controller implements ReviewController {
   connect(): void {
     void (async () => {
       try {
-        const openClient = this.options.openClient ?? (() => DaemonClient.connect({ home: this.options.home, autostart: true }));
+        const openClient =
+          this.options.openClient ??
+          (() => DaemonClient.connect({ home: this.options.home, autostart: true }));
         const client = await openClient();
         if (this.closed) return void client.close();
         this.client = client;
@@ -270,11 +353,15 @@ class Controller implements ReviewController {
     const session = this.snapshot.session;
     if (this.derivedFor === session) return;
     this.derivedFor = session;
-    const rows = session && session.artifact.type === "diff" ? diffRows(session.artifact.content) : [];
+    const rows =
+      session && session.artifact.type === "diff" ? diffRows(session.artifact.content) : [];
+    const models = new Map<string, FileDiffMetadata>();
+    for (const file of session?.artifact.files ?? []) models.set(file.path, parseFileDiff(file));
     this.derived = {
       display: session ? buildDisplay(session.artifact.content, session.workingCopy) : [],
       rows,
       files: walkFiles(rows),
+      models,
     };
   }
 
@@ -319,14 +406,17 @@ class Controller implements ReviewController {
 
   /** Optimistic apply: the daemon response is the next session snapshot. */
   private apply(mutation: Promise<ReviewSession>): void {
-    mutation.then((session) => this.update({ session })).catch((error: unknown) =>
-      this.setStatus(String(error instanceof Error ? error.message : error)),
-    );
+    mutation
+      .then((session) => this.update({ session }))
+      .catch((error: unknown) =>
+        this.setStatus(String(error instanceof Error ? error.message : error)),
+      );
   }
 
   // ── verbs ───────────────────────────────────
   open(id: string): void {
     this.locallyViewed.clear();
+    this.rejections = [];
     const cached = this.snapshot.inbox?.find((candidate) => candidate.id === id);
     if (cached) this.update({ session: cached });
     else void this.refreshSession(id);
@@ -336,7 +426,9 @@ class Controller implements ReviewController {
     this.client
       ?.sessionDelete(id)
       .then(() => this.setStatus("plan deleted"))
-      .catch((error: unknown) => this.setStatus(`delete failed: ${error instanceof Error ? error.message : String(error)}`));
+      .catch((error: unknown) =>
+        this.setStatus(`delete failed: ${error instanceof Error ? error.message : String(error)}`),
+      );
   }
 
   setSelfName(name: string): void {
@@ -352,18 +444,185 @@ class Controller implements ReviewController {
     if (!block) return;
     const working = this.working();
     if (block.type === "del") {
-      const line = restoreLine(nextWorkBlock(this.display(), displayIndex), working.split("\n").length);
-      // restoreBlock returns undefined when the block structure round-trips
-      // to the submitted revision - the working copy is gone
-      const restored = restoreBlock(session.artifact.content, working, block.base!, line);
-      this.setWorkingCopy(restored);
-      this.setStatus("cut restored");
+      this.restoreDelBlock(block, displayIndex);
     } else if (block.work) {
       this.setWorkingCopy(cutBlock(working, block.work));
       this.setStatus("block cut - it serializes into the diff");
     }
   }
 
+  /** Re-insert a cut plan block at the next surviving block's line (Cut toggle + rail undo). */
+  private restoreDelBlock(block: DisplayBlock, displayIndex: number): void {
+    const session = this.snapshot.session;
+    if (!session || !block.base) return;
+    const working = this.working();
+    const line = restoreLine(
+      nextWorkBlock(this.display(), displayIndex),
+      working.split("\n").length,
+    );
+    // restoreBlock returns undefined when the block structure round-trips to the
+    // submitted revision - the working copy is back to pristine and is dropped
+    const restored = restoreBlock(session.artifact.content, working, block.base, line);
+    this.setWorkingCopy(restored);
+    this.setStatus(REMOVAL_RESTORED_STATUS);
+  }
+
+  // ── diff hunk curation ──────────────────────
+  /** The parsed model and row for a curation action, or null with a status set. */
+  private curationRow(rowIndex: number): { row: DiffRow; model: FileDiffMetadata } | null {
+    const session = this.snapshot.session;
+    if (!session || session.status === "resolved") return null;
+    if (!session.artifact.files) {
+      this.setStatus("hunk curation needs full file contents (PR diffs cannot be curated)");
+      return null;
+    }
+    const row = this.rows()[rowIndex];
+    if (!row || row.kind === "file" || row.kind === "hunk") {
+      this.setStatus("move to a code line to curate");
+      return null;
+    }
+    const model = this.derived.models.get(row.file);
+    if (!model) return null;
+    return { row, model };
+  }
+
+  toggleRejectHunk(rowIndex: number): void {
+    const located = this.curationRow(rowIndex);
+    if (!located) return;
+    const target = hunkRejectionForRow(located.row.file, located.model, located.row);
+    if (!target) return this.setStatus("no hunk under the cursor");
+    const wholeHunk = (rejection: HunkRejection): boolean => rejectsWholeHunk(rejection, target);
+    if (this.rejections.some(wholeHunk)) {
+      this.rejections = this.rejections.filter((rejection) => !wholeHunk(rejection));
+      this.setStatus("hunk restored");
+    } else {
+      // a whole-hunk reject supersedes any change-level rejects inside it
+      this.rejections = this.rejections.filter(
+        (rejection) =>
+          !(rejection.path === target.path && rejection.hunkIndex === target.hunkIndex),
+      );
+      this.rejections.push(target);
+      this.setStatus("hunk rejected - dropped from the working copy");
+    }
+    this.recomputeCuration();
+  }
+
+  toggleRejectChange(rowIndex: number): void {
+    const located = this.curationRow(rowIndex);
+    if (!located) return;
+    if (located.row.kind !== "add" && located.row.kind !== "del")
+      return this.setStatus("move to a changed line to reject a change");
+    const target = changeRejectionForRow(located.row.file, located.model, located.row);
+    if (!target) return this.setStatus("no change under the cursor");
+    const wholeCovers = this.rejections.some((rejection) => rejectsWholeHunk(rejection, target));
+    if (wholeCovers) return this.setStatus("the whole hunk is rejected - restore it first");
+    if (this.rejections.some((rejection) => sameRejection(rejection, target))) {
+      this.rejections = this.rejections.filter((rejection) => !sameRejection(rejection, target));
+      this.setStatus("change restored");
+    } else {
+      this.rejections.push(target);
+      this.setStatus("change rejected - dropped from the working copy");
+    }
+    this.recomputeCuration();
+  }
+
+  /** Recompute the curated patch and push it as the working copy (or clear it). */
+  private recomputeCuration(): void {
+    const files = this.snapshot.session?.artifact.files;
+    if (!files) return;
+    // no decisions left = the working copy reverts to the full submitted diff
+    this.setWorkingCopy(this.rejections.length ? curateDiff(files, this.rejections) : undefined);
+    // dimming reads `rejections` directly; a bare update forces the re-read
+    this.update({});
+  }
+
+  rejectedRows(): Set<number> {
+    this.ensureDerived();
+    if (!this.rejections.length) return EMPTY_REJECTED_ROWS;
+    const rejected = new Set<number>();
+    this.derived.rows.forEach((row, index) => {
+      const model = this.derived.models.get(row.file);
+      if (model && isRowRejected(row.file, model, row, this.rejections)) rejected.add(index);
+    });
+    return rejected;
+  }
+
+  curationItems(): CurationItem[] {
+    this.ensureDerived();
+    const session = this.snapshot.session;
+    if (!session) return EMPTY_CURATION_ITEMS;
+    return session.artifact.type === "diff" ? this.diffCurationItems() : this.planCurationItems();
+  }
+
+  restoreCuration(id: string): void {
+    // diff rejections drop from the reject list; a plan cut re-inserts its block
+    if (id.startsWith("diff:")) {
+      const kept = this.rejections.filter((rejection) => curationItemId(rejection) !== id);
+      if (kept.length === this.rejections.length) return;
+      this.rejections = kept;
+      this.setStatus(REMOVAL_RESTORED_STATUS);
+      this.recomputeCuration();
+      return;
+    }
+    const display = this.display();
+    const displayIndex = display.findIndex(
+      (block) => block.type === "del" && block.base && planCutId(block.base) === id,
+    );
+    if (displayIndex !== -1) this.restoreDelBlock(display[displayIndex]!, displayIndex);
+  }
+
+  /** The curated-out diff rejections as removal cards (newest decisions last). */
+  private diffCurationItems(): CurationItem[] {
+    if (!this.rejections.length) return EMPTY_CURATION_ITEMS;
+    const items: CurationItem[] = [];
+    for (const rejection of this.rejections) {
+      const rows = this.rowsForRejection(rejection);
+      const firstRow = rows[0];
+      items.push({
+        id: curationItemId(rejection),
+        source: "diff",
+        preview: rows.map(
+          (row) => `${row.kind === "add" ? "+" : "-"} ${row.text.replace(/\n$/, "")}`,
+        ),
+        revealIndex: firstRow ? this.derived.rows.indexOf(firstRow) : 0,
+      });
+    }
+    return items;
+  }
+
+  /** The cut plan blocks as removal cards, in document order. */
+  private planCurationItems(): CurationItem[] {
+    const items: CurationItem[] = [];
+    this.derived.display.forEach((block, displayIndex) => {
+      if (block.type !== "del" || !block.base) return;
+      items.push({
+        id: planCutId(block.base),
+        source: "plan",
+        preview: block.base.text.split("\n"),
+        revealIndex: displayIndex,
+      });
+    });
+    return items.length ? items : EMPTY_CURATION_ITEMS;
+  }
+
+  /** The change/deletion rows a rejection covers, for its preview and reveal row. */
+  private rowsForRejection(rejection: HunkRejection): DiffRow[] {
+    const model = this.derived.models.get(rejection.path);
+    if (!model) return [];
+    const rows: DiffRow[] = [];
+    for (const row of this.derived.rows) {
+      if (row.file !== rejection.path || (row.kind !== "add" && row.kind !== "del")) continue;
+      if (rejection.changeIndex === undefined) {
+        const target = hunkRejectionForRow(rejection.path, model, row);
+        if (target && target.hunkIndex === rejection.hunkIndex) rows.push(row);
+      } else {
+        const target = changeRejectionForRow(rejection.path, model, row);
+        if (target && sameRejection(target, rejection)) rows.push(row);
+      }
+    }
+    return rows;
+  }
+
   edit(): void {
     const session = this.snapshot.session;
     if (!session || session.status === "resolved") return;
@@ -394,7 +653,7 @@ class Controller implements ReviewController {
   }
 
   annotate(
-    kind: "comment" | "suggestion",
+    kind: "comment",
     displayIndex: number,
     start: number,
     end: number,
@@ -408,14 +667,15 @@ class Controller implements ReviewController {
     } else {
       const display = this.display();
       const workBlocks = display.filter((entry) => entry.work).map((entry) => entry.work!);
-      const workBlockIndex = display.slice(0, displayIndex + 1).filter((entry) => entry.work).length - 1;
+      const workBlockIndex =
+        display.slice(0, displayIndex + 1).filter((entry) => entry.work).length - 1;
       anchor = makeAnchor(workBlocks, workBlockIndex, start, end);
     }
     const wire = { id: newAnnotationId(), kind, anchor, body };
     const persisted = this.client!.sessionAnnotate(session.id, wire);
     this.apply(persisted);
     this.mirrorAnnotation(persisted, wire);
-    this.setStatus(kind === "suggestion" ? "suggestion added - the agent applies it" : "comment added");
+    this.setStatus("comment added");
     return wire.id;
   }
 
@@ -433,7 +693,10 @@ class Controller implements ReviewController {
   }
 
   // push only after the local write lands, so a rejected write never leaks to the share
-  private mirrorAnnotation(persisted: Promise<ReviewSession>, annotation: Omit<Annotation, "createdAt">): void {
+  private mirrorAnnotation(
+    persisted: Promise<ReviewSession>,
+    annotation: Omit<Annotation, "createdAt">,
+  ): void {
     const shareId = this.snapshot.session?.shareId;
     if (!shareId) return;
     void persisted.then(() => pushShare(shareId, [annotation])).catch(() => {});
@@ -509,7 +772,11 @@ class Controller implements ReviewController {
         for (const exporter of this.exporters) {
           if (!exporter.runsOn(verdict)) continue;
           void exporter.run(resolved).then((exportResult) => {
-            this.setStatus(exportResult.success && exportResult.path ? `exported to ${exportResult.path}` : `export failed: ${exportResult.error ?? "unknown"}`);
+            this.setStatus(
+              exportResult.success && exportResult.path
+                ? `exported to ${exportResult.path}`
+                : `export failed: ${exportResult.error ?? "unknown"}`,
+            );
           });
         }
         // Hand the reviewer back to the agent. The default is a visible
@@ -520,7 +787,9 @@ class Controller implements ReviewController {
         else if (typeof delay === "number") this.startCounting(delay);
         else this.startCounting(DEFAULT_AUTO_CLOSE);
       })
-      .catch((error: unknown) => this.setStatus(String(error instanceof Error ? error.message : error)));
+      .catch((error: unknown) =>
+        this.setStatus(String(error instanceof Error ? error.message : error)),
+      );
   }
 
   share(): void {
@@ -532,10 +801,12 @@ class Controller implements ReviewController {
         // Stamp the id back so a later pull knows which share to collect from.
         const shareId = shareIdFromLine(line);
         if (shareId && this.client) await this.client.sessionSetShareId(session.id, shareId);
-        this.setStatus(copied ? "✓ share link copied" : "share link ready");
+        this.setStatus("");
         this.showToast(line, copied ? "share link copied" : "share link");
       })
-      .catch((error: unknown) => this.setStatus(`share failed: ${error instanceof Error ? error.message : String(error)}`));
+      .catch((error: unknown) =>
+        this.setStatus(`share failed: ${error instanceof Error ? error.message : String(error)}`),
+      );
   }
 
   /**
@@ -550,7 +821,10 @@ class Controller implements ReviewController {
     const client = this.client;
     return pullShare(session.shareId)
       .then((remote) =>
-        client.sessionMergeShared(session.id, { annotations: collaboratorAnnotations(remote), participants: remote.participants }),
+        client.sessionMergeShared(session.id, {
+          annotations: collaboratorAnnotations(remote),
+          participants: remote.participants,
+        }),
       )
       .then(() => {})
       .catch(() => {});
@@ -568,7 +842,8 @@ class Controller implements ReviewController {
     this.shareRun = run;
     const tick = (): void => {
       void this.pullShared().finally(() => {
-        if (this.shareRun === run && !this.closed) this.sharePoll = this.clock.setTimeout(tick, SHARE_POLL_MS);
+        if (this.shareRun === run && !this.closed)
+          this.sharePoll = this.clock.setTimeout(tick, SHARE_POLL_MS);
       });
     };
     tick();