@cueloop/client 0.1.0-alpha.2 → 0.1.0-alpha.20

package/package.json

@@ -1,21 +1,22 @@
 {
   "name": "@cueloop/client",
-  "version": "0.1.0-alpha.2",
+  "version": "0.1.0-alpha.20",
   "license": "Apache-2.0",
   "type": "module",
   "exports": {
     ".": "./src/index.ts"
   },
   "dependencies": {
-    "@cueloop/daemon": "0.1.0-alpha.2",
-    "@cueloop/extension-api": "0.1.0-alpha.2",
-    "@cueloop/integration-obsidian": "0.1.0-alpha.2",
-    "@cueloop/schema": "0.1.0-alpha.2",
-    "@opentui/core": "^0.4.3",
-    "@opentui/react": "^0.4.3",
+    "@cueloop/daemon": "0.1.0-alpha.20",
+    "@cueloop/extension-api": "0.1.0-alpha.20",
+    "@cueloop/integration-obsidian": "0.1.0-alpha.20",
+    "@cueloop/schema": "0.1.0-alpha.20",
+    "@opentui/core": "^0.5.1",
+    "@opentui/keymap": "0.5.1",
+    "@opentui/react": "^0.5.1",
+    "@opentui/ssh": "0.5.1",
     "@pierre/diffs": "^1.3.5",
-    "react": "^19.2.0",
-    "@opentui/ssh": "0.4.5"
+    "react": "^19.2.0"
   },
   "devDependencies": {
     "@types/react": "^19.2.0",
@@ -36,5 +37,10 @@
     "type": "git",
     "url": "git+https://github.com/mmurakaru/cueloop.git",
     "directory": "packages/client"
-  }
-}
+  },
+  "homepage": "https://github.com/mmurakaru/cueloop#readme",
+  "bugs": {
+    "url": "https://github.com/mmurakaru/cueloop/issues"
+  },
+  "description": "The cueloop review UI: projection renderer, keyboard grammar, review rail"
+}

package/src/App.autoclose.test.tsx

@@ -0,0 +1,109 @@
+/**
+ * Post-submit completion overlay: prompt, opt-in persistence, countdown,
+ * dismissal. Countdown seconds tick on an injected ManualClock, so the
+ * tests advance time instead of waiting it out.
+ */
+
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { existsSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import React from "react";
+import { testRender } from "@opentui/react/test-utils";
+import { ManualClock } from "@opentui/core/testing";
+import { DaemonServer } from "@cueloop/daemon";
+import type { ReviewSession } from "@cueloop/schema";
+import { App } from "./App";
+import { press, settle, waitForText } from "./test-support";
+
+const PLAN = "# Plan\n\nShip the thing.\n";
+
+let home: string;
+let server: DaemonServer;
+let session: ReviewSession;
+let configPath: string;
+let clock: ManualClock;
+
+beforeEach(() => {
+  home = mkdtempSync(join(tmpdir(), "cueloop-close-"));
+  configPath = join(home, "config.toml");
+  process.env.CUELOOP_CONFIG = configPath;
+  server = new DaemonServer({ home, idleExitMs: 0 });
+  server.start();
+  session = server.core.sessionCreate({
+    workspace: { repoRoot: "/repo", branch: "main" },
+    artifact: { type: "plan", content: PLAN, meta: { title: "Plan" } },
+  });
+  clock = new ManualClock();
+});
+afterEach(() => {
+  delete process.env.CUELOOP_CONFIG;
+  server.stop();
+  rmSync(home, { recursive: true, force: true });
+});
+
+async function renderApp(onExit?: (code: number) => void) {
+  const setup = await testRender(<App home={home} sessionId={session.id} onExit={onExit} clock={clock} />, {
+    width: 120,
+    height: 30,
+  });
+  await waitForText(setup, "cueloop");
+  return setup;
+}
+
+type Setup = Awaited<ReturnType<typeof renderApp>>;
+
+async function submitApprove(setup: Setup): Promise<void> {
+  await press(setup, "enter"); // open submit (approve default: no pending items)
+  await press(setup, "enter"); // confirm
+  await waitForText(setup, "review approved");
+}
+
+describe("completion overlay", () => {
+  test("submit with auto-close off counts down from 5; ⏎ exits now", async () => {
+    let exited = -1;
+    const setup = await renderApp((code) => (exited = code));
+    await submitApprove(setup);
+    const frame = await waitForText(setup, "closing in 5s");
+    expect(frame).toContain("review approved");
+    expect(frame).toContain("close [return]");
+    expect(frame).toContain("return to plan [esc]");
+    await press(setup, "enter");
+    expect(exited).toBe(0);
+  });
+
+  test("a remembers the countdown as the persisted default", async () => {
+    const setup = await renderApp();
+    await submitApprove(setup);
+    await waitForText(setup, "closing in 5s");
+    await press(setup, "a");
+    expect(existsSync(configPath)).toBe(true);
+    expect(readFileSync(configPath, "utf8")).toContain("auto_close = 5");
+    // the countdown keeps running; each second is one manual-clock tick
+    clock.advance(1000);
+    await waitForText(setup, "closing in 4s");
+  });
+
+  test("esc dismisses to the resolved read-only view", async () => {
+    const setup = await renderApp();
+    await submitApprove(setup);
+    await waitForText(setup, "closing in 5s");
+    // a bare ESC sits in the input parser's escape-sequence disambiguation
+    // window before it is delivered - the frame wait absorbs it
+    await press(setup, "escape");
+    const frame = await waitForText(setup, "resolved: approve");
+    expect(frame).not.toContain("closing in");
+  });
+
+  test("configured auto_close counts down and exits without interaction", async () => {
+    writeFileSync(configPath, "[ui]\nauto_close = 1\n");
+    let exited = -1;
+    const setup = await renderApp((code) => (exited = code));
+    await submitApprove(setup);
+    await waitForText(setup, "closing in 1s");
+    expect(exited).toBe(-1);
+    clock.advance(1000);
+    await settle(setup);
+    expect(exited).toBe(0);
+  });
+});

package/src/App.diff.test.tsx

@@ -9,6 +9,7 @@ import { testRender } from "@opentui/react/test-utils";
 import { DaemonServer } from "@cueloop/daemon";
 import type { ReviewSession } from "@cueloop/schema";
 import { App } from "./App";
+import { press, waitForText } from "./test-support";
 
 const PATCH = `diff --git a/src/store.ts b/src/store.ts
 index 111..222 100644
@@ -41,22 +42,10 @@ afterEach(() => {
 
 async function renderApp() {
   const setup = await testRender(<App home={home} sessionId={session.id} />, { width: 120, height: 30 });
-  for (let i = 0; i < 40 && !setup.captureCharFrame().includes("cueloop"); i++) {
-    await Bun.sleep(25);
-    await setup.renderOnce();
-  }
-  await setup.renderOnce();
+  await waitForText(setup, "cueloop");
   return setup;
 }
 
-type Setup = Awaited<ReturnType<typeof renderApp>>;
-async function press(setup: Setup, k: string): Promise<void> {
-  if (k === "enter") setup.mockInput.pressKey("RETURN");
-  else await setup.mockInput.typeText(k);
-  await Bun.sleep(15);
-  await setup.renderOnce();
-}
-
 describe("diff review", () => {
   test("renders file header, hunks, and signed lines", async () => {
     const setup = await renderApp();
@@ -75,17 +64,15 @@ describe("diff review", () => {
     expect(setup.captureCharFrame()).toContain("COMMENT ON");
     await setup.mockInput.typeText("Map needs an eviction story.");
     await press(setup, "enter");
-    await Bun.sleep(80);
-    await setup.renderOnce();
+    // inline annotation card rendered under the line
+    await waitForText(setup, "◆ Map needs an eviction story.");
     const stored = server.core.sessionGet(session.id);
     expect(stored.annotations.length).toBe(1);
     expect(stored.annotations[0]!.anchor.quote).toContain("new Map()");
-    // inline annotation card rendered under the line
-    expect(setup.captureCharFrame()).toContain("◆ Map needs an eviction story.");
 
     await press(setup, "enter"); // submit
     await press(setup, "enter"); // confirm request_changes
-    await Bun.sleep(100);
+    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.");

package/src/App.export.test.tsx

@@ -13,6 +13,7 @@ import { testRender } from "@opentui/react/test-utils";
 import { DaemonServer } from "@cueloop/daemon";
 import type { ReviewSession } from "@cueloop/schema";
 import { App } from "./App";
+import { press, waitForState, waitForText } from "./test-support";
 
 const PLAN = `# Migration Plan
 
@@ -50,22 +51,16 @@ afterEach(() => {
 describe("obsidian export on resolve", () => {
   test("submitting a review writes the plan into the vault and shows the path", async () => {
     const setup = await testRender(<App home={home} sessionId={session.id} />, { width: 120, height: 32 });
-    for (let i = 0; i < 40 && !setup.captureCharFrame().includes("cueloop"); i++) {
-      await Bun.sleep(25);
-      await setup.renderOnce();
-    }
+    await waitForText(setup, "cueloop");
     // open the submit overlay, keep the default verdict (approve), submit
-    setup.mockInput.pressKey("RETURN");
-    await Bun.sleep(15);
-    await setup.renderOnce();
+    await press(setup, "enter");
     expect(setup.captureCharFrame()).toContain("verdict");
-    setup.mockInput.pressKey("RETURN");
+    await press(setup, "enter");
+    // the export is an async round-trip after resolve; the status line lands
+    // on a later render than the file write
     const dir = join(vault, "cueloop");
-    for (let i = 0; i < 40 && !existsSync(dir); i++) {
-      await Bun.sleep(25);
-      await setup.renderOnce();
-    }
-    await setup.renderOnce();
+    await waitForState(setup, () => existsSync(dir));
+    await waitForText(setup, "exported to");
 
     const notes = readdirSync(dir);
     expect(notes.length).toBe(1);

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

@@ -0,0 +1,232 @@
+/**
+ * The plan review surface v2: native selection feeds the annotation
+ * quote, the inline compose box keeps its anchor painted, the rail edits what
+ * the document selects, and edit-exit reconciliation orphans annotations
+ * whose passage was removed. Char-frame + styled-span assertions over the
+ * real App and a real in-process daemon.
+ */
+
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import React from "react";
+import { testRender } from "@opentui/react/test-utils";
+import { DaemonServer } from "@cueloop/daemon";
+import type { ReviewSession } from "@cueloop/schema";
+import { App } from "./App";
+import { DARK as T } from "./theme";
+import { press, settle, typeText as type, waitForState, waitForText, waitForTextGone } from "./test-support";
+
+const PLAN = `# Migration Plan
+
+## Context
+
+The daemon persists sessions to disk atomically.
+
+## Steps
+
+- move the store
+- add recovery
+`;
+
+let home: string;
+let server: DaemonServer;
+let session: ReviewSession;
+
+beforeEach(() => {
+  home = mkdtempSync(join(tmpdir(), "cueloop-plan-review-"));
+  server = new DaemonServer({ home, idleExitMs: 0 });
+  server.start();
+  session = server.core.sessionCreate({
+    workspace: { repoRoot: "/repo", branch: "main" },
+    artifact: { type: "plan", content: PLAN, meta: { title: "Migration Plan", planPath: "plan.md", agent: "agent/worker-3" } },
+  });
+});
+afterEach(() => {
+  server.stop();
+  rmSync(home, { recursive: true, force: true });
+});
+
+async function renderApp() {
+  const setup = await testRender(<App home={home} sessionId={session.id} />, {
+    width: 120,
+    height: 32,
+  });
+  await waitForText(setup, "cueloop");
+  return setup;
+}
+
+type Setup = Awaited<ReturnType<typeof renderApp>>;
+
+/**
+ * Background colors (hex) of every styled span containing the needle - the
+ * document highlight and the rail's quote excerpt can both match.
+ */
+function backgroundsOf(setup: Setup, needle: string): string[] {
+  const backgrounds: string[] = [];
+  for (const line of setup.captureSpans().lines) {
+    for (const span of line.spans) {
+      if (!span.text.includes(needle)) continue;
+      const [red, green, blue] = span.bg.toInts();
+      backgrounds.push("#" + [red, green, blue].map((part) => part.toString(16).padStart(2, "0")).join(""));
+    }
+  }
+  return backgrounds;
+}
+
+/** Move the cursor to "The daemon persists sessions to disk atomically." */
+async function toContextParagraph(setup: Setup): Promise<void> {
+  await press(setup, "j");
+  await press(setup, "j");
+}
+
+describe("selection feeds the annotation quote", () => {
+  test("v anchors, l extends, c composes with the char-precise quote", async () => {
+    const setup = await renderApp();
+    await toContextParagraph(setup);
+    await press(setup, "v");
+    await press(setup, "l"); // "The daemon"
+    await press(setup, "c");
+    expect(setup.captureCharFrame()).toContain('comment on "The daemon"');
+    await type(setup, "Which daemon?");
+    await press(setup, "enter");
+    await waitForState(setup, () => server.core.sessionGet(session.id).annotations.length === 1);
+    const stored = server.core.sessionGet(session.id);
+    expect(stored.annotations[0]!.anchor.quote).toBe("The daemon");
+  });
+
+  test("a mouse drag over the text becomes the compose quote", async () => {
+    const setup = await renderApp();
+    const lines = setup.captureCharFrame().split("\n");
+    const row = lines.findIndex((line) => line.includes("persists sessions"));
+    const startColumn = lines[row]!.indexOf("persists");
+    expect(row).toBeGreaterThan(-1);
+    // the drag's end cell is exclusive: release one past the last character
+    await setup.mockMouse.drag(startColumn, row, startColumn + "persists sessions".length, row);
+    await settle(setup);
+    await press(setup, "c");
+    expect(setup.captureCharFrame()).toContain('comment on "persists sessions"');
+    await type(setup, "sessions plural?");
+    await press(setup, "enter");
+    await waitForState(setup, () => server.core.sessionGet(session.id).annotations.length === 1);
+    const stored = server.core.sessionGet(session.id);
+    expect(stored.annotations[0]!.anchor.quote).toBe("persists sessions");
+  });
+});
+
+describe("inline compose keeps the anchor painted", () => {
+  test("the selection stays painted while composing; cancel un-paints; save converts to the comment highlight", async () => {
+    const setup = await renderApp();
+    await toContextParagraph(setup);
+    await press(setup, "v");
+    await press(setup, "l");
+    await press(setup, "c");
+    // compose open: the anchor is painted selection-style. The box can render
+    // a frame before the anchor repaint settles, so wait on the color itself.
+    expect(setup.captureCharFrame()).toContain("Save ⏎");
+    expect(setup.captureCharFrame()).toContain("Cancel esc");
+    await waitForState(setup, () => backgroundsOf(setup, "The daemon").includes(T.accent));
+    expect(backgroundsOf(setup, "The daemon")).toContain(T.accent);
+    // cancel un-paints (a bare ESC settles after the parser's escape window)
+    await press(setup, "escape");
+    await waitForTextGone(setup, 'comment on "');
+    expect(backgroundsOf(setup, "The daemon")).not.toContain(T.accent);
+    // save converts the paint to the kind-colored annotation highlight
+    await press(setup, "c");
+    await type(setup, "Which daemon?");
+    await press(setup, "enter");
+    await waitForState(setup, () => server.core.sessionGet(session.id).annotations.length === 1);
+    await settle(setup);
+    // the whole cursor block is the anchor here; check the highlight landed
+    const stored = server.core.sessionGet(session.id);
+    expect(stored.annotations.length).toBe(1);
+    expect(backgroundsOf(setup, stored.annotations[0]!.anchor.quote.slice(0, 20))).toContain(T.markCommentBg);
+    // renderApp plus this many frame-waits grazes the 5s default on a loaded CI
+    // runner; the sibling walk resume test carries the same budget.
+  }, 15_000);
+});
+
+describe("the document selects, the rail edits", () => {
+  test("e edits the selected card in place; enter saves through the controller", async () => {
+    const setup = await renderApp();
+    await toContextParagraph(setup);
+    await press(setup, "c");
+    await type(setup, "Needs a citation.");
+    await press(setup, "enter");
+    await waitForText(setup, "COMMENT · pending");
+    // the saved card is selected; e turns its body into an input in place
+    await press(setup, "e");
+    await type(setup, " And a link.");
+    await press(setup, "enter");
+    await waitForState(
+      setup,
+      () => server.core.sessionGet(session.id).annotations[0]!.body === "Needs a citation. And a link.",
+    );
+  });
+
+  test("x deletes the selected card and un-paints the document highlight", async () => {
+    const setup = await renderApp();
+    await toContextParagraph(setup);
+    await press(setup, "c");
+    await type(setup, "Delete me.");
+    await press(setup, "enter");
+    await waitForText(setup, "COMMENT · pending");
+    expect(server.core.sessionGet(session.id).annotations.length).toBe(1);
+    expect(backgroundsOf(setup, "persists sessions")).toContain(T.markCommentBg);
+    await press(setup, "x");
+    await waitForTextGone(setup, "COMMENT · pending");
+    expect(server.core.sessionGet(session.id).annotations.length).toBe(0);
+    expect(backgroundsOf(setup, "persists sessions")).not.toContain(T.markCommentBg);
+  });
+});
+
+describe("sheet header", () => {
+  test("shows the submitting agent, the revision, and the Edit word-button", async () => {
+    const setup = await renderApp();
+    const frame = setup.captureCharFrame();
+    expect(frame).toContain("submitted by agent/worker-3 · revision 1");
+    expect(frame).toContain("Edit");
+  });
+
+  test("the Agent tab shows the submitter, status, and revision", async () => {
+    const setup = await renderApp();
+    const lines = setup.captureCharFrame().split("\n");
+    const tabRow = lines.findIndex((line) => line.includes("Review (0)"));
+    const tabColumn = lines[tabRow]!.indexOf("Agent");
+    await setup.mockMouse.click(tabColumn + 1, tabRow);
+    await setup.renderOnce();
+    const frame = setup.captureCharFrame();
+    expect(frame).toContain("agent/worker-3");
+    expect(frame).toContain("status: pending");
+    expect(frame).toContain("revision 1");
+  });
+});
+
+describe("edit-exit reconciliation", () => {
+  test("an edit that removes an anchored passage orphans the annotation and shows the banner", async () => {
+    const script = join(home, "fake-editor.sh");
+    await Bun.write(script, `#!/bin/sh\nsed -i '' '/^The daemon persists/d' "$1"\n`);
+    Bun.spawnSync(["chmod", "+x", script]);
+    process.env.CUELOOP_EDITOR = script;
+    try {
+      const setup = await renderApp();
+      await toContextParagraph(setup);
+      await press(setup, "c");
+      await type(setup, "Anchor me to the doomed passage.");
+      await press(setup, "enter");
+      await waitForText(setup, "· pending");
+      // deselect the card so e reaches the editor hand-off, then edit
+      await press(setup, "escape");
+      await waitForTextGone(setup, "▸ COMMENT");
+      await press(setup, "e");
+      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 {
+      delete process.env.CUELOOP_EDITOR;
+    }
+  });
+});

package/src/App.readonly.test.tsx

@@ -13,6 +13,7 @@ import { testRender } from "@opentui/react/test-utils";
 import { DaemonServer } from "@cueloop/daemon";
 import { makeAnchor, parseBlocks, type ReviewSession } from "@cueloop/schema";
 import { App } from "./App";
+import { press, waitForText } from "./test-support";
 
 const PLAN = `# Migration Plan
 
@@ -49,27 +50,14 @@ async function renderObserver() {
     width: 120,
     height: 32,
   });
-  for (let i = 0; i < 40 && !setup.captureCharFrame().includes("cueloop"); i++) {
-    await Bun.sleep(25);
-    await setup.renderOnce();
-  }
-  await setup.renderOnce();
+  await waitForText(setup, "cueloop");
   return setup;
 }
 
-type Setup = Awaited<ReturnType<typeof renderObserver>>;
-
-async function press(setup: Setup, k: string): Promise<void> {
-  if (k === "enter") setup.mockInput.pressKey("RETURN");
-  else await setup.mockInput.typeText(k);
-  await Bun.sleep(15);
-  await setup.renderOnce();
-}
-
 /** Session state that any mutating verb would change. */
 function snapshot() {
-  const s = server.core.sessionGet(session.id);
-  return { annotations: s.annotations.length, workingCopy: s.workingCopy, status: s.status };
+  const stored = server.core.sessionGet(session.id);
+  return { annotations: stored.annotations.length, workingCopy: stored.workingCopy, status: stored.status };
 }
 
 describe("observer rendering", () => {
@@ -96,10 +84,7 @@ describe("observer verbs are blocked", () => {
       await press(setup, "j");
       await press(setup, "j");
       await press(setup, key);
-      await Bun.sleep(60);
-      await setup.renderOnce();
-      const frame = setup.captureCharFrame();
-      expect(frame).toContain("observer - read-only");
+      const frame = await waitForText(setup, "observer - read-only");
       // no overlay opened: compose/submit bars never appear
       expect(frame).not.toContain("COMMENT ON");
       expect(frame).not.toContain("SUGGEST REPLACEMENT");
@@ -129,7 +114,7 @@ describe("observer navigation still works", () => {
     await press(setup, "j");
     await setup.renderOnce();
     const lines = setup.captureCharFrame().split("\n");
-    const cursorLine = lines.find((l) => l.includes("▎"))!;
+    const cursorLine = lines.find((line) => line.includes("▎"))!;
     expect(cursorLine).toContain("persists sessions");
   });
 

package/src/App.rendering.test.tsx

@@ -0,0 +1,100 @@
+/** Plan rendering: code blocks verbatim + contained, spacing never collapses. */
+
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import React from "react";
+import { testRender } from "@opentui/react/test-utils";
+import { DaemonServer } from "@cueloop/daemon";
+import type { ReviewSession } from "@cueloop/schema";
+import { App } from "./App";
+import { waitForText } from "./test-support";
+
+const PLAN = `# Render Plan
+
+## Sensor
+
+- wire the duck over MQTT
+
+\`\`\`tsx
+export function Gate({ full }: { full: number }) {
+  const blocked = full < 0.6;
+  return <text>{blocked ? "blocked" : "clear"}</text>;
+}
+\`\`\`
+
+## Gate
+
+Deploys block below the threshold.
+`;
+
+let home: string;
+let server: DaemonServer;
+let session: ReviewSession;
+
+beforeEach(() => {
+  home = mkdtempSync(join(tmpdir(), "cueloop-render-"));
+  server = new DaemonServer({ home, idleExitMs: 0 });
+  server.start();
+  session = server.core.sessionCreate({
+    workspace: { repoRoot: "/repo", branch: "main" },
+    artifact: { type: "plan", content: PLAN, meta: { title: "Render Plan" } },
+  });
+});
+afterEach(() => {
+  server.stop();
+  rmSync(home, { recursive: true, force: true });
+});
+
+async function frame(): Promise<string> {
+  const setup = await testRender(<App home={home} sessionId={session.id} />, { width: 120, height: 36 });
+  await waitForText(setup, "Render Plan");
+  // async highlights settle within the visual-idle wait
+  await setup.waitForVisualIdle();
+  return setup.captureCharFrame();
+}
+
+describe("code blocks", () => {
+  test("lines render verbatim: indentation preserved, no word-wrap", async () => {
+    const rendered = await frame();
+    expect(rendered).toContain("  const blocked = full < 0.6;");
+    expect(rendered).toContain('  return <text>{blocked ? "blocked" : "clear"}</text>;');
+  });
+
+  test("the block carries its language tag", async () => {
+    const rendered = await frame();
+    expect(rendered).toContain("tsx");
+  });
+});
+
+describe("block spacing", () => {
+  test("a code block never glues to the list item above it", async () => {
+    const lines = (await frame()).split("\n").map((line) => line.trimEnd());
+    const listItemLineIndex = lines.findIndex((line) => line.includes("wire the duck over MQTT"));
+    const codeHeader = lines.findIndex((line) => line.trim().startsWith("tsx"));
+    expect(listItemLineIndex).toBeGreaterThan(-1);
+    expect(codeHeader).toBeGreaterThan(listItemLineIndex);
+    expect(lines.slice(listItemLineIndex + 1, codeHeader).some((line) => line === "")).toBe(true);
+  });
+
+  test("a heading never sits directly on the previous block", async () => {
+    const lines = (await frame()).split("\n").map((line) => line.trimEnd());
+    const gate = lines.findIndex((line) => line.trim() === "Gate");
+    expect(gate).toBeGreaterThan(0);
+    expect(lines[gate - 1]).toBe("");
+  });
+
+  test("consecutive list items stay tight", async () => {
+    const listPlan = "# T\n\n- one\n- two\n";
+    const s2 = server.core.sessionCreate({
+      workspace: { repoRoot: "/repo", branch: "main" },
+      artifact: { type: "plan", content: listPlan, meta: {} },
+    });
+    const setup = await testRender(<App home={home} sessionId={s2.id} />, { width: 120, height: 30 });
+    await waitForText(setup, "one");
+    const lines = setup.captureCharFrame().split("\n").map((line) => line.trimEnd());
+    const one = lines.findIndex((line) => line.includes("- one"));
+    expect(lines[one + 1]).toContain("- two");
+  });
+});