@cueloop/client 0.1.0-alpha.76 → 0.1.0-alpha.78

package/src/thread-controller.derivation.test.ts

@@ -0,0 +1,62 @@
+import { describe, expect, test } from "bun:test";
+import { SCHEMA_VERSION, type Annotation, type Thread } from "@cueloop/schema";
+import { sameDerivationInputs } from "./thread-controller";
+
+function threadFixture(overrides: Partial<Thread> = {}): Thread {
+  return {
+    schemaVersion: SCHEMA_VERSION,
+    id: "ses_1",
+    workspace: { repoRoot: "/repo", branch: "main" },
+    artifact: { type: "plan", content: "# Plan\n\nShip it.\n", meta: {} },
+    revisions: [
+      { revision: 1, content: "# Plan\n\nShip it.\n", submittedAt: "2026-01-01T00:00:00.000Z" },
+    ],
+    annotations: [],
+    verdict: null,
+    status: "pending",
+    createdAt: "2026-01-01T00:00:00.000Z",
+    ...overrides,
+  };
+}
+
+const annotation: Annotation = {
+  id: "ann_1",
+  kind: "comment",
+  anchor: { quote: "Ship it.", prefix: "", suffix: "" },
+  body: "nit",
+  createdAt: "2026-01-01T00:00:00.000Z",
+};
+
+describe("sameDerivationInputs", () => {
+  test("an annotation-only update reuses the projection (a fresh record, identical inputs)", () => {
+    // Arrange - the daemon re-serializes the whole thread on any change, so the record is all-new
+    const before = threadFixture();
+    const after = threadFixture({ annotations: [annotation] });
+
+    // Assert - the artifact and working copy are unchanged, so the projection can be reused
+    expect(sameDerivationInputs(before, after)).toBe(true);
+  });
+
+  test("a content edit forces a re-derivation", () => {
+    const before = threadFixture();
+    const after = threadFixture({
+      artifact: { type: "plan", content: "# Plan\n\nShip it soon.\n", meta: {} },
+    });
+
+    expect(sameDerivationInputs(before, after)).toBe(false);
+  });
+
+  test("a working-copy change forces a re-derivation", () => {
+    const before = threadFixture();
+    const after = threadFixture({ workingCopy: "# Plan\n\nShip it.\n\nedited\n" });
+
+    expect(sameDerivationInputs(before, after)).toBe(false);
+  });
+
+  test("a different thread is never a reuse", () => {
+    const before = threadFixture();
+    const after = threadFixture({ id: "ses_2" });
+
+    expect(sameDerivationInputs(before, after)).toBe(false);
+  });
+});

package/src/thread-controller.live-diff.test.ts

@@ -73,6 +73,7 @@ function fakeClient(session: Thread): SessionClient {
     sessionCutBlock: unimplemented("sessionCutBlock"),
     sessionRestoreBlock: unimplemented("sessionRestoreBlock"),
     sessionCurate: unimplemented("sessionCurate"),
+    sessionSetAccess: unimplemented("sessionSetAccess"),
     sessionNavigate: unimplemented("sessionNavigate"),
     sessionBranch: unimplemented("sessionBranch"),
     sessionSwitch: unimplemented("sessionSwitch"),

package/src/thread-controller.optimistic.test.ts

@@ -0,0 +1,69 @@
+import { describe, expect, test } from "bun:test";
+import { SCHEMA_VERSION, type Annotation, type Thread } from "@cueloop/schema";
+import { withAnnotationUpserted } from "./thread-controller";
+
+function threadFixture(annotations: Annotation[] = []): Thread {
+  return {
+    schemaVersion: SCHEMA_VERSION,
+    id: "ses_1",
+    workspace: { repoRoot: "/repo", branch: "main" },
+    artifact: { type: "plan", content: "# Plan\n\nShip it.\n", meta: {} },
+    revisions: [
+      { revision: 1, content: "# Plan\n\nShip it.\n", submittedAt: "2026-01-01T00:00:00.000Z" },
+    ],
+    annotations,
+    verdict: null,
+    status: "pending",
+    createdAt: "2026-01-01T00:00:00.000Z",
+  };
+}
+
+const existing: Annotation = {
+  id: "ann_1",
+  kind: "comment",
+  anchor: { quote: "Ship it.", prefix: "", suffix: "" },
+  body: "first",
+  createdAt: "2026-01-01T00:00:00.000Z",
+};
+
+describe("withAnnotationUpserted", () => {
+  test("a new comment is appended so it paints immediately", () => {
+    // Arrange
+    const session = threadFixture([existing]);
+    const wire = { id: "ann_2", kind: "comment", anchor: existing.anchor, body: "second" };
+
+    // Act
+    const next = withAnnotationUpserted(session, wire);
+
+    // Assert
+    expect(next.annotations.map((entry) => entry.id)).toEqual(["ann_1", "ann_2"]);
+    expect(next.annotations[1]!.body).toBe("second");
+    expect(next.annotations[1]!.createdAt).not.toBe("");
+  });
+
+  test("an edit replaces the note in place and keeps its timestamp", () => {
+    // Arrange
+    const session = threadFixture([existing]);
+    const wire = { id: "ann_1", kind: "comment", anchor: existing.anchor, body: "edited" };
+
+    // Act
+    const next = withAnnotationUpserted(session, wire);
+
+    // Assert - same position, same createdAt, new body (no reorder or timestamp flash)
+    expect(next.annotations.map((entry) => entry.id)).toEqual(["ann_1"]);
+    expect(next.annotations[0]!.body).toBe("edited");
+    expect(next.annotations[0]!.createdAt).toBe(existing.createdAt);
+  });
+
+  test("the input session is not mutated", () => {
+    // Arrange
+    const session = threadFixture([existing]);
+    const wire = { id: "ann_2", kind: "comment", anchor: existing.anchor, body: "second" };
+
+    // Act
+    withAnnotationUpserted(session, wire);
+
+    // Assert
+    expect(session.annotations).toHaveLength(1);
+  });
+});

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

@@ -1,6 +1,6 @@
 import { beforeEach, describe, expect, mock, test, type Mock } from "bun:test";
 import { ManualClock } from "@opentui/core/testing";
-import { SCHEMA_VERSION, type Annotation, type Thread } from "@cueloop/schema";
+import { SCHEMA_VERSION, type Annotation, type ShareAccess, type Thread } from "@cueloop/schema";
 import type { SessionClient } from "@cueloop/daemon/client";
 import {
   createReviewController,
@@ -14,7 +14,11 @@ const publishShare = mock(async () => ({ line: "ssh p_abc123xy@cueloop.dev", cop
 let remote: Thread;
 const pullShare = mock(async () => remote);
 const pushShare = mock(
-  async (_shareId: string, _annotations: Array<Omit<Annotation, "createdAt">>) => {},
+  async (
+    _shareId: string,
+    _annotations: Array<Omit<Annotation, "createdAt">>,
+    _access?: ShareAccess,
+  ) => {},
 );
 
 const shareTransport: ShareTransport = {
@@ -73,6 +77,7 @@ function fakeClient(session: Thread): FakeSessionClient {
     sessionCutBlock: unimplemented("sessionCutBlock"),
     sessionRestoreBlock: unimplemented("sessionRestoreBlock"),
     sessionCurate: unimplemented("sessionCurate"),
+    sessionSetAccess: mock(async () => session),
     sessionNavigate: unimplemented("sessionNavigate"),
     sessionBranch: unimplemented("sessionBranch"),
     sessionSwitch: unimplemented("sessionSwitch"),
@@ -149,6 +154,35 @@ describe("share", () => {
   });
 });
 
+describe("setShareAccess", () => {
+  test("pushes the allowlist up to the gateway when the plan is already shared", async () => {
+    // Arrange
+    pushShare.mockClear();
+    const { controller } = await connectedController(sessionFixture({ shareId: "p_abc123xy" }));
+
+    // Act
+    controller.setShareAccess(["octocat"]);
+    await tick();
+
+    // Assert - the existing link must enforce the new access, so it rides the push
+    expect(pushShare.mock.calls[0]?.[0]).toBe("p_abc123xy");
+    expect(pushShare.mock.calls[0]?.[2]).toEqual({ githubLogins: ["octocat"] });
+  });
+
+  test("does not push when the plan was never shared", async () => {
+    // Arrange
+    pushShare.mockClear();
+    const { controller } = await connectedController(sessionFixture());
+
+    // Act
+    controller.setShareAccess(["octocat"]);
+    await tick();
+
+    // Assert
+    expect(pushShare).not.toHaveBeenCalled();
+  });
+});
+
 describe("pullShared", () => {
   test("unions collaborator notes and identities in when the plan was shared", async () => {
     // Arrange

package/src/thread-controller.switch-cache.test.ts

@@ -0,0 +1,146 @@
+import { describe, expect, mock, test } from "bun:test";
+import {
+  SCHEMA_VERSION,
+  type DiffFileContents,
+  type HunkRejection,
+  type Thread,
+} from "@cueloop/schema";
+import { curateDiff } from "@cueloop/daemon/curate";
+import type { SessionClient } from "@cueloop/daemon/client";
+import { createReviewController } from "./thread-controller";
+
+const PATCH_A = `diff --git a/src/a.ts b/src/a.ts
+index 111..222 100644
+--- a/src/a.ts
++++ b/src/a.ts
+@@ -1,3 +1,3 @@
+ export class A {
+-  value = 1;
++  value = 2;
+ }
+`;
+
+const PATCH_B = `diff --git a/src/b.ts b/src/b.ts
+index 333..444 100644
+--- a/src/b.ts
++++ b/src/b.ts
+@@ -1,3 +1,3 @@
+ export class B {
+-  flag = false;
++  flag = true;
+ }
+`;
+
+function diffSession(id: string, patch: string, files: DiffFileContents[]): Thread {
+  return {
+    schemaVersion: SCHEMA_VERSION,
+    id,
+    workspace: { repoRoot: "/repo", branch: "main" },
+    artifact: { type: "diff", content: patch, meta: { title: id }, files },
+    revisions: [{ revision: 1, content: patch, submittedAt: "2026-01-01T00:00:00.000Z" }],
+    annotations: [],
+    verdict: null,
+    status: "pending",
+    createdAt: "2026-01-01T00:00:00.000Z",
+  };
+}
+
+const FILES_A: DiffFileContents[] = [
+  {
+    path: "src/a.ts",
+    oldContents: "export class A {\n  value = 1;\n}\n",
+    newContents: "export class A {\n  value = 2;\n}\n",
+    status: "modified",
+  },
+];
+const FILES_B: DiffFileContents[] = [
+  {
+    path: "src/b.ts",
+    oldContents: "export class B {\n  flag = false;\n}\n",
+    newContents: "export class B {\n  flag = true;\n}\n",
+    status: "modified",
+  },
+];
+
+const unimplemented = (member: string) => () =>
+  Promise.reject(new Error(`fakeClient does not implement ${member}`));
+
+/** A fake client over a fixed set of sessions, so open(id) can switch between them from the inbox. */
+function fakeClient(sessions: Thread[]): SessionClient {
+  const byId = new Map(sessions.map((session) => [session.id, session]));
+
+  return {
+    onEvent: () => () => {},
+    subscribe: async () => {},
+    sessionGet: async (id: string) => byId.get(id)!,
+    sessionList: async () => [...byId.values()],
+    sessionCurate: mock(async (id: string, rejections: HunkRejection[]) => {
+      const session = byId.get(id)!;
+      const content = rejections.length
+        ? curateDiff(session.artifact.files!, rejections)
+        : undefined;
+      const next = {
+        ...session,
+        workingCopy: content,
+        curation: rejections.length ? rejections : undefined,
+      };
+
+      byId.set(id, next);
+
+      return next;
+    }),
+    sessionComment: unimplemented("sessionComment"),
+    sessionAnnotate: unimplemented("sessionAnnotate"),
+    sessionRemoveAnnotation: unimplemented("sessionRemoveAnnotation"),
+    sessionSetWorkingCopy: unimplemented("sessionSetWorkingCopy"),
+    sessionCutBlock: unimplemented("sessionCutBlock"),
+    sessionRestoreBlock: unimplemented("sessionRestoreBlock"),
+    sessionSetAccess: unimplemented("sessionSetAccess"),
+    sessionNavigate: unimplemented("sessionNavigate"),
+    sessionBranch: unimplemented("sessionBranch"),
+    sessionSwitch: unimplemented("sessionSwitch"),
+    sessionLabel: unimplemented("sessionLabel"),
+    sessionFork: unimplemented("sessionFork"),
+    sessionSetViewed: unimplemented("sessionSetViewed"),
+    sessionSetTitle: unimplemented("sessionSetTitle"),
+    sessionSetShareId: unimplemented("sessionSetShareId"),
+    sessionMergeShared: unimplemented("sessionMergeShared"),
+    sessionDelete: unimplemented("sessionDelete"),
+    sessionSetSelfName: unimplemented("sessionSetSelfName"),
+    sessionResolve: unimplemented("sessionResolve"),
+    close: () => {},
+  };
+}
+
+const tick = () => new Promise((resolve) => setTimeout(resolve, 0));
+
+// rows for each single-change patch: file(0), hunk(1), ctx(2), del(3), add(4), ctx(5)
+describe("switching threads keeps the cached projection curatable", () => {
+  test("curation still works after switching away and back to a diff thread", async () => {
+    // Arrange - two diff threads in one inbox
+    const controller = createReviewController({
+      sessionId: "ses_a",
+      openClient: async () =>
+        fakeClient([
+          diffSession("ses_a", PATCH_A, FILES_A),
+          diffSession("ses_b", PATCH_B, FILES_B),
+        ]),
+    });
+
+    controller.connect();
+    await tick();
+
+    // Act - visit B, then return to A (A's projection now comes from the per-thread cache)
+    controller.open("ses_b");
+    await tick();
+    controller.open("ses_a");
+    await tick();
+
+    // Assert - the returned thread's file model parses lazily and curation lands
+    controller.toggleRejectChange(4);
+    await tick();
+
+    expect(controller.getSnapshot().status).toContain("change rejected");
+    expect(controller.getSnapshot().session?.workingCopy).toBe("");
+  });
+});

package/src/thread-controller.tree.test.ts

@@ -82,6 +82,7 @@ function fakeClient(session: Thread) {
     sessionCutBlock: unimplemented("sessionCutBlock"),
     sessionRestoreBlock: unimplemented("sessionRestoreBlock"),
     sessionCurate: unimplemented("sessionCurate"),
+    sessionSetAccess: unimplemented("sessionSetAccess"),
     sessionNavigate: mock(pending),
     sessionBranch: mock(pending),
     sessionSwitch: mock(pending),

package/src/thread-controller.ts

@@ -1,5 +1,5 @@
 /**
- * The review-session controller: every daemon round-trip and mutation
+ * The thread controller: every daemon round-trip and mutation
  * primitive behind one React-free object. It owns connect/autostart/subscribe,
  * the session/inbox/status/error snapshot, optimistic apply, the mutation
  * primitives (cut/edit/annotate/submit/...), and the post-submit completion
@@ -132,6 +132,41 @@ function planCutId(base: { lineStart: number; lineEnd: number }): string {
   return `plan:${base.lineStart}-${base.lineEnd}`;
 }
 
+/**
+ * Whether two records of the same thread yield the same document projection (display, rows, files,
+ * models). Those derive only from the artifact content and the working copy, so an update that
+ * touched only annotations, status, or the verdict leaves them identical - the projection can be
+ * reused rather than re-parsed. Content and working copy are strings, compared here by value.
+ */
+export function sameDerivationInputs(previous: Thread, next: Thread): boolean {
+  return (
+    previous.id === next.id &&
+    previous.artifact.content === next.artifact.content &&
+    previous.workingCopy === next.workingCopy
+  );
+}
+
+/**
+ * The session with `annotation` upserted, for an optimistic paint the instant the composer closes
+ * rather than after the daemon round-trip - otherwise a saved comment blinks out until the write
+ * lands. An edit keeps the note in place and its timestamp; a new note appends. The daemon's record
+ * replaces this guess when the write returns.
+ */
+export function withAnnotationUpserted(
+  session: Thread,
+  annotation: Omit<Annotation, "createdAt">,
+): Thread {
+  const index = session.annotations.findIndex((entry) => entry.id === annotation.id);
+  const createdAt = index >= 0 ? session.annotations[index]!.createdAt : new Date().toISOString();
+  const optimistic: Annotation = { ...annotation, createdAt };
+  const annotations =
+    index >= 0
+      ? session.annotations.map((entry) => (entry.id === annotation.id ? optimistic : entry))
+      : [...session.annotations, optimistic];
+
+  return { ...session, annotations };
+}
+
 export interface ControllerSnapshot {
   session: Thread | null;
   inbox: Thread[] | null;
@@ -309,6 +344,8 @@ export interface ReviewController {
   submit(verdict: VerdictKind, summary: string): void;
   /** Publish the current session as a share; the ssh line lands on the clipboard. */
   share(): void;
+  /** Replace the private-share allowlist of GitHub logins for the current session. Owner only. */
+  setShareAccess(githubLogins: string[]): void;
   /** The session tree as rows for the rail's Tree tab, cached per session identity. */
   treeRows(): TreeRow[];
   /**
@@ -343,6 +380,9 @@ interface DerivedSessionProjection {
   display: DisplayBlock[];
   rows: DiffRow[];
   files: WalkFile[];
+  /** Raw per-file contents; parsed into a model lazily on first curation touch, not all upfront. */
+  fileContents: Map<string, DiffFileContents>;
+  /** Parsed file models, filled on demand from fileContents and memoized here. */
   models: Map<string, FileDiffMetadata>;
   tree: TreeRow[];
 }
@@ -353,6 +393,15 @@ interface LiveWorkingDiff {
   files: readonly DiffFileContents[];
 }
 
+interface DerivedCacheEntry {
+  derivedFor: Thread;
+  derivedForLiveDiff: LiveWorkingDiff | null;
+  derived: DerivedSessionProjection;
+}
+
+/** Recently-viewed threads whose parsed projection is kept for an instant return; oldest evicted first. */
+const DERIVED_CACHE_LIMIT = 8;
+
 class Controller implements ReviewController {
   readonly readOnly: boolean;
   private client: SessionClient | null = null;
@@ -387,9 +436,12 @@ class Controller implements ReviewController {
     display: [],
     rows: [],
     files: [],
+    fileContents: new Map(),
     models: new Map(),
     tree: [],
   };
+  /** Recently-viewed threads' parsed projections, so returning to a thread reuses its work instead of re-parsing. */
+  private derivedCache = new Map<string, DerivedCacheEntry>();
   /** File paths whose diff body is folded to just the file band. */
   private collapsedFiles = new Set<string>();
   /** File paths woven to their full contents (unchanged lines shown as context). */
@@ -496,6 +548,57 @@ class Controller implements ReviewController {
   }
 
   // ── derived projections ─────────────────────
+  /**
+   * The projection reuses when the same thread's derivation inputs are unchanged. display, rows,
+   * files, and models derive only from the artifact and working copy - never from annotations,
+   * status, or the verdict - so an update that touched only those produces an all-new session
+   * record but an identical projection.
+   */
+  private reusesDerived(session: Thread, liveDiff: LiveWorkingDiff | null): boolean {
+    return (
+      this.derivedFor !== null &&
+      this.derivedForLiveDiff === liveDiff &&
+      sameDerivationInputs(this.derivedFor, session)
+    );
+  }
+
+  private buildDerived(
+    session: Thread | null,
+    frozenDiff: boolean,
+    liveDiff: LiveWorkingDiff | null,
+  ): DerivedSessionProjection {
+    const content = frozenDiff ? session!.artifact.content : (liveDiff?.patch ?? "");
+    const files = frozenDiff ? (session?.artifact.files ?? []) : (liveDiff?.files ?? []);
+    const rows = content ? diffRows(content) : [];
+    const fileContents = new Map<string, DiffFileContents>();
+
+    for (const file of files) fileContents.set(file.path, file);
+
+    return {
+      display: session ? buildDisplay(session.artifact.content, session.workingCopy) : [],
+      rows,
+      files: walkFiles(rows),
+      fileContents,
+      models: new Map<string, FileDiffMetadata>(),
+      tree: session?.history ? treeRows(session.history) : [],
+    };
+  }
+
+  /** The parsed model for a changed file, computed on first touch and memoized in the projection. */
+  private fileModel(path: string): FileDiffMetadata | undefined {
+    const cached = this.derived.models.get(path);
+
+    if (cached) return cached;
+    const contents = this.derived.fileContents.get(path);
+
+    if (!contents) return undefined;
+    const model = parseFileDiff(contents);
+
+    this.derived.models.set(path, model);
+
+    return model;
+  }
+
   private ensureDerived(): void {
     const session = this.snapshot.session;
     const frozenDiff = readsFrozenDiff(session);
@@ -503,27 +606,60 @@ class Controller implements ReviewController {
     const liveDiff = frozenDiff ? null : this.liveDiff;
 
     if (this.derivedFor === session && this.derivedForLiveDiff === liveDiff) return;
-    // fold state belongs to the session, so a live-tree refresh keeps it; only a new session resets it
-    if (this.derivedFor !== session) {
+    // reuse the parsed projection across an update that left the inputs unchanged; only the cheap tree can differ
+    if (session !== null && this.reusesDerived(session, liveDiff)) {
+      this.derivedFor = session;
+      this.derived = { ...this.derived, tree: session.history ? treeRows(session.history) : [] };
+
+      return;
+    }
+    // a different thread resets fold state; a same-thread re-derivation (content edit) keeps it
+    if (this.derivedFor?.id !== session?.id) {
       this.collapsedFiles.clear();
       this.expandedFiles.clear();
     }
+    // returning to a recently-viewed thread whose inputs are unchanged reuses its parsed projection
+    const cached = session !== null ? this.derivedCache.get(session.id) : undefined;
+
+    if (
+      cached &&
+      cached.derivedForLiveDiff === liveDiff &&
+      sameDerivationInputs(cached.derivedFor, session!)
+    ) {
+      this.derivedFor = session;
+      this.derivedForLiveDiff = liveDiff;
+      this.derived = {
+        ...cached.derived,
+        tree: session!.history ? treeRows(session!.history) : [],
+      };
+      this.rememberDerived(session!, liveDiff, this.derived);
+
+      return;
+    }
     this.derivedFor = session;
     this.derivedForLiveDiff = liveDiff;
+    this.derived = this.buildDerived(session, frozenDiff, liveDiff);
+    if (session !== null) this.rememberDerived(session, liveDiff, this.derived);
+  }
 
-    const content = frozenDiff ? session!.artifact.content : (liveDiff?.patch ?? "");
-    const files = frozenDiff ? (session?.artifact.files ?? []) : (liveDiff?.files ?? []);
-    const rows = content ? diffRows(content) : [];
-    const models = new Map<string, FileDiffMetadata>();
+  /** Keep the freshest projections per thread, evicting the least-recently-used past the cap. */
+  private rememberDerived(
+    session: Thread,
+    liveDiff: LiveWorkingDiff | null,
+    derived: DerivedSessionProjection,
+  ): void {
+    this.derivedCache.delete(session.id);
+    this.derivedCache.set(session.id, {
+      derivedFor: session,
+      derivedForLiveDiff: liveDiff,
+      derived,
+    });
+    while (this.derivedCache.size > DERIVED_CACHE_LIMIT) {
+      const oldest = this.derivedCache.keys().next().value;
 
-    for (const file of files) models.set(file.path, parseFileDiff(file));
-    this.derived = {
-      display: session ? buildDisplay(session.artifact.content, session.workingCopy) : [],
-      rows,
-      files: walkFiles(rows),
-      models,
-      tree: session?.history ? treeRows(session.history) : [],
-    };
+      if (oldest === undefined) break;
+      this.derivedCache.delete(oldest);
+    }
   }
 
   /** The per-file contents that back the current rows: a diff thread's capture, else the live working tree. */
@@ -819,7 +955,7 @@ class Controller implements ReviewController {
 
       return null;
     }
-    const model = this.derived.models.get(row.file);
+    const model = this.fileModel(row.file);
 
     if (!model) return null;
 
@@ -882,13 +1018,25 @@ class Controller implements ReviewController {
     this.applyOptimistic(expected, this.client!.sessionCurate(session.id, rejections));
   }
 
+  setShareAccess(githubLogins: string[]): void {
+    const session = this.snapshot.session;
+
+    if (!session) return;
+    const access = { githubLogins };
+    const expected: Thread = { ...session, access };
+
+    this.applyOptimistic(expected, this.client!.sessionSetAccess(session.id, githubLogins));
+    // an already-shared link must enforce the new access, so push it up to the gateway blob
+    if (session.shareId) void this.shareTransport.push(session.shareId, [], access).catch(() => {});
+  }
+
   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);
+      const model = this.fileModel(row.file);
 
       if (model && isRowRejected(row.file, model, row, this.rejections)) rejected.add(index);
     });
@@ -965,7 +1113,7 @@ class Controller implements ReviewController {
 
   /** 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);
+    const model = this.fileModel(rejection.path);
 
     if (!model) return [];
     const rows: DiffRow[] = [];
@@ -1080,7 +1228,7 @@ class Controller implements ReviewController {
         : { id: newAnnotationId(), kind, anchor, body, target: resolvedTarget };
     const persisted = this.client!.sessionComment(session.id, wire);
 
-    this.apply(persisted);
+    this.applyOptimistic(withAnnotationUpserted(session, wire), persisted);
     this.mirrorAnnotation(persisted, wire);
 
     return wire.id;
@@ -1096,7 +1244,7 @@ class Controller implements ReviewController {
         : { id: newAnnotationId(), kind: "comment", anchor, body, target };
     const persisted = this.client!.sessionComment(session.id, wire);
 
-    this.apply(persisted);
+    this.applyOptimistic(withAnnotationUpserted(session, wire), persisted);
     this.mirrorAnnotation(persisted, wire);
 
     return wire.id;
@@ -1162,7 +1310,7 @@ class Controller implements ReviewController {
     const wire = root.target ? { ...base, target: root.target } : base;
     const persisted = this.client!.sessionComment(session.id, wire);
 
-    this.apply(persisted);
+    this.applyOptimistic(withAnnotationUpserted(session, wire), persisted);
     this.mirrorAnnotation(persisted, wire);
 
     return wire.id;
@@ -1176,7 +1324,7 @@ class Controller implements ReviewController {
     const wire = { id: newAnnotationId(), kind: "comment", anchor, body };
     const persisted = this.client!.sessionComment(session.id, wire);
 
-    this.apply(persisted);
+    this.applyOptimistic(withAnnotationUpserted(session, wire), persisted);
     this.mirrorAnnotation(persisted, wire);
 
     return wire.id;
@@ -1201,9 +1349,8 @@ class Controller implements ReviewController {
     if (existing.replyTo !== undefined) wire.replyTo = existing.replyTo;
     const persisted = this.client!.sessionComment(session.id, wire);
 
-    this.apply(persisted);
+    this.applyOptimistic(withAnnotationUpserted(session, wire), persisted);
     this.mirrorAnnotation(persisted, wire);
-    this.setStatus("annotation updated");
   }
 
   // push only after the local write lands, so a rejected write never leaks to the share