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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cueloop/client",
-  "version": "0.1.0-alpha.65",
+  "version": "0.1.0-alpha.67",
   "description": "The cueloop review UI: projection renderer, keyboard grammar, review rail",
   "homepage": "https://github.com/mmurakaru/cueloop#readme",
   "bugs": {
@@ -26,15 +26,16 @@
     "access": "public"
   },
   "dependencies": {
-    "@cueloop/daemon": "0.1.0-alpha.65",
-    "@cueloop/extension-api": "0.1.0-alpha.65",
-    "@cueloop/integration-obsidian": "0.1.0-alpha.65",
-    "@cueloop/schema": "0.1.0-alpha.65",
+    "@cueloop/daemon": "0.1.0-alpha.67",
+    "@cueloop/extension-api": "0.1.0-alpha.67",
+    "@cueloop/integration-obsidian": "0.1.0-alpha.67",
+    "@cueloop/schema": "0.1.0-alpha.67",
     "@opentui/core": "^0.5.8",
     "@opentui/keymap": "0.5.8",
     "@opentui/react": "^0.5.8",
     "@opentui/ssh": "0.5.8",
     "@pierre/diffs": "^1.3.6",
+    "@tanstack/virtual-core": "^3.17.9",
     "diff": "^9",
     "puppeteer-core": "^25.8.0",
     "react": "^19.2.0",

package/src/App.autoclose.test.tsx

@@ -118,8 +118,8 @@ describe("completion overlay", () => {
     // window before it is delivered - the frame wait absorbs it
     await press(setup, "escape");
 
-    // Assert
-    const frame = await waitForText(setup, "resolved: approve");
+    // Assert - the countdown is cancelled and we are back in the (resolved) thread view
+    const frame = await waitForText(setup, "Ship the thing");
 
     expect(frame).not.toContain("closing in");
   });

package/src/App.diff.test.tsx

@@ -1,4 +1,4 @@
-/** Diff-review flow in the virtual terminal (slice 3). */
+/** Diff-review flow in the virtual terminal: the diff sheet annotates like the thread view. */
 
 import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 import { mkdtempSync, rmSync } from "node:fs";
@@ -9,7 +9,17 @@ import { testRender } from "@opentui/react/test-utils";
 import { DaemonServer } from "@cueloop/daemon";
 import type { ReviewSession } from "@cueloop/schema";
 import { App } from "./App";
-import { isolateUserConfig, press, waitForText } from "./test-support";
+import { NERD } from "./components/primitives/icons";
+import {
+  clickText,
+  dragText,
+  isolateUserConfig,
+  press,
+  pressKey,
+  typeText,
+  waitForState,
+  waitForText,
+} from "./test-support";
 
 const PATCH = `diff --git a/src/store.ts b/src/store.ts
 index 111..222 100644
@@ -43,13 +53,13 @@ afterEach(() => {
   rmSync(home, { recursive: true, force: true });
 });
 
-async function renderApp() {
-  const setup = await testRender(<App home={home} sessionId={session.id} />, {
+async function renderApp(sessionId = session.id) {
+  const setup = await testRender(<App home={home} sessionId={sessionId} />, {
     width: 120,
     height: 30,
   });
 
-  await waitForText(setup, "cueloop");
+  await waitForText(setup, "new Map()");
 
   return setup;
 }
@@ -62,46 +72,74 @@ describe("diff review", () => {
     // Assert
     const frame = setup.captureCharFrame();
 
-    expect(frame).toContain("■ src/store.ts");
+    expect(frame).toContain("src/store.ts");
     expect(frame).toContain("@@ -1,4 +1,4 @@");
-    expect(frame).toContain("-  private items = [];");
-    expect(frame).toContain("+  private items = new Map();");
+    expect(frame).toMatch(/- {2,}private items = \[\];/);
+    expect(frame).toMatch(/\+ {2,}private items = new Map\(\);/);
   });
 
-  test("line comment: quote-anchored, lands in feedback with the code line", async () => {
+  test("a drag marks the code, typing comments on it, and the comment lands in feedback", async () => {
     // Arrange
     const setup = await renderApp();
 
-    // Act
-    // rows: file(0), hunk(1), ctx(2), del(3), add(4)
-    for (let i = 0; i < 4; i++) await press(setup, "j");
-    await press(setup, "c");
+    // Act - mark "new Map()" on the added line and just start typing, as in the thread view
+    await dragText(setup, "new Map()", "new Map()", "new Map()".length);
+    await typeText(setup, "Map needs an eviction story.");
+    await waitForText(setup, "● Map needs an eviction story.");
+    await pressKey(setup, "RETURN", { meta: true });
 
-    // Assert
-    await waitForText(setup, 'comment on "');
+    // Assert - the discussion card hangs under the line; the anchor is the marked words
+    await waitForState(setup, () => server.core.sessionGet(session.id).annotations.length === 1);
+    await waitForText(setup, "● Map needs an eviction story.");
+    expect(server.core.sessionGet(session.id).annotations[0]!.anchor.quote).toBe("new Map()");
 
-    // Act
-    await setup.mockInput.typeText("Map needs an eviction story.");
+    // Act - submit with the session chord (cmd+enter, no composer open), confirm request_changes
+    await pressKey(setup, "RETURN", { meta: true });
     await press(setup, "enter");
 
     // Assert
-    // inline annotation card rendered under the line
-    await waitForText(setup, "◆ Map needs an eviction story.");
-    const stored = server.core.sessionGet(session.id);
+    await waitForText(setup, "feedback sent");
+    const resolved = server.core.sessionGet(session.id);
+
+    expect(resolved.verdict!.feedback).toContain("new Map()");
+    expect(resolved.verdict!.feedback).toContain("Map needs an eviction story.");
+  });
 
-    expect(stored.annotations.length).toBe(1);
-    expect(stored.annotations[0]!.anchor.quote).toContain("new Map()");
+  test("a comment reopens with its mark painted on the code", async () => {
+    // Arrange - a stored comment anchored to the added line's words
+    server.core.sessionAnnotate(session.id, {
+      id: "a_existing",
+      kind: "comment",
+      anchor: { quote: "new Map()", prefix: "  private items = ", suffix: ";" },
+      body: "Existing note.",
+    });
 
     // Act
-    await press(setup, "enter"); // submit
-    await press(setup, "enter"); // confirm request_changes
+    const setup = await renderApp();
 
     // Assert
-    await waitForText(setup, "feedback sent");
-    const resolved = server.core.sessionGet(session.id);
+    await waitForText(setup, "● Existing note.");
+  });
 
-    expect(resolved.verdict!.feedback).toContain("new Map()");
-    expect(resolved.verdict!.feedback).toContain("Map needs an eviction story.");
+  test("option+c folds the caret's file to its band; the chevron restores its body", async () => {
+    // Arrange - the caret opens on the file's first code line
+    const setup = await renderApp();
+
+    // Act
+    await pressKey(setup, "c", { meta: true });
+
+    // Assert - the body is gone but the band (with its counts) remains
+    await waitForState(setup, () => !setup.captureCharFrame().includes("new Map()"));
+    const collapsed = setup.captureCharFrame();
+
+    expect(collapsed).toContain("src/store.ts");
+    expect(collapsed).toContain("+1");
+
+    // Act - the band's chevron unfolds it again
+    await clickText(setup, NERD.chevronRight);
+
+    // Assert
+    await waitForText(setup, "new Map()");
   });
 
   test("curation needs full file contents; a legacy diff answers", async () => {
@@ -109,7 +147,7 @@ describe("diff review", () => {
     const setup = await renderApp();
 
     // Act
-    await press(setup, "x");
+    await pressKey(setup, "x", { meta: true });
 
     // Assert
     await waitForText(setup, "hunk curation needs full file contents");
@@ -133,17 +171,11 @@ describe("diff review", () => {
         ],
       },
     });
-    const setup = await testRender(<App home={home} sessionId={withFiles.id} />, {
-      width: 120,
-      height: 30,
-    });
-
-    await waitForText(setup, "cueloop");
+    const setup = await renderApp(withFiles.id);
 
-    // Act - move to the added line and reject its change
-    // rows: file(0), hunk(1), ctx(2), del(3), add(4)
-    for (let i = 0; i < 4; i++) await press(setup, "j");
-    await press(setup, "x");
+    // Act - place the caret on the added line and reject its change
+    await clickText(setup, "new Map()");
+    await pressKey(setup, "x", { meta: true });
 
     // Assert - the single change is gone, so the curated working copy is empty
     await waitForText(setup, "change rejected");
@@ -152,8 +184,9 @@ describe("diff review", () => {
     expect(stored.workingCopy).toBe("");
   });
 
-  test("a rejected change lists in the rail and undo (u) restores it", async () => {
-    // Arrange - a diff session that carries full file contents
+  test("a diff opens with the Changes column listing every changed file", async () => {
+    // Arrange - two changed files; config.ts is not in the patch text, so it can
+    // only appear here by way of the Changes column reading artifact.files
     const withFiles = server.core.sessionCreate({
       workspace: { repoRoot: "/repo", branch: "main" },
       artifact: {
@@ -161,12 +194,8 @@ describe("diff review", () => {
         content: PATCH,
         meta: { title: "working tree" },
         files: [
-          {
-            path: "src/store.ts",
-            oldContents: "export class Store {\n  private items = [];\n}\n",
-            newContents: "export class Store {\n  private items = new Map();\n}\n",
-            status: "modified",
-          },
+          { path: "src/store.ts", oldContents: "a", newContents: "b", status: "modified" },
+          { path: "src/config.ts", oldContents: "", newContents: "c", status: "added" },
         ],
       },
     });
@@ -177,70 +206,8 @@ describe("diff review", () => {
 
     await waitForText(setup, "cueloop");
 
-    // Act - reject the change under the added line
-    // rows: file(0), hunk(1), ctx(2), del(3), add(4)
-    for (let i = 0; i < 4; i++) await press(setup, "j");
-    await press(setup, "x");
-
-    // Assert - the rail shows a removal card titled REJECT · me for the change
-    await waitForText(setup, "REJECT · me");
-    expect(server.core.sessionGet(withFiles.id).workingCopy).toBe("");
-
-    // Act - undo restores it (no selection, so the last item)
-    await press(setup, "u");
-
-    // Assert - the change returns to the curated diff (working copy cleared)
-    await waitForText(setup, "removal restored");
-    expect(server.core.sessionGet(withFiles.id).workingCopy).toBeUndefined();
-  });
-
-  test("a selected removal card shows an undo button that restores it on click", async () => {
-    // Arrange - a diff session that carries full file contents
-    const withFiles = server.core.sessionCreate({
-      workspace: { repoRoot: "/repo", branch: "main" },
-      artifact: {
-        type: "diff",
-        content: PATCH,
-        meta: { title: "working tree" },
-        files: [
-          {
-            path: "src/store.ts",
-            oldContents: "export class Store {\n  private items = [];\n}\n",
-            newContents: "export class Store {\n  private items = new Map();\n}\n",
-            status: "modified",
-          },
-        ],
-      },
-    });
-    const setup = await testRender(<App home={home} sessionId={withFiles.id} />, {
-      width: 120,
-      height: 30,
-    });
-
-    await waitForText(setup, "cueloop");
-
-    // Act - reject the change; the removal card lands unselected (no undo button)
-    for (let i = 0; i < 4; i++) await press(setup, "j");
-    await press(setup, "x");
-    await waitForText(setup, "REJECT · me");
-    expect(setup.captureCharFrame()).not.toContain("undo");
-
-    // Act - click the card to select it; the undo button appears
-    const clickText = async (needle: string): Promise<void> => {
-      const lines = setup.captureCharFrame().split("\n");
-      const row = lines.findIndex((line) => line.includes(needle));
-
-      await setup.mockMouse.click(lines[row]!.indexOf(needle) + 1, row);
-    };
-
-    await clickText("REJECT · me");
-    await waitForText(setup, "undo");
-
-    // Act - click the undo button
-    await clickText("undo");
-
-    // Assert - the change returns to the curated diff (working copy cleared)
-    await waitForText(setup, "removal restored");
-    expect(server.core.sessionGet(withFiles.id).workingCopy).toBeUndefined();
+    // Assert - the context default opens the column for a diff, so both files show
+    await waitForText(setup, "config.ts");
+    expect(setup.captureCharFrame()).toContain("store.ts");
   });
 });

package/src/App.plan-review.test.tsx

@@ -10,7 +10,6 @@ import { DaemonServer } from "@cueloop/daemon";
 import type { ReviewSession } from "@cueloop/schema";
 import { App } from "./App";
 import { DEFAULT_QUICK_ACTIONS, quickActionBody } from "./config";
-import { DARK } from "./theme";
 import {
   clickText,
   dragText,
@@ -100,14 +99,13 @@ describe("share button", () => {
     const setup = await renderApp();
 
     // Assert
-    // both word-buttons ride the same header row, so Share sits next to Edit
+    // both word-buttons ride the header's thread segment, so share sits next to edit
     const headerLine = setup
       .captureCharFrame()
       .split("\n")
-      .find((line) => line.includes("submitted by"));
+      .find((line) => line.includes("edit"));
 
-    expect(headerLine).toContain("Edit");
-    expect(headerLine).toContain("Share");
+    expect(headerLine).toContain("share");
   });
 
   test("a read-only viewer (a plan shared over ssh) never sees the Share button", async () => {
@@ -120,7 +118,7 @@ describe("share button", () => {
     await waitForText(viewer, "cueloop");
 
     // Assert
-    expect(viewer.captureCharFrame()).not.toContain("Share");
+    expect(viewer.captureCharFrame()).not.toContain(" share ");
   });
 
   test("a resolved plan hides Edit and Share (no re-sharing a finished review)", async () => {
@@ -130,16 +128,13 @@ describe("share button", () => {
     // Act
     const setup = await renderApp();
 
-    await waitForText(setup, "submitted by");
+    await waitForText(setup, "Migration Plan");
 
     // Assert - the owner toolbar is gone once the review is resolved
-    const headerLine = setup
-      .captureCharFrame()
-      .split("\n")
-      .find((line) => line.includes("submitted by"));
+    const frame = setup.captureCharFrame();
 
-    expect(headerLine).not.toContain("Edit");
-    expect(headerLine).not.toContain("Share");
+    expect(frame).not.toContain(" edit ");
+    expect(frame).not.toContain(" share ");
   });
 });
 
@@ -149,7 +144,7 @@ describe("edit affordance", () => {
     const owner = await renderApp();
 
     // Assert
-    expect(owner.captureCharFrame()).toContain("Edit");
+    expect(owner.captureCharFrame()).toContain(" edit ");
   });
 
   test("a read-only viewer (a plan shared over ssh) never sees the Edit button", async () => {
@@ -162,32 +157,7 @@ describe("edit affordance", () => {
     await waitForText(viewer, "cueloop");
 
     // Assert
-    expect(viewer.captureCharFrame()).not.toContain("Edit");
-  });
-});
-
-describe("attribution", () => {
-  test("a collaborator's note shows their name in the card border", async () => {
-    // Arrange - a pulled collaborator note carries an author fingerprint
-    const { makeAnchor, parseBlocks } = await import("@cueloop/schema");
-    const blocks = parseBlocks(PLAN);
-    const contextBlockIndex = blocks.findIndex((block) =>
-      block.text.startsWith("The daemon persists"),
-    );
-
-    server.core.sessionAnnotate(session.id, {
-      id: "collab-1",
-      kind: "comment",
-      anchor: makeAnchor(blocks, contextBlockIndex, 0, 10),
-      body: "who owns retries?",
-      author: "SHA256:1a2b3c4d5e6f",
-    });
-
-    // Act
-    const setup = await renderApp();
-
-    // Assert - the short author handle rides the card border
-    await waitForText(setup, "1a2b3c4d");
+    expect(viewer.captureCharFrame()).not.toContain(" edit ");
   });
 });
 
@@ -299,171 +269,20 @@ describe("compose newline convention", () => {
   });
 });
 
-describe("the document selects, the rail edits", () => {
-  test("option+e edits the focused card in place; enter saves through the controller", async () => {
-    // Arrange
-    const setup = await renderApp();
-
-    await clickText(setup, "daemon");
-    await type(setup, "Needs a citation.");
-    await pressKey(setup, "RETURN", { meta: true });
-    await waitForText(setup, "COMMENT · me");
-
-    // Act: focus the card, then turn its body into an input in place
-    await pressKey(setup, "n", { meta: true });
-    await pressKey(setup, "e", { meta: true });
-    await type(setup, " And a link.");
-    await press(setup, "enter");
-
-    // Assert
-    await waitForState(
-      setup,
-      () =>
-        server.core.sessionGet(session.id).annotations[0]!.body === "Needs a citation. And a link.",
-    );
-  });
-
-  test("activating a collaborator's card opens rename, not a body edit", async () => {
-    // Arrange - a pulled collaborator note carries an author fingerprint
-    const { makeAnchor, parseBlocks } = await import("@cueloop/schema");
-    const blocks = parseBlocks(PLAN);
-    const contextBlockIndex = blocks.findIndex((block) =>
-      block.text.startsWith("The daemon persists"),
-    );
-
-    server.core.sessionAnnotate(session.id, {
-      id: "collab-1",
-      kind: "comment",
-      anchor: makeAnchor(blocks, contextBlockIndex, 0, 10),
-      body: "who owns retries?",
-      author: "SHA256:1a2b3c4d5e6f",
-    });
-    const setup = await renderApp();
-
-    await waitForText(setup, "1a2b3c4d");
-
-    // Act - focus the collaborator card, then activate it
-    await pressKey(setup, "n", { meta: true });
-    await pressKey(setup, "e", { meta: true });
-
-    // Assert - the rename prompt opens; the body never becomes an editor
-    await waitForText(setup, "Rename author");
-  });
-
-  test("option+backspace deletes the focused card and un-paints the document mark", async () => {
-    // Arrange
-    const setup = await renderApp();
-
-    await dragText(setup, "daemon", "daemon persists", "daemon".length);
-    await type(setup, "Delete me.");
-    await pressKey(setup, "RETURN", { meta: true });
-    await waitForText(setup, "COMMENT · me");
-    expect(server.core.sessionGet(session.id).annotations.length).toBe(1);
-    await waitForState(setup, () => backgroundsOf(setup, "daemon").includes(THREAD_MARK));
-
-    // Act
-    await pressKey(setup, "n", { meta: true });
-    await pressKey(setup, "BACKSPACE", { meta: true });
-
-    // Assert
-    await waitForTextGone(setup, "COMMENT · me");
-    expect(server.core.sessionGet(session.id).annotations.length).toBe(0);
-    expect(backgroundsOf(setup, "daemon")).not.toContain(THREAD_MARK);
-  });
-});
-
-describe("plan cut removals", () => {
-  test("option+x cuts the caret's block into a rail removal card and option+u restores it", async () => {
-    // Arrange
-    const setup = await renderApp();
-
-    await clickText(setup, "daemon");
-
-    // Act - no card is focused, so the cut takes the block under the caret
-    await pressKey(setup, "x", { meta: true });
-
-    // Assert - the rail shows a removal card titled CUT · me for the cut block
-    await waitForText(setup, "CUT · me");
-    await waitForState(setup, () => server.core.sessionGet(session.id).workingCopy !== undefined);
-
-    // Act - undo restores it (no selection, so the last removal)
-    await pressKey(setup, "u", { meta: true });
-
-    // Assert - the block returns and the working copy is pristine again
-    await waitForText(setup, "removal restored");
-    await waitForState(setup, () => server.core.sessionGet(session.id).workingCopy === undefined);
-  });
-});
-
-describe("addressed annotations leave the open list", () => {
-  test("a revision that addresses one card hides it, un-paints it, and shows the count", async () => {
-    // Arrange: two annotations through the daemon, then a revision addressing one
-    const { makeAnchor, parseBlocks } = await import("@cueloop/schema");
-    const blocks = parseBlocks(PLAN);
-    const contextBlockIndex = blocks.findIndex((block) =>
-      block.text.startsWith("The daemon persists"),
-    );
-
-    server.core.sessionAnnotate(session.id, {
-      id: "a_settled",
-      kind: "comment",
-      anchor: makeAnchor(blocks, contextBlockIndex, 0, 10), // "The daemon"
-      body: "settled note",
-    });
-    server.core.sessionAnnotate(session.id, {
-      id: "a_open",
-      kind: "comment",
-      anchor: makeAnchor(blocks, contextBlockIndex, 11, 19), // "persists"
-      body: "still open note",
-    });
-    server.core.sessionSubmitRevision(session.id, PLAN, ["a_settled"]);
-
-    // Act
-    const setup = await renderApp();
-
-    await waitForText(setup, "still open note");
-
-    // Assert: the open card renders, the addressed one is gone behind the count
-    const frame = setup.captureCharFrame();
-
-    expect(frame).toContain("✓ 1 addressed by revision");
-    expect(frame).not.toContain("settled note");
-    expect(frame).toContain("still open note"); // the open card survives; the addressed one does not
-    expect(backgroundsOf(setup, "The daemon")).not.toContain(DARK.markCommentBackground); // no highlight paint
-  });
-});
-
 describe("sheet header", () => {
-  test("shows the submitting agent, the revision, and the Edit and Share word-buttons", async () => {
-    // Arrange
-    const setup = await renderApp();
-
-    // Assert
-    const frame = setup.captureCharFrame();
-
-    expect(frame).toContain("submitted by agent/worker-3");
-    expect(frame).toContain("rev 1");
-    expect(frame).toContain("Edit");
-    expect(frame).toContain("Share");
-  });
-
-  test("the Agent tab shows the text-only harness launcher buttons", async () => {
+  test("mirrors the thread name and carries the Edit and Share word-buttons", async () => {
     // Arrange
     const setup = await renderApp();
-    const lines = setup.captureCharFrame().split("\n");
-    const tabRow = lines.findIndex((line) => line.includes("Review") && line.includes("Agent"));
-    const tabColumn = lines[tabRow]!.indexOf("Agent");
-
-    // Act
-    await setup.mockMouse.click(tabColumn + 1, tabRow);
-    await setup.renderOnce();
 
-    // Assert - the three launcher buttons, in order
-    await waitForText(setup, "Claude Code");
+    // Assert - the minimal header shows the thread title (mirror) plus the owner
+    // actions; the revision and submitter metadata are no longer in the header
     const frame = setup.captureCharFrame();
 
-    expect(frame).toContain("Pi");
-    expect(frame).toContain("OpenAI Codex");
+    expect(frame).toContain("Migration Plan");
+    expect(frame).not.toContain("submitted by");
+    expect(frame).not.toContain("rev 1");
+    expect(frame).toContain(" edit ");
+    expect(frame).toContain(" share ");
   });
 });
 
@@ -472,8 +291,9 @@ describe("quick-actions settings editor", () => {
     // Arrange
     const setup = await renderApp();
 
-    // Act - open Settings, enter Actions, expand the first action, type into its input
-    await clickText(setup, "menu");
+    // Act - open Settings from the top-left gear, enter Actions, expand the first action, type
+    await setup.mockMouse.click(1, 0);
+    await waitForText(setup, "Keybinds");
     await clickText(setup, "Settings");
     await clickText(setup, "Actions");
     await clickText(setup, "Zoom out, research in depth");
@@ -502,15 +322,13 @@ describe("edit-exit reconciliation", () => {
       await clickText(setup, "daemon");
       await type(setup, "Anchor me to the doomed passage.");
       await pressKey(setup, "RETURN", { meta: true });
-      await waitForText(setup, "COMMENT · me");
+      await waitForState(setup, () => server.core.sessionGet(session.id).annotations.length === 1);
 
       // Act
       await pressKey(setup, "e", { ctrl: true });
 
-      // Assert
+      // Assert - the thread view banner reports the orphaned annotation
       await waitForText(setup, "1 annotation no longer match - the passage was removed.");
-      // the rail card flips to ORPHANED once the working-copy refresh lands
-      await waitForText(setup, "· ORPHANED");
       // the annotation is NOT deleted: the feedback serializer handles orphans
       expect(server.core.sessionGet(session.id).annotations.length).toBe(1);
     } finally {

package/src/App.prototype.test.tsx

@@ -105,7 +105,7 @@ async function clickText(setup: Setup, needle: string): Promise<void> {
 }
 
 describe("prototype review", () => {
-  test("click an element, comment on it, and it lands in the rail", async () => {
+  test("click an element, comment on it, and it saves to the daemon", async () => {
     // Arrange - wait until the fake browser produced its first screenshot, so
     // the sheet is interactive before the click
     const setup = await renderApp();
@@ -135,13 +135,6 @@ describe("prototype review", () => {
     expect(stored.kind).toBe("comment");
     expect(stored.body).toBe("tighten the padding");
     expect(stored.anchor.selector).toBe("main > div.card");
-
-    // and it renders in the rail
-    await settle(setup);
-    const frame = setup.captureCharFrame();
-
-    expect(frame).toContain("tighten the padding");
-    expect(frame).toContain("COMMENT");
   });
 
   test("escape cancels the compose, matching the plan composer", async () => {