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

package/package.json

@@ -1,16 +1,16 @@
 {
   "name": "@cueloop/client",
-  "version": "0.1.0-alpha.20",
+  "version": "0.1.0-alpha.22",
   "license": "Apache-2.0",
   "type": "module",
   "exports": {
     ".": "./src/index.ts"
   },
   "dependencies": {
-    "@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",
+    "@cueloop/daemon": "0.1.0-alpha.22",
+    "@cueloop/extension-api": "0.1.0-alpha.22",
+    "@cueloop/integration-obsidian": "0.1.0-alpha.22",
+    "@cueloop/schema": "0.1.0-alpha.22",
     "@opentui/core": "^0.5.1",
     "@opentui/keymap": "0.5.1",
     "@opentui/react": "^0.5.1",

package/src/App.autoclose.test.tsx

@@ -1,8 +1,4 @@
-/**
- * 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.
- */
+/** Post-submit completion overlay: prompt, opt-in persistence, countdown, dismissal. Countdown seconds tick on an injected ManualClock, so 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";
@@ -61,49 +57,77 @@ async function submitApprove(setup: Setup): Promise<void> {
 
 describe("completion overlay", () => {
   test("submit with auto-close off counts down from 5; ⏎ exits now", async () => {
+    // Arrange
     let exited = -1;
     const setup = await renderApp((code) => (exited = code));
+
+    // Act
     await submitApprove(setup);
+
+    // Assert
     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]");
+
+    // Act
     await press(setup, "enter");
+
+    // Assert
     expect(exited).toBe(0);
   });
 
   test("a remembers the countdown as the persisted default", async () => {
+    // Arrange
     const setup = await renderApp();
     await submitApprove(setup);
     await waitForText(setup, "closing in 5s");
+
+    // Act
     await press(setup, "a");
+
+    // Assert
     expect(existsSync(configPath)).toBe(true);
     expect(readFileSync(configPath, "utf8")).toContain("auto_close = 5");
+
+    // Act
     // the countdown keeps running; each second is one manual-clock tick
     clock.advance(1000);
+
+    // Assert
     await waitForText(setup, "closing in 4s");
   });
 
   test("esc dismisses to the resolved read-only view", async () => {
+    // Arrange
     const setup = await renderApp();
     await submitApprove(setup);
     await waitForText(setup, "closing in 5s");
+
+    // Act
     // 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");
+
+    // Assert
     const frame = await waitForText(setup, "resolved: approve");
     expect(frame).not.toContain("closing in");
   });
 
   test("configured auto_close counts down and exits without interaction", async () => {
+    // Arrange
     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);
+
+    // Act
     clock.advance(1000);
     await settle(setup);
+
+    // Assert
     expect(exited).toBe(0);
   });
 });

package/src/App.diff.test.tsx

@@ -48,7 +48,10 @@ async function renderApp() {
 
 describe("diff review", () => {
   test("renders file header, hunks, and signed lines", async () => {
+    // Arrange
     const setup = await renderApp();
+
+    // Assert
     const frame = setup.captureCharFrame();
     expect(frame).toContain("■ src/store.ts");
     expect(frame).toContain("@@ -1,4 +1,4 @@");
@@ -57,21 +60,33 @@ describe("diff review", () => {
   });
 
   test("line comment: quote-anchored, lands in feedback with the code line", 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");
+
+    // Assert
     expect(setup.captureCharFrame()).toContain("COMMENT ON");
+
+    // Act
     await setup.mockInput.typeText("Map needs an eviction story.");
     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);
     expect(stored.annotations.length).toBe(1);
     expect(stored.annotations[0]!.anchor.quote).toContain("new Map()");
 
+    // Act
     await press(setup, "enter"); // submit
     await press(setup, "enter"); // confirm request_changes
+
+    // Assert
     await waitForText(setup, "feedback sent");
     const resolved = server.core.sessionGet(session.id);
     expect(resolved.verdict!.feedback).toContain("new Map()");
@@ -79,8 +94,13 @@ describe("diff review", () => {
   });
 
   test("plan verbs are guarded in diff sessions", async () => {
+    // Arrange
     const setup = await renderApp();
+
+    // Act
     await press(setup, "x");
+
+    // Assert
     expect(setup.captureCharFrame()).toContain("plan-only verb");
   });
 });

package/src/App.export.test.tsx

@@ -1,8 +1,4 @@
-/**
- * Tier-2 wiring test for the notes-vault export: with [integrations.obsidian]
- * configured to export on resolve, submitting a review writes the note into
- * the vault and surfaces the path in the status line.
- */
+/** Tier-2 wiring for the notes-vault export: with [integrations.obsidian] set to export on resolve, submitting a review writes the note into the vault and surfaces the path in the status line. */
 
 import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 import { existsSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, rmSync, writeFileSync } from "node:fs";
@@ -50,12 +46,20 @@ afterEach(() => {
 
 describe("obsidian export on resolve", () => {
   test("submitting a review writes the plan into the vault and shows the path", async () => {
+    // Arrange
     const setup = await testRender(<App home={home} sessionId={session.id} />, { width: 120, height: 32 });
     await waitForText(setup, "cueloop");
-    // open the submit overlay, keep the default verdict (approve), submit
-    await press(setup, "enter");
+
+    // Act
+    await press(setup, "enter"); // open the submit overlay, keep the default verdict (approve)
+
+    // Assert
     expect(setup.captureCharFrame()).toContain("verdict");
-    await press(setup, "enter");
+
+    // Act
+    await press(setup, "enter"); // submit
+
+    // Assert
     // 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");

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

@@ -1,10 +1,4 @@
-/**
- * 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.
- */
+/** 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";
@@ -81,34 +75,62 @@ async function toContextParagraph(setup: Setup): Promise<void> {
   await press(setup, "j");
 }
 
+describe("share button", () => {
+  test("the owner's rail shows the one-click Share button", async () => {
+    // Arrange / Act
+    const setup = await renderApp();
+
+    // Assert
+    expect(setup.captureCharFrame()).toContain("Share plan");
+  });
+});
+
 describe("selection feeds the annotation quote", () => {
   test("v anchors, l extends, c composes with the char-precise quote", async () => {
+    // Arrange
     const setup = await renderApp();
     await toContextParagraph(setup);
+
+    // Act
     await press(setup, "v");
     await press(setup, "l"); // "The daemon"
     await press(setup, "c");
+
+    // Assert
     expect(setup.captureCharFrame()).toContain('comment on "The daemon"');
+
+    // Act
     await type(setup, "Which daemon?");
     await press(setup, "enter");
+
+    // Assert
     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 () => {
+    // Arrange
     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);
+
+    // Act
     // 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");
+
+    // Assert
     expect(setup.captureCharFrame()).toContain('comment on "persists sessions"');
+
+    // Act
     await type(setup, "sessions plural?");
     await press(setup, "enter");
+
+    // Assert
     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");
@@ -117,25 +139,38 @@ describe("selection feeds the annotation quote", () => {
 
 describe("inline compose keeps the anchor painted", () => {
   test("the selection stays painted while composing; cancel un-paints; save converts to the comment highlight", async () => {
+    // Arrange
     const setup = await renderApp();
     await toContextParagraph(setup);
+
+    // Act
     await press(setup, "v");
     await press(setup, "l");
     await press(setup, "c");
+
+    // Assert
     // 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);
+
+    // Act
     // cancel un-paints (a bare ESC settles after the parser's escape window)
     await press(setup, "escape");
+
+    // Assert
     await waitForTextGone(setup, 'comment on "');
     expect(backgroundsOf(setup, "The daemon")).not.toContain(T.accent);
+
+    // Act
     // save converts the paint to the kind-colored annotation highlight
     await press(setup, "c");
     await type(setup, "Which daemon?");
     await press(setup, "enter");
+
+    // Assert
     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
@@ -147,18 +182,107 @@ describe("inline compose keeps the anchor painted", () => {
   }, 15_000);
 });
 
+describe("compose newline convention", () => {
+  // Option/Alt and Shift reach the App as `meta`/`shift` on the return key.
+  // modifyOtherKeys encoding preserves those modifiers so the grammar and the
+  // focused textarea can tell a bare submit from a newline.
+  async function renderModifierAwareApp() {
+    const setup = await testRender(<App home={home} sessionId={session.id} />, {
+      width: 120,
+      height: 32,
+      otherModifiersMode: true,
+    });
+    await waitForText(setup, "cueloop");
+    return setup;
+  }
+
+  async function pressReturnWith(setup: Setup, modifiers: { shift?: boolean; meta?: boolean }): Promise<void> {
+    setup.mockInput.pressKey("RETURN", modifiers);
+    await settle(setup);
+  }
+
+  test("option+return inserts a newline; a bare return submits the multiline body", async () => {
+    // Arrange
+    const setup = await renderModifierAwareApp();
+    await toContextParagraph(setup);
+    await press(setup, "v");
+    await press(setup, "l");
+    await press(setup, "c");
+    await waitForText(setup, 'comment on "The daemon"');
+
+    // Act
+    await type(setup, "first line");
+    await pressReturnWith(setup, { meta: true }); // option/alt+return -> newline
+    await type(setup, "second line");
+
+    // Assert
+    // still composing: the newline did not submit
+    expect(server.core.sessionGet(session.id).annotations.length).toBe(0);
+
+    // Act
+    await press(setup, "enter"); // bare return -> save
+
+    // Assert
+    await waitForState(setup, () => server.core.sessionGet(session.id).annotations.length === 1);
+    expect(server.core.sessionGet(session.id).annotations[0]!.body).toBe("first line\nsecond line");
+  });
+
+  test("shift+return still inserts a newline (existing muscle memory)", async () => {
+    // Arrange
+    const setup = await renderModifierAwareApp();
+    await toContextParagraph(setup);
+    await press(setup, "c");
+
+    // Act
+    await type(setup, "alpha");
+    await pressReturnWith(setup, { shift: true }); // shift+return -> newline
+    await type(setup, "beta");
+
+    // Assert
+    expect(server.core.sessionGet(session.id).annotations.length).toBe(0);
+
+    // Act
+    await press(setup, "enter");
+
+    // Assert
+    await waitForState(setup, () => server.core.sessionGet(session.id).annotations.length === 1);
+    expect(server.core.sessionGet(session.id).annotations[0]!.body).toBe("alpha\nbeta");
+  });
+
+  test("escape cancels the composer without saving", async () => {
+    // Arrange
+    const setup = await renderModifierAwareApp();
+    await toContextParagraph(setup);
+    await press(setup, "c");
+    await waitForText(setup, 'comment on "');
+    await type(setup, "never saved");
+
+    // Act
+    await press(setup, "escape");
+
+    // Assert
+    await waitForTextGone(setup, 'comment on "');
+    expect(server.core.sessionGet(session.id).annotations.length).toBe(0);
+  });
+});
+
 describe("the document selects, the rail edits", () => {
   test("e edits the selected card in place; enter saves through the controller", async () => {
+    // Arrange
     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");
+
+    // Act
     // 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");
+
+    // Assert
     await waitForState(
       setup,
       () => server.core.sessionGet(session.id).annotations[0]!.body === "Needs a citation. And a link.",
@@ -166,6 +290,7 @@ describe("the document selects, the rail edits", () => {
   });
 
   test("x deletes the selected card and un-paints the document highlight", async () => {
+    // Arrange
     const setup = await renderApp();
     await toContextParagraph(setup);
     await press(setup, "c");
@@ -174,28 +299,73 @@ describe("the document selects, the rail edits", () => {
     await waitForText(setup, "COMMENT · pending");
     expect(server.core.sessionGet(session.id).annotations.length).toBe(1);
     expect(backgroundsOf(setup, "persists sessions")).toContain(T.markCommentBg);
+
+    // Act
     await press(setup, "x");
+
+    // Assert
     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("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("Review (1)"); // the addressed card no longer counts as pending
+    expect(backgroundsOf(setup, "The daemon")).not.toContain(T.markCommentBg); // no highlight paint
+  });
+});
+
 describe("sheet header", () => {
   test("shows the submitting agent, the revision, and the Edit word-button", async () => {
+    // Arrange
     const setup = await renderApp();
+
+    // Assert
     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 () => {
+    // Arrange
     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");
+
+    // Act
     await setup.mockMouse.click(tabColumn + 1, tabRow);
     await setup.renderOnce();
+
+    // Assert
     const frame = setup.captureCharFrame();
     expect(frame).toContain("agent/worker-3");
     expect(frame).toContain("status: pending");
@@ -210,16 +380,21 @@ describe("edit-exit reconciliation", () => {
     Bun.spawnSync(["chmod", "+x", script]);
     process.env.CUELOOP_EDITOR = script;
     try {
+      // Arrange
       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");
+
+      // Act
       // deselect the card so e reaches the editor hand-off, then edit
       await press(setup, "escape");
       await waitForTextGone(setup, "▸ COMMENT");
       await press(setup, "e");
+
+      // Assert
       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");

package/src/App.readonly.test.tsx

@@ -1,8 +1,4 @@
-/**
- * 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 verb answers "observer - read-only" and leaves daemon state untouched. */
 
 import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 import { mkdtempSync, rmSync } from "node:fs";
@@ -62,7 +58,10 @@ function snapshot() {
 
 describe("observer rendering", () => {
   test("shows the observer badge and read-only hint bar", async () => {
+    // Arrange
     const setup = await renderObserver();
+
+    // Assert
     const frame = setup.captureCharFrame();
     expect(frame).toContain("· observer");
     expect(frame).toContain("observer - read-only · j/k move");
@@ -94,12 +93,17 @@ describe("observer verbs are blocked", () => {
   }
 
   test("span mode c/s is blocked too", async () => {
+    // Arrange
     const setup = await renderObserver();
+
+    // Act
     await press(setup, "j");
     await press(setup, "j");
     await press(setup, "v");
     await press(setup, "c");
     await setup.renderOnce();
+
+    // Assert
     const frame = setup.captureCharFrame();
     expect(frame).toContain("observer - read-only");
     expect(frame).not.toContain("COMMENT ON");
@@ -109,16 +113,22 @@ describe("observer verbs are blocked", () => {
 
 describe("observer navigation still works", () => {
   test("j/k moves the cursor between blocks", async () => {
+    // Arrange
     const setup = await renderObserver();
+
+    // Act
     await press(setup, "j");
     await press(setup, "j");
     await setup.renderOnce();
+
+    // Assert
     const lines = setup.captureCharFrame().split("\n");
     const cursorLine = lines.find((line) => line.includes("▎"))!;
     expect(cursorLine).toContain("persists sessions");
   });
 
   test("n focuses annotations made by the controller", async () => {
+    // Arrange
     server.core.sessionAnnotate(session.id, {
       id: "a_obs1",
       kind: "comment",
@@ -126,8 +136,12 @@ describe("observer navigation still works", () => {
       body: "From the controller.",
     });
     const setup = await renderObserver();
+
+    // Act
     await press(setup, "n");
     await setup.renderOnce();
+
+    // Assert
     expect(setup.captureCharFrame()).toContain("▸ COMMENT");
   });
 });

package/src/App.rendering.test.tsx

@@ -57,35 +57,52 @@ async function frame(): Promise<string> {
 
 describe("code blocks", () => {
   test("lines render verbatim: indentation preserved, no word-wrap", async () => {
+    // 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 () => {
+    // Arrange
     const rendered = await frame();
+
+    // Assert
     expect(rendered).toContain("tsx");
   });
 });
 
 describe("block spacing", () => {
+  // the review panel's full-height divider paints a `│` on every row, so read
+  // the plan column (everything left of the divider) 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((line) => line.trimEnd());
+    // 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((line) => line.trimEnd());
+    // 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" },
@@ -93,6 +110,8 @@ describe("block spacing", () => {
     });
     const setup = await testRender(<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");