@cueloop/client 0.1.0-alpha.73 → 0.1.0-alpha.74

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

@@ -197,3 +197,122 @@ describe("live working-tree diff for a non-diff thread", () => {
     controller.close();
   });
 });
+
+const STALE_PATCH = `diff --git a/src/stale.ts b/src/stale.ts
+--- a/src/stale.ts
++++ b/src/stale.ts
+@@ -1,1 +1,1 @@
+-const s = 1;
++const s = 2;
+`;
+
+const STALE_FILES = [
+  {
+    path: "src/stale.ts",
+    oldContents: "const s = 1;\n",
+    newContents: "const s = 2;\n",
+    status: "modified" as const,
+  },
+];
+
+/** A `type:"diff"` thread with a captured snapshot; `meta.workbench` decides frozen vs live. */
+function diffSession(meta: Thread["artifact"]["meta"], id = "ses_diff"): Thread {
+  return {
+    schemaVersion: SCHEMA_VERSION,
+    id,
+    workspace: { repoRoot: "/repo", branch: "main" },
+    artifact: { type: "diff", content: STALE_PATCH, files: STALE_FILES, meta },
+    revisions: [{ revision: 1, content: STALE_PATCH, submittedAt: AT }],
+    annotations: [],
+    verdict: null,
+    status: "pending",
+    createdAt: AT,
+  };
+}
+
+describe("frozen vs live diff by thread kind", () => {
+  test("a workbench thread renders the live working tree, not its captured snapshot", async () => {
+    const session = diffSession({ workbench: true, title: "Workbench" });
+    const controller = createReviewController({
+      sessionId: session.id,
+      openClient: async () => fakeClient(session),
+      shareTransport,
+    });
+    controller.connect();
+    await tick();
+
+    // the live repoDiff (src/x.ts) wins over the frozen capture (src/stale.ts)
+    const changes = await controller.repoChanges();
+
+    expect(changes.map((file) => file.path)).toEqual(["src/x.ts"]);
+    expect(controller.rows().some((row) => row.file === "src/x.ts")).toBe(true);
+    expect(controller.rows().some((row) => row.file === "src/stale.ts")).toBe(false);
+
+    controller.close();
+  });
+
+  test("a plain diff review pins its captured snapshot and never queries the live tree", async () => {
+    const session = diffSession({});
+    const repoDiff = mock(async () => ({ patch: PATCH, files: FILES }));
+    const client = { ...fakeClient(session), repoDiff } satisfies SessionClient;
+    const controller = createReviewController({
+      sessionId: session.id,
+      openClient: async () => client,
+      shareTransport,
+    });
+    controller.connect();
+    await tick();
+
+    const changes = await controller.repoChanges();
+
+    expect(changes.map((file) => file.path)).toEqual(["src/stale.ts"]);
+    expect(controller.rows().some((row) => row.file === "src/stale.ts")).toBe(true);
+    expect(repoDiff).not.toHaveBeenCalled();
+
+    controller.close();
+  });
+});
+
+const SERVED_PATCH = `diff --git a/src/served.ts b/src/served.ts
+--- a/src/served.ts
++++ b/src/served.ts
+@@ -1,1 +1,1 @@
+-const served = 0;
++const served = 1;
+`;
+
+describe("serve mode pins the served thread to a frozen snapshot", () => {
+  test("the served artifact wins over the thread's own capture and the live tree", async () => {
+    const session = diffSession({ workbench: true });
+    const repoDiff = mock(async () => ({ patch: PATCH, files: FILES }));
+    const client = { ...fakeClient(session), repoDiff } satisfies SessionClient;
+    const controller = createReviewController({
+      sessionId: session.id,
+      openClient: async () => client,
+      shareTransport,
+      servedArtifact: {
+        type: "diff",
+        content: SERVED_PATCH,
+        files: [
+          {
+            path: "src/served.ts",
+            oldContents: "const served = 0;\n",
+            newContents: "const served = 1;\n",
+            status: "modified",
+          },
+        ],
+        meta: { workbench: true, snapshot: true },
+      },
+    });
+    controller.connect();
+    await tick();
+
+    // the observer sees the frozen served snapshot, not the thread's stale capture nor the live tree
+    expect(controller.rows().some((row) => row.file === "src/served.ts")).toBe(true);
+    expect(controller.rows().some((row) => row.file === "src/stale.ts")).toBe(false);
+    expect(controller.rows().some((row) => row.file === "src/x.ts")).toBe(false);
+    expect(repoDiff).not.toHaveBeenCalled();
+
+    controller.close();
+  });
+});

package/src/thread-controller.ts

@@ -29,6 +29,7 @@ import {
   type Anchor,
   type Annotation,
   type AnnotationTarget,
+  type Artifact,
   type DiffFileContents,
   type Thread,
   type SessionHistory,
@@ -46,8 +47,16 @@ import {
 } from "./share";
 import { buildDisplay, nextWorkBlock, type DisplayBlock } from "./view-plan";
 import { entryTarget, treeRows, type TreeRow } from "./tree-view";
-import { diffRowBlocks, diffRows, fileChangeCounts, fileRowRange, type DiffRow } from "./view-diff";
+import {
+  diffRowBlocks,
+  diffRows,
+  fileChangeCounts,
+  fileRowRange,
+  readsFrozenDiff,
+  type DiffRow,
+} from "./view-diff";
 import { applyFold } from "./diff-fold";
+import { snapshotWorkbench } from "./workbench-snapshot";
 import { copyToClipboard } from "./clipboard";
 import {
   changeRejectionForRow,
@@ -180,6 +189,8 @@ export interface ReviewControllerOptions {
    */
   openClient?: () => Promise<SessionClient>;
   shareTransport?: ShareTransport;
+  /** Serve mode: pin this frozen diff onto the served thread so an observer sees a stable snapshot. */
+  servedArtifact?: Artifact;
 }
 
 export interface ReviewController {
@@ -268,6 +279,14 @@ export interface ReviewController {
    * first write a browse-only launch makes - nothing is on disk until it runs.
    */
   commentOnWorkbench(anchor: Anchor, target: AnnotationTarget, body: string): Promise<void>;
+  /** As commentOnWorkbench, for a note drawn on the bare-launch Changes diff (row coords, file target). */
+  commentOnWorkbenchDiff(
+    displayIndex: number,
+    start: number,
+    end: number,
+    endDisplayIndex: number,
+    body: string,
+  ): Promise<void>;
   /**
    * Reply to `rootAnnotationId`: the reply shares the root's anchor and names
    * it in replyTo, so the discussion stays one conversation. Returns the minted id.
@@ -395,10 +414,19 @@ class Controller implements ReviewController {
   getSnapshot = (): ControllerSnapshot => this.snapshot;
 
   private update(patch: Partial<ControllerSnapshot>): void {
-    this.snapshot = { ...this.snapshot, ...patch };
+    this.snapshot = { ...this.snapshot, ...this.freezeServed(patch) };
     for (const listener of this.listeners) listener();
   }
 
+  /** Serve mode pins the served thread's diff to a snapshot; its annotations and the rest stay live. */
+  private freezeServed(patch: Partial<ControllerSnapshot>): Partial<ControllerSnapshot> {
+    const served = this.options.servedArtifact;
+
+    if (!served || !patch.session || patch.session.id !== this.options.sessionId) return patch;
+
+    return { ...patch, session: { ...patch.session, artifact: served } };
+  }
+
   connect(): void {
     void (async () => {
       try {
@@ -470,9 +498,9 @@ class Controller implements ReviewController {
   // ── derived projections ─────────────────────
   private ensureDerived(): void {
     const session = this.snapshot.session;
-    const isDiff = session?.artifact.type === "diff";
-    // a diff thread reads its pinned capture; every other thread reflects the live working tree
-    const liveDiff = isDiff ? null : this.liveDiff;
+    const frozenDiff = readsFrozenDiff(session);
+    // a plain diff thread reads its pinned capture; a workbench thread and every other thread reflect the live working tree
+    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
@@ -483,8 +511,8 @@ class Controller implements ReviewController {
     this.derivedFor = session;
     this.derivedForLiveDiff = liveDiff;
 
-    const content = isDiff ? session!.artifact.content : (liveDiff?.patch ?? "");
-    const files = isDiff ? (session?.artifact.files ?? []) : (liveDiff?.files ?? []);
+    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>();
 
@@ -502,7 +530,7 @@ class Controller implements ReviewController {
   private foldFiles(): readonly DiffFileContents[] | undefined {
     const session = this.snapshot.session;
 
-    return session?.artifact.type === "diff" ? session.artifact.files : this.liveDiff?.files;
+    return readsFrozenDiff(session) ? session!.artifact.files : this.liveDiff?.files;
   }
 
   treeRows(): TreeRow[] {
@@ -614,9 +642,9 @@ class Controller implements ReviewController {
   }
 
   async repoChanges(): Promise<readonly DiffFileContents[]> {
-    // a diff review pins its captured snapshot; every other thread reflects the live working tree
+    // a plain diff review pins its captured snapshot; a workbench thread and every other thread reflect the live working tree
     const session = this.snapshot.session;
-    if (session?.artifact.type === "diff") return session.artifact.files ?? [];
+    if (readsFrozenDiff(session)) return session!.artifact.files ?? [];
     // eager: capture the live working-tree diff so the Changes navigator and its file tabs render a real diff
     if (this.client?.repoDiff !== undefined) {
       const diff = await this.client.repoDiff(this.sidebarRepoRoot());
@@ -1073,26 +1101,49 @@ class Controller implements ReviewController {
     return wire.id;
   }
 
-  async commentOnWorkbench(anchor: Anchor, target: AnnotationTarget, body: string): Promise<void> {
-    if (!this.snapshot.session) {
-      if (this.client?.sessionWorkbench === undefined) return;
-      let workbench;
+  /** Find-or-create the per-repo workbench thread and adopt it as active; true once a session exists. */
+  private async ensureWorkbenchSession(): Promise<boolean> {
+    if (this.snapshot.session) return true;
+    if (this.client?.sessionWorkbench === undefined) return false;
+    let workbench;
 
-      try {
-        workbench = await this.client.sessionWorkbench(this.options.cwd ?? process.cwd());
-      } catch (cause) {
-        // the composer already closed, so a lost first comment must at least surface, not vanish
-        this.setStatus(String(cause instanceof Error ? cause.message : cause));
+    try {
+      workbench = await this.client.sessionWorkbench(this.options.cwd ?? process.cwd());
+    } catch (cause) {
+      // the composer already closed, so a lost first comment must at least surface, not vanish
+      this.setStatus(String(cause instanceof Error ? cause.message : cause));
 
-        return;
-      }
-      // adopt the thread as active (the shell flips to the thread view) and let the inbox catch up
-      this.update({ session: workbench });
-      void this.refreshInbox();
+      return false;
     }
+    // adopt the thread as active (the shell flips to the thread view) and let the inbox catch up
+    this.update({ session: workbench });
+    void this.refreshInbox();
+
+    return true;
+  }
+
+  async commentOnWorkbench(anchor: Anchor, target: AnnotationTarget, body: string): Promise<void> {
+    if (!(await this.ensureWorkbenchSession())) return;
     this.addComment(anchor, target, body);
   }
 
+  /** A first comment on the bare-launch Changes diff: promote to the workbench thread, then anchor it in the diff rows. */
+  async commentOnWorkbenchDiff(
+    displayIndex: number,
+    start: number,
+    end: number,
+    endDisplayIndex: number,
+    body: string,
+  ): Promise<void> {
+    if (!(await this.ensureWorkbenchSession())) return;
+    // annotate re-derives the file path and rev from the diff row it lands on
+    this.annotate("comment", displayIndex, start, end, body, endDisplayIndex, {
+      kind: "file",
+      path: "",
+      rev: "worktree",
+    });
+  }
+
   reply(rootAnnotationId: string, body: string): string | undefined {
     const session = this.snapshot.session;
     const root = session?.annotations.find((annotation) => annotation.id === rootAnnotationId);
@@ -1270,13 +1321,22 @@ class Controller implements ReviewController {
       );
   }
 
+  /** A workbench thread renders live locally; freeze its diff so a remote reviewer gets a stable snapshot. */
+  private freezeForShare(session: Thread): Promise<Thread> {
+    const repoDiff = this.client?.repoDiff;
+
+    return repoDiff
+      ? snapshotWorkbench(session, (root) => repoDiff.call(this.client, root))
+      : Promise.resolve(session);
+  }
+
   share(): void {
     const session = this.snapshot.session;
 
     if (!session) return;
     this.setStatus("sharing…");
-    this.shareTransport
-      .publish(session)
+    this.freezeForShare(session)
+      .then((shared) => this.shareTransport.publish(shared))
       .then(async ({ line, copied }) => {
         // Stamp the id back so a later pull knows which share to collect from.
         const shareId = this.shareTransport.parseShareId(line);
@@ -1373,7 +1433,8 @@ class Controller implements ReviewController {
     client
       .sessionFork(session.id)
       .then(async (fork) => {
-        const { line, copied } = await this.shareTransport.publish(fork);
+        const shared = await this.freezeForShare(fork);
+        const { line, copied } = await this.shareTransport.publish(shared);
         const shareId = this.shareTransport.parseShareId(line);
 
         if (shareId) await client.sessionSetShareId(fork.id, shareId);

package/src/use-changes-workbench.ts

@@ -4,6 +4,7 @@
 
 import { useRef, useState } from "react";
 import type { ProjectPanelMode } from "./components/AppShell";
+import type { LaunchLayout } from "./launch-layout";
 import {
   activateTab,
   addTab,
@@ -22,6 +23,41 @@ import {
 /** Seed the workbench for a bare launch: the region opens on a disposable Welcome tab. */
 export interface ChangesWorkbenchOptions {
   seed?: "changes" | "welcome";
+  /** The launch layout the right region opens in; overrides the seed's defaults. */
+  layout?: LaunchLayout;
+}
+
+interface InitialPanes {
+  projectOpen: boolean;
+  changesOpen: boolean;
+  projectMode: ProjectPanelMode;
+  zoomed: boolean;
+}
+
+/** The right region's opening state: from the launch layout when given, else the welcome-seed defaults. */
+function initialPanes(options?: ChangesWorkbenchOptions): InitialPanes {
+  const layout = options?.layout;
+
+  if (layout) {
+    const changesOpen = layout.rightSidebar === "changes";
+
+    return {
+      projectOpen: layout.rightSidebar !== "off",
+      changesOpen,
+      projectMode: layout.rightSidebar === "project" ? "tree" : "changes",
+      // zoom fills the middle with the Changes editor, so a hand-edited layout that zooms without one
+      // would strand a blank center with the Thread pane hidden; only honor zoom when Changes is open
+      zoomed: layout.zoomChanges && changesOpen,
+    };
+  }
+  const welcomeSeed = options?.seed === "welcome";
+
+  return {
+    projectOpen: welcomeSeed,
+    changesOpen: welcomeSeed,
+    projectMode: "changes",
+    zoomed: false,
+  };
 }
 
 export interface ChangesWorkbench {
@@ -46,10 +82,11 @@ export interface ChangesWorkbench {
 
 export function useChangesWorkbench(options?: ChangesWorkbenchOptions): ChangesWorkbench {
   const welcomeSeed = options?.seed === "welcome";
-  const [projectOpen, setProjectOpen] = useState(welcomeSeed);
-  const [changesOpen, setChangesOpen] = useState(welcomeSeed);
-  const [projectMode, setProjectMode] = useState<ProjectPanelMode>("changes");
-  const [zoomed, setZoomed] = useState(false);
+  const initial = initialPanes(options);
+  const [projectOpen, setProjectOpen] = useState(initial.projectOpen);
+  const [changesOpen, setChangesOpen] = useState(initial.changesOpen);
+  const [projectMode, setProjectMode] = useState<ProjectPanelMode>(initial.projectMode);
+  const [zoomed, setZoomed] = useState(initial.zoomed);
   const [grid, setGrid] = useState<EditorNode>(() =>
     makeGroup([welcomeSeed ? welcomeTab() : changesTab()]),
   );

package/src/use-remember-layout.ts

@@ -0,0 +1,31 @@
+import { useEffect, useRef } from "react";
+import { persistLayout } from "./config";
+import { layoutFromPanes, type LaunchLayout } from "./launch-layout";
+
+/**
+ * Persist the pane composition whenever the user changes it, so the next bare launch restores it.
+ * Only a launch that carried an intended layout (a create-command or the vanilla inbox) remembers;
+ * a bare thread open collapses the sidebar and must not clobber the remembered composition. The
+ * mount write is skipped: the opening composition is the one just restored.
+ */
+export function useRememberLayout(
+  layout: LaunchLayout | undefined,
+  active: boolean,
+  threads: boolean,
+  changesOpen: boolean,
+  projectOpen: boolean,
+  zoomChanges: boolean,
+): void {
+  const settled = useRef(false);
+
+  useEffect(() => {
+    if (!settled.current) {
+      settled.current = true;
+
+      return;
+    }
+    // only the active workbench persists: on a bare launch App's unused panes must not clobber the shell's
+    if (!active || layout === undefined) return;
+    persistLayout(layoutFromPanes({ threads, changesOpen, projectOpen, zoomChanges }));
+  }, [active, layout, threads, changesOpen, projectOpen, zoomChanges]);
+}

package/src/use-settings-dialog.tsx

@@ -111,6 +111,15 @@ export function useSettingsDialog(params: {
     setQuickActions(next);
     persistActions(next);
   };
+  const editActionPrompt = (index: number, prompt: string): void => {
+    // a blank title fails the config schema and would vanish on reload, so never persist one
+    if (prompt.trim().length === 0) return;
+    commitActions(
+      quickActions.map((action, actionIndex) =>
+        actionIndex === index ? { ...action, prompt } : action,
+      ),
+    );
+  };
   const editActionMetadata = (index: number, metadata: string): void =>
     commitActions(
       quickActions.map((action, actionIndex) =>
@@ -175,6 +184,7 @@ export function useSettingsDialog(params: {
             setSettingsNav((state) => ({ ...state, zone: "body", rowIndex: index }));
             setActionsExpandedIndex((current) => (current === index ? null : index));
           }}
+          onEditPrompt={editActionPrompt}
           onEditMetadata={editActionMetadata}
           onReset={resetActions}
           onAdd={addAction}
@@ -215,8 +225,7 @@ export function useSettingsDialog(params: {
   };
 
   const onCategorySelect = (categoryId: string): void => {
-    // the nav tree carries a synthetic Settings group folder; clicking it must
-    // not become the active category, or the key handler dereferences nothing
+    // ignore a select that names no real category, so the key handler never dereferences nothing
     if (!settingsCategories.some((category) => category.id === categoryId)) return;
     setActionsExpandedIndex(null);
     setSettingsNav({ categoryId, rowIndex: 0, zone: "body" });

package/src/view-diff.test.ts

@@ -1,6 +1,13 @@
 import { describe, expect, test } from "bun:test";
-import { makeAnchor, type Annotation } from "@cueloop/schema";
-import { diffRowAnchor, diffRowBlocks, diffRows, fileRowRange, fileTargetMarks } from "./view-diff";
+import { makeAnchor, type Annotation, type Thread } from "@cueloop/schema";
+import {
+  changesMarks,
+  diffRowAnchor,
+  diffRowBlocks,
+  diffRows,
+  fileRowRange,
+  fileTargetMarks,
+} from "./view-diff";
 
 const PATCH = `diff --git a/src/store.ts b/src/store.ts
 index 111..222 100644
@@ -110,3 +117,67 @@ diff --git a/b.ts b/b.ts
     expect(marked.every((index) => index >= range.start && index < range.end)).toBe(true);
   });
 });
+
+describe("changesMarks", () => {
+  const PATCH = `diff --git a/x.ts b/x.ts
+--- a/x.ts
++++ b/x.ts
+@@ -1,1 +1,2 @@
+ const keep = 0;
++const added = 1;
+`;
+
+  function diffThread(meta: Thread["artifact"]["meta"], annotations: Annotation[]): Thread {
+    return {
+      schemaVersion: "1",
+      id: "s_changes",
+      workspace: { repoRoot: "/repo", branch: "main" },
+      artifact: { type: "diff", content: PATCH, meta },
+      revisions: [{ revision: 1, content: PATCH, submittedAt: "2026-01-01T00:00:00Z" }],
+      annotations,
+      verdict: null,
+      status: "pending",
+      createdAt: "2026-01-01T00:00:00Z",
+    };
+  }
+
+  function fileNote(rows: ReturnType<typeof diffRows>): Annotation {
+    const range = fileRowRange(rows, "x.ts")!;
+    const fileRows = rows.slice(range.start, range.end);
+    const addRelative = fileRows.findIndex((row) => row.kind === "add");
+    const quote = fileRows[addRelative]!.text.replace(/\n$/, "");
+    const anchor = makeAnchor(diffRowBlocks(fileRows), addRelative, 0, quote.length, addRelative);
+
+    return {
+      id: "f1",
+      kind: "comment",
+      anchor,
+      target: { kind: "file", path: "x.ts", rev: "worktree" },
+      body: "note",
+      createdAt: "2026-01-01T00:00:00Z",
+    };
+  }
+
+  test("a workbench thread paints its file-targeted working-tree notes", () => {
+    const rows = diffRows(PATCH);
+    const session = diffThread({ workbench: true }, [fileNote(rows)]);
+
+    expect([...changesMarks(session, rows).keys()].length).toBeGreaterThan(0);
+  });
+
+  test("a pinned diff review paints only artifact notes, not the working tree's file targets", () => {
+    const rows = diffRows(PATCH);
+    const session = diffThread({}, [fileNote(rows)]);
+
+    // the same file-targeted note is not an artifact note, so a frozen review leaves it unpainted
+    expect([...changesMarks(session, rows).keys()].length).toBe(0);
+  });
+
+  test("a shared snapshot still paints the workbench's file-targeted feedback", () => {
+    const rows = diffRows(PATCH);
+    // a served/shared snapshot keeps the workbench marker, so its notes stay file-targeted and visible
+    const session = diffThread({ workbench: true, snapshot: true }, [fileNote(rows)]);
+
+    expect([...changesMarks(session, rows).keys()].length).toBeGreaterThan(0);
+  });
+});

package/src/view-diff.ts

@@ -248,6 +248,44 @@ export function fileTargetMarks(
   return result;
 }
 
+/** A plain diff review's notes anchor to the artifact itself; a working-tree diff's notes target files. */
+export function annotatesArtifact(session: Thread | null): boolean {
+  return session?.artifact.type === "diff" && session.artifact.meta.workbench !== true;
+}
+
+/**
+ * Render the diff from the pinned artifact rather than the live working tree: a plain diff review (the
+ * artifact is the diff), or a shared/served snapshot of a workbench thread (the remote has no tree).
+ */
+export function readsFrozenDiff(session: Thread | null): boolean {
+  return (
+    session?.artifact.type === "diff" &&
+    (session.artifact.meta.workbench !== true || session.artifact.meta.snapshot === true)
+  );
+}
+
+/**
+ * The marks a Changes surface paints. A plain diff review is the artifact itself, so only its
+ * artifact-anchored notes belong; a workbench thread (live or a frozen snapshot) and every other thread
+ * show a working-tree diff, whose notes carry a file target and resolve per file - so a refresh never
+ * rebinds one across files, and a snapshot still surfaces the feedback already on the thread.
+ */
+export function changesMarks(
+  session: Thread,
+  rows: DiffRow[],
+  focusedId?: string,
+): Map<number, Mark[]> {
+  if (annotatesArtifact(session)) {
+    const artifactNotes = session.annotations.filter(
+      (annotation) => annotationTarget(annotation).kind === "artifact",
+    );
+
+    return marksByRows(artifactNotes, rows, focusedId);
+  }
+
+  return fileTargetMarks(session.annotations, rows, focusedId);
+}
+
 /**
  * Comments per file path across the diff: each discussion counts its comments (root plus
  * replies) toward the file its span ends in. Feeds the changed-files tree and tab badges, so a

package/src/workbench-snapshot.test.ts

@@ -0,0 +1,81 @@
+/** Sharing/serving a workbench thread freezes its live working-tree diff into the artifact so a remote
+ * reviewer, who cannot see the owner's tree, reads a stable snapshot; any other thread passes through. */
+
+import { describe, expect, mock, test } from "bun:test";
+import { historyFromLinear, viewFollowing, type Thread } from "@cueloop/schema";
+import { snapshotWorkbench } from "./workbench-snapshot";
+
+const AT = "2026-01-01T00:00:00.000Z";
+
+const STALE_FILES = [
+  { path: "src/a.ts", oldContents: "a\n", newContents: "b\n", status: "modified" as const },
+];
+const LIVE = {
+  patch: "FRESH PATCH",
+  files: [
+    { path: "src/a.ts", oldContents: "a\n", newContents: "c\n", status: "modified" as const },
+  ],
+};
+
+function diffThread(meta: Thread["artifact"]["meta"]): Thread {
+  return {
+    schemaVersion: "1",
+    id: "ses_wb",
+    workspace: { repoRoot: "/repo", branch: "main" },
+    artifact: { type: "diff", content: "STALE PATCH", files: STALE_FILES, meta },
+    revisions: [{ revision: 1, content: "STALE PATCH", submittedAt: AT }],
+    annotations: [
+      {
+        id: "n1",
+        kind: "comment",
+        anchor: { quote: "b", prefix: "", suffix: "" },
+        body: "why?",
+        createdAt: AT,
+      },
+    ],
+    verdict: null,
+    status: "pending",
+    createdAt: AT,
+  };
+}
+
+describe("snapshotWorkbench", () => {
+  test("freezes a workbench thread's live diff and drops the workbench flag", async () => {
+    const frozen = await snapshotWorkbench(
+      diffThread({ workbench: true, title: "Workbench" }),
+      async () => LIVE,
+    );
+
+    // the live diff is pinned into the artifact
+    expect(frozen.artifact.content).toBe("FRESH PATCH");
+    expect(frozen.artifact.files).toEqual(LIVE.files);
+    // the snapshot marker pins the render; the workbench marker stays so file-targeted feedback still paints
+    expect(frozen.artifact.meta.snapshot).toBe(true);
+    expect(frozen.artifact.meta.workbench).toBe(true);
+    expect(frozen.artifact.meta.title).toBe("Workbench");
+    // the thread is otherwise intact - same id, workspace, and annotations
+    expect(frozen.id).toBe("ses_wb");
+    expect(frozen.annotations).toHaveLength(1);
+  });
+
+  test("recaptures history so the share path rebuilds the fresh content, not the stale head", async () => {
+    // a workbench thread carries branch history whose head is the creation-time capture
+    const base = diffThread({ workbench: true });
+    const withHistory: Thread = { ...base, history: historyFromLinear(base) };
+
+    const frozen = await snapshotWorkbench(withHistory, async () => LIVE);
+
+    // viewFollowing (the share path) rebuilds content from history - it must yield the fresh patch
+    expect(viewFollowing(frozen).artifact.content).toBe("FRESH PATCH");
+  });
+
+  test("passes a plain diff review through untouched and never queries the tree", async () => {
+    const session = diffThread({ title: "PR #7" });
+    const repoDiff = mock(async () => LIVE);
+
+    const result = await snapshotWorkbench(session, repoDiff);
+
+    expect(result).toBe(session);
+    expect(repoDiff).not.toHaveBeenCalled();
+  });
+});