@cueloop/client 0.1.0-alpha.84 → 0.1.0-alpha.86

package/src/config.ts

@@ -32,6 +32,14 @@ export type AutoClose = "off" | number;
  *  (unzoomed) pane has no room for two columns, so it is always stacked regardless of this choice. */
 export type DiffViewMode = "split" | "stacked";
 
+export type ReviewWorkspaceMode = "worktree" | "current";
+
+/** Agent review defaults shared by the slash workflow and Settings. */
+export interface ReviewConfig {
+  skill: string;
+  workspace: ReviewWorkspaceMode;
+}
+
 /** One marker-popover quick action: a preset comment body, plus optional extra lines. */
 export interface QuickAction {
   prompt: string;
@@ -122,6 +130,7 @@ export interface CueloopConfig {
   actions: QuickAction[];
   /** Directory of user-level skills surfaced in the "/" palette ([skills] path); ~/.agents/skills default. */
   skillsPath: string;
+  review: ReviewConfig;
   integrations: IntegrationsConfig;
   /** Opt-in experimental features ([experimental] table); all default off. */
   experimental: ExperimentalConfig;
@@ -185,6 +194,7 @@ const ConfigDocumentSchema = v.object({
   ui: v.optional(v.unknown()),
   experimental: v.optional(v.unknown()),
   skills: v.fallback(v.optional(SkillsSectionSchema), undefined),
+  review: v.optional(v.unknown()),
 });
 
 const IdentitySchema = v.object({
@@ -237,6 +247,10 @@ const IntegrationsSchema = v.object({ obsidian: v.optional(ObsidianSchema) });
 const ExperimentalSchema = v.object({
   prototype_pixels: v.fallback(v.optional(v.boolean()), undefined),
 });
+const ReviewSchema = v.object({
+  skill: v.fallback(v.optional(v.string()), undefined),
+  workspace: v.fallback(v.optional(v.picklist(["worktree", "current"])), undefined),
+});
 const ThemeOverridesSchema = v.record(v.string(), v.unknown());
 
 function isThemeToken(token: string): token is keyof Theme {
@@ -292,6 +306,11 @@ function applyUi(ui: CueloopConfig["ui"], parsed: v.InferOutput<typeof UiSchema>
   }
 }
 
+function applyReview(review: ReviewConfig, parsed: v.InferOutput<typeof ReviewSchema>): void {
+  if (parsed.skill?.trim()) review.skill = parsed.skill.trim();
+  if (parsed.workspace !== undefined) review.workspace = parsed.workspace;
+}
+
 function layer(
   base: CueloopConfig,
   raw: v.InferOutput<typeof ConfigDocumentSchema>,
@@ -306,6 +325,7 @@ function layer(
     identity: { ...base.identity },
     actions: [...base.actions],
     skillsPath: base.skillsPath,
+    review: { ...base.review },
     integrations: { obsidian: { ...base.integrations.obsidian } },
     experimental: { ...base.experimental },
   };
@@ -316,6 +336,7 @@ function layer(
   const ui = v.safeParse(UiSchema, raw.ui);
   const integrations = v.safeParse(IntegrationsSchema, raw.integrations);
   const experimental = v.safeParse(ExperimentalSchema, raw.experimental);
+  const review = v.safeParse(ReviewSchema, raw.review);
 
   if (actions) out.actions = actions;
   out.skillsPath = skillsPathFrom(raw.skills, base.skillsPath);
@@ -346,6 +367,7 @@ function layer(
   if (experimental.success && experimental.output.prototype_pixels !== undefined) {
     out.experimental.prototypePixels = experimental.output.prototype_pixels;
   }
+  if (review.success) applyReview(out.review, review.output);
 
   return out;
 }
@@ -368,6 +390,7 @@ export function loadConfig(
     identity: { provider: "typed" },
     actions: [...DEFAULT_QUICK_ACTIONS],
     skillsPath: join(homedir(), ".agents", "skills"),
+    review: { skill: "code-review", workspace: "worktree" },
     integrations: { obsidian: { ...OBSIDIAN_DEFAULTS } },
     experimental: { prototypePixels: false },
   };
@@ -458,6 +481,36 @@ function persistUiSetting(key: string, rendered: string, userConfigPath?: string
   writeFileSync(path, text);
 }
 
+function persistTableSetting(
+  table: string,
+  key: string,
+  rendered: string,
+  userConfigPath?: string,
+): void {
+  const path = userConfigPathFrom(userConfigPath);
+  let text = existsSync(path) ? readFileSync(path, "utf8") : "";
+  const escapedTable = escapeRegExp(table);
+  const block = new RegExp(
+    `(^\\[${escapedTable}\\][ \\t]*(?:#[^\\r\\n]*)?\\r?$)([\\s\\S]*?)(?=^\\[|(?![\\s\\S]))`,
+    "m",
+  );
+  const match = block.exec(text);
+
+  if (match) {
+    const assignment = new RegExp(`^(\\s*)${escapeRegExp(key)}\\s*=.*$`, "m");
+    const body = assignment.test(match[2]!)
+      ? match[2]!.replace(assignment, `$1${key} = ${rendered}`)
+      : `\n${key} = ${rendered}${match[2]!}`;
+
+    text =
+      text.slice(0, match.index) + match[1]! + body + text.slice(match.index + match[0].length);
+  } else {
+    text = `${text.trimEnd()}${text.trim() ? "\n\n" : ""}[${table}]\n${key} = ${rendered}\n`;
+  }
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, text);
+}
+
 /** A double-quoted TOML basic string with the quote-breaking characters escaped. */
 function tomlString(value: string): string {
   return `"${value.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\n/g, "\\n")}"`;
@@ -521,6 +574,19 @@ export function persistDiffView(mode: DiffViewMode, userConfigPath?: string): vo
   persistUiSetting("diff_view", `"${mode}"`, userConfigPath);
 }
 
+/** Persist the configured agent review skill (`[review] skill`). */
+export function persistReviewSkill(skill: string, userConfigPath?: string): void {
+  persistTableSetting("review", "skill", tomlString(skill), userConfigPath);
+}
+
+/** Persist where agent review work runs (`[review] workspace`). */
+export function persistReviewWorkspace(
+  workspace: ReviewWorkspaceMode,
+  userConfigPath?: string,
+): void {
+  persistTableSetting("review", "workspace", tomlString(workspace), userConfigPath);
+}
+
 /** Persist the pinned-thread ids (`[ui] pins`) into the user config. */
 export function persistPins(ids: readonly string[], userConfigPath?: string): void {
   persistUiSetting("pins", `[${ids.map(tomlString).join(", ")}]`, userConfigPath);

package/src/index.ts

@@ -1,6 +1,21 @@
 export { runClient, type RunClientOptions } from "./run";
 export { snapshotWorkbench, type RepoDiff } from "./workbench-snapshot";
-export { defaultLayout, planLayout, reviewLayout, type LaunchLayout } from "./launch-layout";
+export {
+  defaultLayout,
+  planLayout,
+  pullRequestReviewLayout,
+  reviewLayout,
+  type LaunchLayout,
+} from "./launch-layout";
+export {
+  diffRowAnchor,
+  diffRows,
+  diffRowText,
+  fileRowRange,
+  resolveReviewAnchorRow,
+  type DiffRow,
+} from "./view-diff";
+export { loadConfig, type ReviewWorkspaceMode } from "./config";
 export { serveClient, type ServeHandle, type ServeOptions } from "./serve";
 export { App, type AppProps } from "./App";
 export {

package/src/intent-dispatch.test.ts

@@ -82,6 +82,7 @@ function baseController(): ReviewController {
     repoFiles: mock(() => Promise.resolve<string[]>([])),
     repoReadFile: mock(() => Promise.resolve<string | null>(null)),
     repoChanges: mock(() => Promise.resolve([])),
+    refreshPullRequest: mock(() => Promise.resolve()),
     open: mock(),
     deleteSession: mock(),
     renameSession: mock(),

package/src/launch-layout.test.ts

@@ -1,5 +1,11 @@
 import { describe, expect, test } from "bun:test";
-import { defaultLayout, layoutFromPanes, planLayout, reviewLayout } from "./launch-layout";
+import {
+  defaultLayout,
+  layoutFromPanes,
+  planLayout,
+  pullRequestReviewLayout,
+  reviewLayout,
+} from "./launch-layout";
 
 describe("launch layout factories", () => {
   test("review opens the diff zoomed with the Changes panel", () => {
@@ -7,6 +13,15 @@ describe("launch layout factories", () => {
     expect(reviewLayout()).toEqual({ threads: true, rightSidebar: "changes", zoomChanges: true });
   });
 
+  test("pull request review keeps its brief beside the Changes panel", () => {
+    // Assert
+    expect(pullRequestReviewLayout()).toEqual({
+      threads: true,
+      rightSidebar: "changes",
+      zoomChanges: false,
+    });
+  });
+
   test("plan fills the middle with the thread pane and no right region", () => {
     // Assert
     expect(planLayout()).toEqual({ threads: true, rightSidebar: "off", zoomChanges: false });

package/src/launch-layout.ts

@@ -14,11 +14,16 @@ export interface LaunchLayout {
   zoomChanges: boolean;
 }
 
-/** `cueloop diff` / `cueloop review`: the diff front and center. */
+/** `cueloop diff`: the diff front and center. */
 export function reviewLayout(): LaunchLayout {
   return { threads: true, rightSidebar: "changes", zoomChanges: true };
 }
 
+/** `cueloop review <pr>`: PR context beside the Changes panel. */
+export function pullRequestReviewLayout(): LaunchLayout {
+  return { threads: true, rightSidebar: "changes", zoomChanges: false };
+}
+
 /** `cueloop plan` / `cueloop reply`: the thread pane fills the middle; no Changes panel. */
 export function planLayout(): LaunchLayout {
   return { threads: true, rightSidebar: "off", zoomChanges: false };

package/src/prototype-browser.test.ts

@@ -1,5 +1,10 @@
-import { describe, expect, test } from "bun:test";
-import { closePrototypeBrowser, cssBoxToCell, imageCellToCss } from "./prototype-browser";
+import { afterEach, describe, expect, mock, test } from "bun:test";
+import {
+  closePrototypeBrowser,
+  cssBoxToCell,
+  imageCellToCss,
+  setPrototypeBrowserForTest,
+} from "./prototype-browser";
 
 const IMAGE = { x: 1, y: 1, width: 80, height: 40 };
 const VIEWPORT = { width: 1280, height: 720 };
@@ -56,9 +61,21 @@ describe("cssBoxToCell", () => {
 });
 
 describe("closePrototypeBrowser", () => {
+  afterEach(() => setPrototypeBrowserForTest(null));
+
   test("is a safe no-op when no prototype browser was ever launched", async () => {
     // the shutdown path calls this on every quit; with no warm Chromium it must not throw or load puppeteer
     await expect(closePrototypeBrowser()).resolves.toBeUndefined();
     await expect(closePrototypeBrowser()).resolves.toBeUndefined();
   });
+
+  test("closes a warm browser once without launching Chrome", async () => {
+    const close = mock(async () => {});
+
+    setPrototypeBrowserForTest({ close });
+    await closePrototypeBrowser();
+    await closePrototypeBrowser();
+
+    expect(close).toHaveBeenCalledTimes(1);
+  });
 });

package/src/prototype-browser.ts

@@ -108,6 +108,13 @@ type PuppeteerBrowser = Awaited<ReturnType<typeof import("puppeteer-core").defau
 // launch is the dominant load cost, so each open only spawns a fresh page.
 let sharedBrowser: Promise<PuppeteerBrowser> | null = null;
 
+/** Install only the browser lifecycle used by unit tests, without launching Chrome. */
+export function setPrototypeBrowserForTest(browser: Pick<PuppeteerBrowser, "close"> | null): void {
+  // SAFETY: tests call only closePrototypeBrowser before resetting this seam, so close is the sole
+  // browser member the shared slot can read while the double is installed.
+  sharedBrowser = browser ? Promise.resolve(browser as PuppeteerBrowser) : null;
+}
+
 async function warmBrowser(executablePath: string | undefined): Promise<PuppeteerBrowser> {
   // reuse the warm browser only while it is still connected; a crashed or
   // disconnected Chromium is dropped so the next open relaunches instead of
@@ -150,13 +157,6 @@ export async function closePrototypeBrowser(): Promise<void> {
   await browser?.close().catch(() => undefined);
 }
 
-/** Test-only: the warm browser's OS process id, or null when none is running. */
-export async function prototypeBrowserPidForTest(): Promise<number | null> {
-  const browser = sharedBrowser ? await sharedBrowser.catch(() => null) : null;
-
-  return browser?.process()?.pid ?? null;
-}
-
 export async function launchPrototypeRenderer(options: LaunchOptions): Promise<PrototypeRenderer> {
   const { pathToFileURL } = await import("node:url");
   const browser = await warmBrowser(options.executablePath);

package/src/theme-presets.ts

@@ -43,6 +43,7 @@ const ROSE_PINE_MOON: Theme = {
   textDim: "#6e6a86",
   accent: "#ea9a97",
   accentInk: "#232136",
+  warning: "#f6c177",
   green: "#9ccfd8",
   red: "#eb6f92",
   blue: "#3e8fb0",
@@ -68,6 +69,7 @@ const CATPPUCCIN_MOCHA: Theme = {
   textDim: "#6c7086",
   accent: "#cba6f7",
   accentInk: "#1e1e2e",
+  warning: "#fab387",
   green: "#a6e3a1",
   red: "#f38ba8",
   blue: "#89b4fa",
@@ -93,6 +95,7 @@ const TOKYO_NIGHT: Theme = {
   textDim: "#565f89",
   accent: "#bb9af7",
   accentInk: "#1a1b26",
+  warning: "#e0af68",
   green: "#9ece6a",
   red: "#f7768e",
   blue: "#7aa2f7",
@@ -118,6 +121,7 @@ const GRUVBOX_DARK: Theme = {
   textDim: "#928374",
   accent: "#fe8019",
   accentInk: "#282828",
+  warning: "#fe8019",
   green: "#b8bb26",
   red: "#fb4934",
   blue: "#83a598",
@@ -143,6 +147,7 @@ const NORD: Theme = {
   textDim: "#4c566a",
   accent: "#88c0d0",
   accentInk: "#2e3440",
+  warning: "#d08770",
   green: "#a3be8c",
   red: "#bf616a",
   blue: "#81a1c1",

package/src/theme.ts

@@ -15,6 +15,7 @@ export interface Theme {
   textDim: string;
   accent: string;
   accentInk: string;
+  warning: string;
   green: string;
   red: string;
   blue: string;
@@ -43,6 +44,7 @@ export function dimmedTheme(theme: Theme): Theme {
     text: theme.textDim,
     textMuted: theme.textDim,
     accent: theme.textDim,
+    warning: theme.textDim,
     green: theme.textDim,
     red: theme.textDim,
     blue: theme.textDim,
@@ -66,6 +68,7 @@ export const DARK: Theme = {
   textDim: "#6b7280",
   accent: "#cba6f7",
   accentInk: "#17171a",
+  warning: "#e5a45c",
   green: "#62d96b",
   red: "#f08080",
   blue: "#a9c8f5",
@@ -96,6 +99,7 @@ export const LIGHT: Theme = {
   textDim: "#868c9c",
   accent: "#5b3ea6",
   accentInk: "#fbfbfa",
+  warning: "#a45f12",
   green: "#2f8a3e",
   red: "#c0392b",
   blue: "#2f6fb0",

package/src/thread-controller.ts

@@ -310,6 +310,8 @@ export interface ReviewController {
   repoReadFile(path: string): Promise<string | null>;
   /** The launch repo's working-tree changed files for the no-session welcome Changes tree. */
   repoChanges(): Promise<readonly DiffFileContents[]>;
+  /** Explicitly pull a PR diff after its head moved. */
+  refreshPullRequest(): Promise<void>;
   /** Open a session from the inbox. */
   open(id: string): void;
   /** Delete a session for good (inbox delete); the inbox refreshes on the event. */
@@ -864,6 +866,17 @@ class Controller implements ReviewController {
     }));
   }
 
+  async refreshPullRequest(): Promise<void> {
+    const session = this.snapshot.session;
+
+    if (!session?.artifact.meta.prRefreshHeadSha || !this.client?.sessionRefreshDiff) return;
+    try {
+      await this.client.sessionRefreshDiff(session.id);
+    } catch (cause) {
+      this.setStatus(cause instanceof Error ? cause.message : String(cause));
+    }
+  }
+
   // Refreshes race the connection teardown: an event can arrive while close()
   // is rejecting in-flight requests, and a fire-and-forget refresh must never
   // surface that as an unhandled rejection.

package/src/use-settings-dialog.tsx

@@ -4,10 +4,13 @@ import {
   persistActions,
   persistAutoClose,
   persistDiffView,
+  persistReviewSkill,
+  persistReviewWorkspace,
   persistTheme,
   type AutoClose,
   type DiffViewMode,
   type QuickAction,
+  type ReviewWorkspaceMode,
 } from "./config";
 import {
   composeTheme,
@@ -90,6 +93,11 @@ export function useSettingsDialog(params: {
   identityProvider: "typed" | "github";
   onSyncGithubIdentity: () => void;
   onRenameDisplayName: () => void;
+  reviewSkill: string;
+  reviewSkillOptions: string[];
+  setReviewSkill: Dispatch<SetStateAction<string>>;
+  reviewWorkspace: ReviewWorkspaceMode;
+  setReviewWorkspace: Dispatch<SetStateAction<ReviewWorkspaceMode>>;
 }): SettingsDialogModel {
   const {
     theme,
@@ -109,6 +117,11 @@ export function useSettingsDialog(params: {
     identityProvider,
     onSyncGithubIdentity,
     onRenameDisplayName,
+    reviewSkill,
+    reviewSkillOptions,
+    setReviewSkill,
+    reviewWorkspace,
+    setReviewWorkspace,
   } = params;
 
   // open focused on the left nav, so up/down browses categories until l/tab/enter enters the body
@@ -190,6 +203,24 @@ export function useSettingsDialog(params: {
         },
       ],
     },
+    {
+      id: "review",
+      name: "Review",
+      rows: [
+        {
+          key: "reviewSkill",
+          label: "Skill",
+          kind: "cycle",
+          options: reviewSkillOptions,
+        },
+        {
+          key: "reviewWorkspace",
+          label: "Workspace",
+          kind: "cycle",
+          options: ["worktree", "current"],
+        },
+      ],
+    },
     {
       id: "actions",
       name: "Actions",
@@ -226,6 +257,8 @@ export function useSettingsDialog(params: {
     displayName: identityName ?? "-- not set --",
     identitySource: identityProvider === "github" ? "GitHub" : "typed",
     syncGithub: "enter to sync",
+    reviewSkill,
+    reviewWorkspace,
   };
   const cycleSetting = (rowKey: string): void => {
     if (rowKey === "autoClose") {
@@ -248,6 +281,17 @@ export function useSettingsDialog(params: {
       onSyncGithubIdentity();
     } else if (rowKey === "displayName") {
       onRenameDisplayName();
+    } else if (rowKey === "reviewSkill") {
+      const current = Math.max(0, reviewSkillOptions.indexOf(reviewSkill));
+      const next = reviewSkillOptions[(current + 1) % reviewSkillOptions.length]!;
+
+      setReviewSkill(next);
+      persistReviewSkill(next);
+    } else if (rowKey === "reviewWorkspace") {
+      const next: ReviewWorkspaceMode = reviewWorkspace === "worktree" ? "current" : "worktree";
+
+      setReviewWorkspace(next);
+      persistReviewWorkspace(next);
     }
   };
 

package/src/view-diff.test.ts

@@ -165,12 +165,154 @@ describe("changesMarks", () => {
     expect([...changesMarks(session, rows).keys()].length).toBeGreaterThan(0);
   });
 
-  test("a pinned diff review paints only artifact notes, not the working tree's file targets", () => {
+  test("a pinned PR diff paints its file-scoped agent findings", () => {
+    const rows = diffRows(PATCH);
+    const finding = {
+      ...fileNote(rows),
+      author: "agent",
+      reviewComment: {
+        severity: "p1" as const,
+        title: "Finding",
+        path: "x.ts",
+        line: 2,
+        side: "RIGHT" as const,
+      },
+    };
+    const session = diffThread({ pr: "org/repo#1" }, [finding]);
+
+    expect([...changesMarks(session, rows).keys()].length).toBeGreaterThan(0);
+  });
+
+  test("an outdated PR finding stays on its recorded line without rebinding", () => {
+    const rows = diffRows(PATCH);
+    const finding: Annotation = {
+      ...fileNote(rows),
+      anchor: { quote: "text that is no longer present", prefix: "", suffix: "" },
+      author: "agent",
+      reviewComment: {
+        severity: "p1",
+        title: "Finding",
+        path: "x.ts",
+        line: 2,
+        side: "RIGHT",
+      },
+    };
+    const session = diffThread({ pr: "org/repo#1" }, [finding]);
+    const marks = changesMarks(session, rows);
+
+    const findingMark = [...marks.values()].flat().find((mark) => mark.annotationId === finding.id);
+
+    expect(findingMark?.outdated).toBe(true);
+  });
+
+  test("a PR finding does not fuzzily rebind to different text", () => {
+    const rows = diffRows(PATCH);
+    const finding: Annotation = {
+      ...fileNote(rows),
+      anchor: {
+        quote: "  private item = new Map();",
+        prefix: "export class Store {",
+        suffix: "}",
+      },
+      author: "agent",
+      reviewComment: {
+        severity: "p1",
+        title: "Finding",
+        path: "x.ts",
+        line: 2,
+        side: "RIGHT",
+      },
+    };
+    const marks = changesMarks(diffThread({ pr: "org/repo#1" }, [finding]), rows);
+    const findingMark = [...marks.values()].flat().find((mark) => mark.annotationId === finding.id);
+
+    expect(findingMark?.outdated).toBe(true);
+    expect(findingMark?.start).toBe(0);
+    expect(findingMark?.end).toBe(0);
+  });
+
+  test("a PR finding on an empty line remains visible with its replies", () => {
+    const patch = `diff --git a/x.ts b/x.ts
+--- a/x.ts
++++ b/x.ts
+@@ -1,1 +1,2 @@
+ const keep = 0;
++
+`;
+    const rows = diffRows(patch);
+    const range = fileRowRange(rows, "x.ts")!;
+    const fileRows = rows.slice(range.start, range.end);
+    const emptyRow = fileRows.findIndex((row) => row.kind === "add" && row.text === "\n");
+    const finding: Annotation = {
+      id: "empty-finding",
+      kind: "comment",
+      anchor: diffRowAnchor(fileRows, emptyRow),
+      target: { kind: "file", path: "x.ts", rev: "worktree" },
+      body: "Keep this blank line.",
+      author: "agent",
+      createdAt: "2026-01-01T00:00:00Z",
+      reviewComment: {
+        severity: "p2",
+        title: "Empty line",
+        path: "x.ts",
+        line: 2,
+        side: "RIGHT",
+      },
+    };
+    const reply: Annotation = {
+      ...finding,
+      id: "empty-reply",
+      body: "Visible reply.",
+      author: "reviewer",
+      replyTo: finding.id,
+      reviewComment: undefined,
+    };
+    const marks = changesMarks(diffThread({ pr: "org/repo#1" }, [finding, reply]), rows);
+    const marked = [...marks.values()].flat();
+    const findingMark = marked.find((mark) => mark.annotationId === finding.id);
+    const replyMark = marked.find((mark) => mark.annotationId === reply.id);
+
+    expect(findingMark).toMatchObject({ start: 0, end: 0 });
+    expect(findingMark?.outdated).toBeUndefined();
+    expect(replyMark?.span).toEqual(findingMark?.span);
+  });
+
+  test("replies stay grouped with an outdated PR finding", () => {
+    const rows = diffRows(PATCH);
+    const finding: Annotation = {
+      ...fileNote(rows),
+      anchor: { quote: "text that is no longer present", prefix: "", suffix: "" },
+      author: "agent",
+      reviewComment: {
+        severity: "p1",
+        title: "Finding",
+        path: "x.ts",
+        line: 2,
+        side: "RIGHT",
+      },
+    };
+    const reply: Annotation = {
+      ...finding,
+      id: "reply-1",
+      author: "reviewer",
+      body: "Keep this discussion visible.",
+      replyTo: finding.id,
+      reviewComment: undefined,
+    };
+    const marks = changesMarks(diffThread({ pr: "org/repo#1" }, [finding, reply]), rows);
+    const marked = [...marks.values()].flat();
+    const findingMark = marked.find((mark) => mark.annotationId === finding.id);
+    const replyMark = marked.find((mark) => mark.annotationId === reply.id);
+
+    expect(replyMark?.span).toEqual(findingMark?.span);
+    expect(replyMark?.outdated).toBe(true);
+  });
+
+  test("a plain pinned diff ignores working-tree 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);
+    expect([...changesMarks(session, rows).keys()]).toEqual([]);
   });
 
   test("a shared snapshot still paints the workbench's file-targeted feedback", () => {