cueloop 0.1.0-alpha.73 → 0.1.0-alpha.74

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cueloop",
-  "version": "0.1.0-alpha.73",
+  "version": "0.1.0-alpha.74",
   "description": "Terminal review surface for coding agents: annotate plans and diffs, return a verdict, send structured feedback back",
   "homepage": "https://github.com/mmurakaru/cueloop#readme",
   "bugs": {
@@ -30,10 +30,10 @@
     "build:binary": "bun build --compile --external cpu-features ./src/main.ts --outfile dist/cueloop"
   },
   "dependencies": {
-    "@cueloop/adapters": "0.1.0-alpha.73",
-    "@cueloop/client": "0.1.0-alpha.73",
-    "@cueloop/daemon": "0.1.0-alpha.73",
-    "@cueloop/schema": "0.1.0-alpha.73",
+    "@cueloop/adapters": "0.1.0-alpha.74",
+    "@cueloop/client": "0.1.0-alpha.74",
+    "@cueloop/daemon": "0.1.0-alpha.74",
+    "@cueloop/schema": "0.1.0-alpha.74",
     "valibot": "^1.4.2"
   },
   "engines": {

package/src/main.ts

@@ -23,9 +23,8 @@ import {
 import { sessionCommand } from "./session-commands";
 import { CLI_VERSION } from "./version";
 import { DaemonClient } from "@cueloop/daemon/client";
-import { workingTreeDiff } from "@cueloop/daemon/working-tree";
 import type { Thread } from "@cueloop/schema";
-import { openReview, resolveWorkspace } from "@cueloop/daemon/review";
+import { openReview } from "@cueloop/daemon/review";
 
 const argv = process.argv.slice(2);
 const cmd = argv[0];
@@ -167,6 +166,7 @@ async function openReviewOfKind(
   match: (session: Thread) => boolean,
   label: string,
   selector: string | undefined,
+  layout: "review" | "plan" | undefined,
   emptyMessage?: string,
 ): Promise<number> {
   const client = await DaemonClient.connect({ autostart: true });
@@ -179,7 +179,7 @@ async function openReviewOfKind(
   }
   const target = resolveOpenTarget(sessions, { match, selector });
 
-  if (target.kind === "session") return runTui(target.sessionId);
+  if (target.kind === "session") return runTui(target.sessionId, layout);
   if (target.kind === "no-pending" && emptyMessage !== undefined) {
     console.error(emptyMessage);
 
@@ -192,7 +192,7 @@ async function openReviewOfKind(
 
 /** `cueloop plan [id|title]` - open the latest pending plan, or address one. */
 async function planCommand(argv: string[]): Promise<number> {
-  return openReviewOfKind(isPlanReview, "plan", openSelector(parseArgs(argv)));
+  return openReviewOfKind(isPlanReview, "plan", openSelector(parseArgs(argv)), "plan");
 }
 
 /**
@@ -201,7 +201,7 @@ async function planCommand(argv: string[]): Promise<number> {
  * by the /cueloop:reply skill; the opener is scope-only, like plan.
  */
 async function replyCommand(argv: string[]): Promise<number> {
-  return openReviewOfKind(isReplyReview, "reply", openSelector(parseArgs(argv)));
+  return openReviewOfKind(isReplyReview, "reply", openSelector(parseArgs(argv)), "plan");
 }
 
 /**
@@ -221,7 +221,7 @@ async function prototypeCommand(argv: string[]): Promise<number> {
     selector !== undefined && !isSessionId(selector) && (isHtmlPrototype || isMarkdownPrototype);
 
   if (wantsOpen || !looksLikeFile)
-    return openReviewOfKind(isPrototypeReview, "prototype", selector);
+    return openReviewOfKind(isPrototypeReview, "prototype", selector, "plan");
 
   const path = resolve(selector);
   const content = await Bun.file(path)
@@ -244,47 +244,30 @@ async function prototypeCommand(argv: string[]): Promise<number> {
 
   client.close();
 
-  return runTui(review.id);
+  return runTui(review.id, "plan");
 }
 
 /**
- * `cueloop diff` disambiguates create from open by intent:
+ * `cueloop diff` opens the repo's workbench in the review layout:
  *   - a selector (`cueloop diff <id|title>`) or an explicit `--open`/`--latest`
- *     opens a pending diff review;
- *   - otherwise a dirty working tree still creates a review as before;
- *   - a clean working tree carries no create input, so it opens the latest
- *     pending diff review instead of erroring.
+ *     opens a specific pending diff thread;
+ *   - a bare `cueloop diff` find-or-creates the per-repo workbench thread - a live-diff
+ *     annotation container - so it is immediately annotatable and always shows the
+ *     current working tree, reusing the same thread across re-runs.
  */
 async function diffCommand(argv: string[]): Promise<number> {
   const parsed = parseArgs(argv);
   const selector = openSelector(parsed);
   const wantsOpen = selector !== undefined || "open" in parsed.flags || "latest" in parsed.flags;
 
-  if (wantsOpen) return openReviewOfKind(isDiffReview, "diff", selector);
+  if (wantsOpen) return openReviewOfKind(isDiffReview, "diff", selector, "review");
 
-  const workspace = await resolveWorkspace();
-  const diff = await workingTreeDiff();
-
-  if (!diff.patch.trim()) {
-    return openReviewOfKind(
-      isDiffReview,
-      "diff",
-      undefined,
-      "working tree is clean and no pending diff review - nothing to open",
-    );
-  }
   const client = await DaemonClient.connect({ autostart: true });
-  const review = await openReview(client, {
-    type: "diff",
-    content: diff.patch,
-    files: diff.files,
-    workspace,
-    title: `working tree @ ${workspace.branch}`,
-  });
+  const workbench = await client.sessionWorkbench(process.cwd());
 
   client.close();
 
-  return runTui(review.id);
+  return runTui(workbench.id, "review");
 }
 
 /**
@@ -310,13 +293,21 @@ async function reviewEntry(argv: string[]): Promise<number> {
     isPrReview,
     "PR",
     explicitOpen || looksLikeSessionId ? selector : undefined,
+    "review",
   );
 }
 
-async function runTui(sessionId?: string): Promise<number> {
-  const { runClient } = await import("@cueloop/client");
+/**
+ * A create-command dictates the pane composition it opens in; a bare launch (`layout`
+ * omitted) restores the remembered one. Resolve the factory here so the heavy client
+ * module stays lazily imported for non-TUI commands.
+ */
+async function runTui(sessionId?: string, layout?: "review" | "plan"): Promise<number> {
+  const { runClient, reviewLayout, planLayout } = await import("@cueloop/client");
+  const resolved =
+    layout === "review" ? reviewLayout() : layout === "plan" ? planLayout() : undefined;
 
-  return runClient({ sessionId });
+  return runClient({ sessionId, layout: resolved });
 }
 
 function printHelp(): void {

package/src/pr.ts

@@ -80,9 +80,9 @@ export async function reviewCommand(argv: string[]): Promise<number> {
     return 0;
   }
 
-  const { runClient } = await import("@cueloop/client");
+  const { runClient, reviewLayout } = await import("@cueloop/client");
 
-  await runClient({ sessionId: session.id });
+  await runClient({ sessionId: session.id, layout: reviewLayout() });
 
   const after = await getSession(session.id);
 

package/src/share-command.test.ts

@@ -133,6 +133,43 @@ describe(shareSession, () => {
     expect(deps.lines).toEqual(["share link copied - ssh p_abc123xy@cueloop.dev"]);
   });
 
+  test("freezes a workbench thread's live diff into the shared artifact", async () => {
+    // Arrange - a workbench thread (renders live locally) plus a daemon that reports a fresh diff
+    const workbench = sessionFixture("ses_wb", {
+      artifact: {
+        type: "diff",
+        content: "STALE",
+        files: [],
+        meta: { workbench: true, title: "Workbench" },
+      },
+    });
+    const client = {
+      ...fakeClient([workbench]),
+      repoDiff: async () => ({
+        patch: "FRESH",
+        files: [{ path: "x.ts", oldContents: "", newContents: "y\n", status: "added" as const }],
+      }),
+    };
+    let published: Thread | undefined;
+    const deps = depsSpy({
+      publish: mock(async (session: Thread) => {
+        published = session;
+
+        return { line: "ssh p_abc123xy@cueloop.dev", copied: true };
+      }),
+    });
+
+    // Act
+    const code = await shareSession(client, { sessionId: "ses_wb" }, deps);
+
+    // Assert - the remote gets the fresh snapshot, marked so it renders frozen while keeping its notes
+    expect(code).toBe(0);
+    expect(published?.artifact.content).toBe("FRESH");
+    expect(published?.artifact.files).toHaveLength(1);
+    expect(published?.artifact.meta.snapshot).toBe(true);
+    expect(published?.artifact.meta.workbench).toBe(true);
+  });
+
   test("without an id, shares the most recent session", async () => {
     // Arrange
     const publish = mock(

package/src/share-command.ts

@@ -12,6 +12,7 @@ import {
   publishShare,
   pullShare,
   shareIdFromLine,
+  snapshotWorkbench,
   type ShareResult,
   type ShareTarget,
 } from "@cueloop/client";
@@ -81,7 +82,11 @@ export async function shareSession(
     return 1;
   }
   const session = params.fork ? await client.sessionFork(picked.id) : picked;
-  const { line, copied } = await deps.publish(session, { host: params.host, port: params.port });
+  // a workbench thread renders live locally; freeze its diff so the remote reviewer gets a stable snapshot
+  const shared = client.repoDiff
+    ? await snapshotWorkbench(session, client.repoDiff.bind(client))
+    : session;
+  const { line, copied } = await deps.publish(shared, { host: params.host, port: params.port });
   const shareId = shareIdFromLine(line);
 
   if (shareId) await client.sessionSetShareId(session.id, shareId);