@cueloop/client 0.1.0-alpha.7 → 0.1.0-alpha.71

package/src/App.readonly.test.tsx

@@ -1,18 +1,23 @@
-/**
- * Observer mode (tier 2): the App with readOnly renders and navigates like the
- * controller's, but every mutating verb answers "observer - read-only" and
- * leaves daemon state untouched.
- */
+/** Observer mode (tier 2): the App with readOnly renders and navigates like the controller's, but every mutating primitive answers "observer - read-only" and leaves daemon state untouched. */
 
 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 { makeAnchor, parseBlocks, type ReviewSession } from "@cueloop/schema";
+import { makeAnchor, parseBlocks, type Thread } from "@cueloop/schema";
 import { App } from "./App";
+import {
+  clickText,
+  dragText,
+  frameRow,
+  isolateUserConfig,
+  pressKey,
+  renderReadyApp,
+  typeText,
+  waitForText,
+} from "./test-support";
 
 const PLAN = `# Migration Plan
 
@@ -27,113 +32,164 @@ The daemon persists sessions to disk atomically.
 `;
 
 let home: string;
+let restoreUserConfig: () => void;
 let server: DaemonServer;
-let session: ReviewSession;
+let session: Thread;
 
 beforeEach(() => {
   home = mkdtempSync(join(tmpdir(), "cueloop-observer-"));
+  restoreUserConfig = isolateUserConfig(home);
   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" } },
+    artifact: {
+      type: "plan",
+      content: PLAN,
+      meta: { title: "Migration Plan", planPath: "plan.md" },
+    },
   });
 });
 afterEach(() => {
+  restoreUserConfig();
   server.stop();
   rmSync(home, { recursive: true, force: true });
 });
 
 async function renderObserver() {
-  const setup = await testRender(<App home={home} sessionId={session.id} readOnly />, {
+  const setup = await renderReadyApp(<App home={home} sessionId={session.id} readOnly />, {
     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. */
+/** Session state that any mutating primitive 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", () => {
-  test("shows the observer badge and read-only hint bar", async () => {
+  test("the minimal header mirrors the thread name, with no observer badge", async () => {
+    // Arrange
     const setup = await renderObserver();
+
+    // Assert - the header shows the thread title only; read-only is enforced by
+    // the blocked primitives below, not a header badge
     const frame = setup.captureCharFrame();
-    expect(frame).toContain("· observer");
-    expect(frame).toContain("observer - read-only · j/k move");
-    expect(frame).not.toContain("⏎ submit");
+
+    expect(frame).toContain("Migration Plan");
+    expect(frame).not.toContain("· observer");
   });
 });
 
-describe("observer verbs are blocked", () => {
-  for (const [key, verb] of [
-    ["c", "comment"],
-    ["s", "suggest"],
-    ["x", "cut"],
-    ["e", "edit"],
-    ["enter", "submit"],
-  ] as const) {
-    test(`${verb} (${key}) answers observer - read-only and mutates nothing`, async () => {
+describe("observer primitives are blocked", () => {
+  const attempts: Array<[string, (setup: Setup) => Promise<void>]> = [
+    ["comment (typing)", (setup) => typeText(setup, "c")],
+    ["cut (option+x)", (setup) => pressKey(setup, "x", { meta: true })],
+    ["edit (ctrl+e)", (setup) => pressKey(setup, "e", { ctrl: true })],
+    ["submit (cmd+enter)", (setup) => pressKey(setup, "RETURN", { meta: true })],
+  ];
+
+  for (const [primitive, attempt] of attempts) {
+    test(`${primitive} answers observer - read-only and mutates nothing`, async () => {
       const setup = await renderObserver();
       const before = snapshot();
-      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");
-      // no overlay opened: compose/submit bars never appear
-      expect(frame).not.toContain("COMMENT ON");
-      expect(frame).not.toContain("SUGGEST REPLACEMENT");
-      expect(frame).not.toContain("verdict ←/→");
+
+      await clickText(setup, "daemon");
+      await attempt(setup);
+      const frame = await waitForText(setup, "observer - read-only");
+
+      // no draft card and no submit card ever appear
+      expect(frame).not.toContain("● c");
+      expect(frame).not.toContain("[Approve]");
       expect(snapshot()).toEqual(before);
     });
   }
 
-  test("span mode c/s is blocked too", async () => {
+  test("typing over a marked span is blocked too", async () => {
+    // Arrange
     const setup = await renderObserver();
-    await press(setup, "j");
-    await press(setup, "j");
-    await press(setup, "v");
-    await press(setup, "c");
-    await setup.renderOnce();
-    const frame = setup.captureCharFrame();
-    expect(frame).toContain("observer - read-only");
-    expect(frame).not.toContain("COMMENT ON");
+
+    // Act
+    await dragText(setup, "The daemon", "daemon persists", "daemon".length);
+    await typeText(setup, "c");
+
+    // Assert
+    const frame = await waitForText(setup, "observer - read-only");
+
+    expect(frame).not.toContain("● c");
     expect(snapshot().annotations).toBe(0);
   });
 });
 
+describe("a resolved review is read-only for its owner too", () => {
+  test("typing, deleting a card, and editing answer review submitted - read-only", async () => {
+    // Arrange: a comment exists and the verdict is in
+    server.core.sessionAnnotate(session.id, {
+      id: "a_done",
+      kind: "comment",
+      anchor: makeAnchor(parseBlocks(PLAN), 2, 0, 10),
+      body: "settled",
+    });
+    server.core.sessionResolve(session.id, "approve", "");
+    const setup = await renderReadyApp(<App home={home} sessionId={session.id} />, {
+      width: 120,
+      height: 32,
+    });
+
+    await waitForText(setup, "settled");
+    const before = snapshot();
+
+    // Act + Assert: a draft never opens
+    await clickText(setup, "daemon");
+    await typeText(setup, "c");
+    await waitForText(setup, "review submitted - read-only");
+    expect(setup.captureCharFrame()).not.toContain("● c");
+
+    // Act + Assert: the focused card cannot be deleted or edited
+    await pressKey(setup, "n", { meta: true });
+    await pressKey(setup, "BACKSPACE", { meta: true });
+    await pressKey(setup, "e", { meta: true });
+    await pressKey(setup, "x", { meta: true });
+    expect(snapshot()).toEqual(before);
+    expect(server.core.sessionGet(session.id).annotations).toHaveLength(1);
+  });
+});
+
 describe("observer navigation still works", () => {
-  test("j/k moves the cursor between blocks", async () => {
+  test("↓ moves the caret between blocks", async () => {
+    // Arrange
     const setup = await renderObserver();
-    await press(setup, "j");
-    await press(setup, "j");
+
+    // Act
+    await pressKey(setup, "ARROW_DOWN");
+    await pressKey(setup, "ARROW_DOWN");
     await setup.renderOnce();
-    const lines = setup.captureCharFrame().split("\n");
-    const cursorLine = lines.find((l) => l.includes("▎"))!;
-    expect(cursorLine).toContain("persists sessions");
+
+    // Assert: the caret cell is painted on the paragraph's row
+    const caretRow = setup
+      .captureSpans()
+      .lines.findIndex((line) =>
+        line.spans.some((span) => span.bg.toInts().slice(0, 3).join() === "86,91,104"),
+      );
+
+    expect(caretRow).toBe(frameRow(setup, "persists sessions"));
   });
 
-  test("n focuses annotations made by the controller", async () => {
+  test("option+n focuses annotations made by the controller", async () => {
+    // Arrange
     server.core.sessionAnnotate(session.id, {
       id: "a_obs1",
       kind: "comment",
@@ -141,8 +197,13 @@ describe("observer navigation still works", () => {
       body: "From the controller.",
     });
     const setup = await renderObserver();
-    await press(setup, "n");
+
+    // Act - the observer navigates to the annotation without mutating anything
+    await pressKey(setup, "n", { meta: true });
     await setup.renderOnce();
-    expect(setup.captureCharFrame()).toContain("▸ COMMENT");
+
+    // Assert - the observer reads the controller's comment inline in the thread
+    await waitForText(setup, "From the controller.");
+    expect(snapshot().annotations).toBe(1);
   });
 });

package/src/App.rendering.test.tsx

@@ -1,14 +1,14 @@
-/** Plan rendering (#67): code blocks verbatim + contained, spacing never collapses. */
+/** 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 type { Thread } from "@cueloop/schema";
 import { App } from "./App";
+import { isolateUserConfig, waitForText, renderReadyApp } from "./test-support";
 
 const PLAN = `# Render Plan
 
@@ -29,11 +29,13 @@ Deploys block below the threshold.
 `;
 
 let home: string;
+let restoreUserConfig: () => void;
 let server: DaemonServer;
-let session: ReviewSession;
+let session: Thread;
 
 beforeEach(() => {
   home = mkdtempSync(join(tmpdir(), "cueloop-render-"));
+  restoreUserConfig = isolateUserConfig(home);
   server = new DaemonServer({ home, idleExitMs: 0 });
   server.start();
   session = server.core.sessionCreate({
@@ -42,67 +44,91 @@ beforeEach(() => {
   });
 });
 afterEach(() => {
+  restoreUserConfig();
   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 });
-  const deadline = Date.now() + 10_000;
-  while (Date.now() < deadline && !setup.captureCharFrame().includes("Render Plan")) {
-    await Bun.sleep(25);
-    await setup.renderOnce();
-  }
-  // give the async highlighter a beat, then take the final frame
-  await Bun.sleep(150);
-  await setup.renderOnce();
+  const setup = await renderReadyApp(<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 f = await frame();
-    expect(f).toContain("  const blocked = full < 0.6;");
-    expect(f).toContain('  return <text>{blocked ? "blocked" : "clear"}</text>;');
+    // Arrange
+    const rendered = await frame();
+
+    // Assert
+    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 f = await frame();
-    expect(f).toContain("tsx");
+    // Arrange
+    const rendered = await frame();
+
+    // Assert
+    expect(rendered).toContain("tsx");
   });
 });
 
 describe("block spacing", () => {
+  // the review rail paints box edges on the right, so read the document
+  // column (everything left of the first rail glyph) before asserting spacing
+  const planColumn = (line: string): string => line.split(/[│╭╰]/)[0]!.trimEnd();
+
   test("a code block never glues to the list item above it", async () => {
-    const lines = (await frame()).split("\n").map((l) => l.trimEnd());
-    const li = lines.findIndex((l) => l.includes("wire the duck over MQTT"));
-    const codeHeader = lines.findIndex((l) => l.trim().startsWith("tsx"));
-    expect(li).toBeGreaterThan(-1);
-    expect(codeHeader).toBeGreaterThan(li);
-    expect(lines.slice(li + 1, codeHeader).some((l) => l === "")).toBe(true);
+    // Arrange
+    const lines = (await frame()).split("\n").map(planColumn);
+    const listItemLineIndex = lines.findIndex((line) => line.includes("wire the duck over MQTT"));
+    const codeHeader = lines.findIndex((line) => line.trim().startsWith("tsx"));
+
+    // Assert
+    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((l) => l.trimEnd());
-    const gate = lines.findIndex((l) => l.trim() === "Gate");
+    // Arrange
+    const lines = (await frame()).split("\n").map(planColumn);
+    const gate = lines.findIndex((line) => line.trim() === "Gate");
+
+    // Assert
     expect(gate).toBeGreaterThan(0);
     expect(lines[gate - 1]).toBe("");
   });
 
   test("consecutive list items stay tight", async () => {
+    // Arrange
     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 });
-    const deadline = Date.now() + 10_000;
-    while (Date.now() < deadline && !setup.captureCharFrame().includes("one")) {
-      await Bun.sleep(25);
-      await setup.renderOnce();
-    }
-    const lines = setup.captureCharFrame().split("\n").map((l) => l.trimEnd());
-    const one = lines.findIndex((l) => l.includes("- one"));
-    expect(lines[one + 1]).toContain("- two");
+    const setup = await renderReadyApp(<App home={home} sessionId={s2.id} />, {
+      width: 120,
+      height: 30,
+    });
+
+    await waitForText(setup, "one");
+
+    // Assert
+    const lines = setup
+      .captureCharFrame()
+      .split("\n")
+      .map((line) => line.trimEnd());
+    const one = lines.findIndex((line) => line.includes("· one"));
+
+    expect(lines[one + 1]).toContain("· two");
   });
 });

package/src/App.submit-confirm.test.tsx

@@ -0,0 +1,191 @@
+/** The send-message confirm: cmd+enter opens a centered overlay with a verdict selector, summary input, and word-buttons. Char-frame assertions over the real App and an in-process daemon, like App.test.tsx. */
+
+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 { makeAnchor, parseBlocks, type Thread } from "@cueloop/schema";
+import { App } from "./App";
+import {
+  isolateUserConfig,
+  press,
+  pressKey,
+  settle,
+  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 restoreUserConfig: () => void;
+let server: DaemonServer;
+let session: Thread;
+
+beforeEach(() => {
+  home = mkdtempSync(join(tmpdir(), "cueloop-confirm-"));
+  restoreUserConfig = isolateUserConfig(home);
+  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" },
+    },
+  });
+});
+afterEach(() => {
+  restoreUserConfig();
+  server.stop();
+  rmSync(home, { recursive: true, force: true });
+});
+
+async function renderApp(options: { readOnly?: boolean } = {}) {
+  const setup = await testRender(
+    <App home={home} sessionId={session.id} readOnly={options.readOnly ?? false} />,
+    {
+      width: 120,
+      height: 32,
+    },
+  );
+
+  await waitForText(setup, "cueloop");
+
+  return setup;
+}
+
+/** Seed annotations directly through the daemon core (all on one block). */
+function seedAnnotations(count: number): void {
+  const blocks = parseBlocks(PLAN);
+
+  for (let index = 1; index <= count; index++) {
+    server.core.sessionAnnotate(session.id, {
+      id: `a_confirm_${index}`,
+      kind: "comment",
+      anchor: makeAnchor(blocks, 2, 0, 10),
+      body: `note ${String(index).padStart(2, "0")}`,
+    });
+  }
+}
+
+describe("send message confirm", () => {
+  test("cmd+enter opens the send-message confirm overlay", async () => {
+    // Arrange
+    const setup = await renderApp();
+
+    // Assert - the footer carries the send control before the overlay opens
+    expect(setup.captureCharFrame()).toContain("send message");
+
+    // Act
+    await pressKey(setup, "RETURN", { meta: true });
+
+    // Assert - the overlay: verdict selector and word-buttons
+    await waitForText(setup, "[Approve]"); // nothing pending: approve default
+    const frame = setup.captureCharFrame();
+
+    expect(frame).toContain("[Approve]");
+    expect(frame).toContain(" send message ");
+    expect(frame).toContain(" Cancel ");
+  });
+
+  test("left/right cycles the verdict selector in the overlay", async () => {
+    // Arrange
+    const setup = await renderApp();
+
+    await pressKey(setup, "RETURN", { meta: true });
+
+    // Assert
+    await waitForText(setup, "[Approve]");
+
+    // Act
+    await press(setup, "right");
+
+    // Assert
+    await waitForText(setup, "[Changes]");
+
+    // Act
+    await press(setup, "right");
+
+    // Assert
+    await waitForText(setup, "[Comment]");
+
+    // Act
+    await press(setup, "left");
+
+    // Assert
+    await waitForText(setup, "[Changes]");
+  });
+
+  test("esc closes the overlay", async () => {
+    // Arrange
+    const setup = await renderApp();
+
+    await pressKey(setup, "RETURN", { meta: true });
+
+    // Assert
+    await waitForText(setup, "[Approve]");
+
+    // Act
+    await press(setup, "escape");
+
+    // Assert - a bare ESC settles after the parser's escape-sequence window
+    const frame = await waitForTextGone(setup, "[Approve]");
+
+    expect(frame).not.toContain(" Cancel ");
+  });
+
+  test("enter in the overlay resolves the session through the controller", async () => {
+    // Arrange
+    seedAnnotations(1);
+    const setup = await renderApp();
+
+    // Act
+    await pressKey(setup, "RETURN", { meta: true });
+
+    // Assert
+    await waitForText(setup, "[Changes]"); // pending items: request changes default
+
+    // Act
+    await setup.mockInput.typeText("Tighten the steps.");
+    await press(setup, "enter");
+
+    // Assert - the completion flow after submit is unchanged
+    await waitForText(setup, "feedback sent");
+    const stored = server.core.sessionGet(session.id);
+
+    expect(stored.status).toBe("resolved");
+    expect(stored.verdict!.kind).toBe("request_changes");
+  });
+
+  test("read-only observers cannot open the confirm overlay", async () => {
+    // Arrange
+    seedAnnotations(1);
+    const setup = await renderApp({ readOnly: true });
+
+    // Act
+    await pressKey(setup, "RETURN", { meta: true });
+    await settle(setup);
+
+    // Assert - no overlay, and the session stays pending
+    const frame = setup.captureCharFrame();
+
+    expect(frame).not.toContain("[Changes]");
+    expect(frame).not.toContain(" Cancel ");
+    expect(server.core.sessionGet(session.id).status).toBe("pending");
+  });
+});