cueloop 0.1.0-alpha.20 → 0.1.0-alpha.22

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cueloop",
-  "version": "0.1.0-alpha.20",
+  "version": "0.1.0-alpha.22",
   "license": "Apache-2.0",
   "type": "module",
   "bin": {
@@ -10,9 +10,9 @@
     ".": "./src/main.ts"
   },
   "dependencies": {
-    "@cueloop/schema": "0.1.0-alpha.20",
-    "@cueloop/daemon": "0.1.0-alpha.20",
-    "@cueloop/client": "0.1.0-alpha.20"
+    "@cueloop/schema": "0.1.0-alpha.22",
+    "@cueloop/daemon": "0.1.0-alpha.22",
+    "@cueloop/client": "0.1.0-alpha.22"
   },
   "publishConfig": {
     "access": "public"

package/src/main.ts

@@ -1,16 +1,26 @@
 #!/usr/bin/env bun
 /**
- * cueloop entry points: `cueloop` opens the TUI on the inbox,
- * `cueloop diff` reviews the working tree, `cueloop review <pr>` a PR,
- * `cueloop session *` mirrors the daemon API for agents and scripts,
- * `cueloop serve` shares a session over ssh (read-only observers),
- * `cueloop daemon` runs the daemon in the foreground.
+ * cueloop entry points: `cueloop` opens the TUI on the inbox, the verb-first
+ * openers `cueloop plan|diff|review` open the latest pending review of that
+ * type (or address one by id/title), `cueloop diff`/`cueloop review <pr>` also
+ * keep their create paths, `cueloop session *` mirrors the daemon API for
+ * agents and scripts, `cueloop serve` shares a session over ssh (read-only
+ * observers), `cueloop daemon` runs the daemon in the foreground.
  */
 
-import { parseArgs, stringFlag } from "./args";
+import { parseArgs, stringFlag, type ParsedArgs } from "./args";
+import {
+  isDiffReview,
+  isPlanReview,
+  isPrReview,
+  isSessionId,
+  openTargetMessage,
+  resolveOpenTarget,
+} from "./open-target";
 import { sessionCommand } from "./session-commands";
 import { workingTreeDiff } from "./working-tree";
 import { DaemonClient } from "@cueloop/daemon/client";
+import type { ReviewSession } from "@cueloop/schema";
 import { openReview, resolveWorkspace } from "@cueloop/daemon/review";
 
 const argv = process.argv.slice(2);
@@ -32,23 +42,10 @@ async function main(): Promise<number> {
       await new Promise(() => {}); // run until signalled
       return 0;
     }
-    case "diff": {
-      const workspace = await resolveWorkspace();
-      const diff = await workingTreeDiff();
-      if (!diff.trim()) {
-        console.error("working tree is clean - nothing to review");
-        return 1;
-      }
-      const client = await DaemonClient.connect({ autostart: true });
-      const review = await openReview(client, {
-        type: "diff",
-        content: diff,
-        workspace,
-        title: `working tree @ ${workspace.branch}`,
-      });
-      client.close();
-      return runTui(review.id);
-    }
+    case "plan":
+      return planCommand(argv.slice(1));
+    case "diff":
+      return diffCommand(argv.slice(1));
     case "serve": {
       const { positional, flags } = parseArgs(argv.slice(1));
       const port = stringFlag(flags, "port");
@@ -75,10 +72,18 @@ async function main(): Promise<number> {
       await new Promise(() => {}); // serve until signalled
       return 0;
     }
-    case "review": {
-      const { reviewCommand } = await import("./pr");
-      return reviewCommand(argv.slice(1));
+    case "share": {
+      const { positional, flags } = parseArgs(argv.slice(1));
+      const { shareCommand } = await import("./share-command");
+      const port = stringFlag(flags, "port");
+      return shareCommand({
+        sessionId: positional[0],
+        host: stringFlag(flags, "host"),
+        port: port !== undefined ? Number(port) : undefined,
+      });
     }
+    case "review":
+      return reviewEntry(argv.slice(1));
     case "review-post": {
       const { reviewPostCommand } = await import("./pr");
       return reviewPostCommand(argv.slice(1));
@@ -98,6 +103,103 @@ async function main(): Promise<number> {
   }
 }
 
+/**
+ * The id-or-title selector for a verb-first opener: the bare positional, or a
+ * value handed to `--open`/`--latest`. A bare `--latest`/`--open` flag carries
+ * no value, so the selector stays undefined and the opener defaults to the
+ * latest pending review.
+ */
+function openSelector(parsed: ParsedArgs): string | undefined {
+  return parsed.positional[0] ?? stringFlag(parsed.flags, "open") ?? stringFlag(parsed.flags, "latest");
+}
+
+/**
+ * Resolve one review of the verb's scope and open it in the TUI, or print the
+ * miss and fail. `emptyMessage` overrides the default no-pending line for the
+ * one caller that needs a scope-specific hint (a clean working tree).
+ */
+async function openReviewOfKind(
+  match: (session: ReviewSession) => boolean,
+  label: string,
+  selector: string | undefined,
+  emptyMessage?: string,
+): Promise<number> {
+  const client = await DaemonClient.connect({ autostart: true });
+  let sessions: ReviewSession[];
+  try {
+    sessions = await client.sessionList();
+  } finally {
+    client.close();
+  }
+  const target = resolveOpenTarget(sessions, { match, selector });
+  if (target.kind === "session") return runTui(target.sessionId);
+  if (target.kind === "no-pending" && emptyMessage !== undefined) {
+    console.error(emptyMessage);
+    return 1;
+  }
+  console.error(openTargetMessage(label, target));
+  return 1;
+}
+
+/** `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)));
+}
+
+/**
+ * `cueloop diff` disambiguates create from open by intent:
+ *   - 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.
+ */
+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);
+
+  const workspace = await resolveWorkspace();
+  const diff = await workingTreeDiff();
+  if (!diff.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,
+    workspace,
+    title: `working tree @ ${workspace.branch}`,
+  });
+  client.close();
+  return runTui(review.id);
+}
+
+/**
+ * `cueloop review` disambiguates create from open by intent:
+ *   - bare `cueloop review`, `--open`/`--latest`, or a `ses_*` selector opens a
+ *     pending PR review (a diff carrying a `pr` reference);
+ *   - any other positional is a PR reference and takes the create path in pr.ts.
+ */
+async function reviewEntry(argv: string[]): Promise<number> {
+  const parsed = parseArgs(argv);
+  const explicitOpen = "open" in parsed.flags || "latest" in parsed.flags;
+  const selector = openSelector(parsed);
+  const looksLikeSessionId = selector !== undefined && isSessionId(selector);
+  const wantsCreate = !explicitOpen && !looksLikeSessionId && selector !== undefined;
+  if (wantsCreate) {
+    const { reviewCommand } = await import("./pr");
+    return reviewCommand(argv);
+  }
+  return openReviewOfKind(isPrReview, "PR", explicitOpen || looksLikeSessionId ? selector : undefined);
+}
+
 async function runTui(sessionId?: string): Promise<number> {
   const { runClient } = await import("@cueloop/client");
   return runClient({ sessionId });
@@ -111,12 +213,18 @@ function printHelp(): void {
       "usage:",
       "  cueloop                          open the inbox",
       "  cueloop <session-id>             open one session",
-      "  cueloop diff                     review the working tree",
+      "  cueloop plan [id|title]          open the latest pending plan review (or one by id/title)",
+      "  cueloop diff [id|title]          open the latest pending diff review (or one by id/title);",
+      "                                   with a dirty working tree and no argument, create one instead",
+      "  cueloop review [id|title]        open the latest pending PR review (or one by id/title)",
       "  cueloop review <pr>              review a pull request (--no-tui prints the session)",
+      "  cueloop <plan|diff|review> --latest  open the latest pending review of that type",
       "  cueloop review-post <id> <pr>    post a resolved session's verdict back to the PR",
       "  cueloop serve [session-id]       share over ssh: observers are read-only,",
       "                                   you stay the controller (--port 2222, --host 127.0.0.1;",
       "                                   password-less - share the address deliberately)",
+      "  cueloop share [session-id]       hand a plan to a teammate: copies one",
+      "                                   ssh line (--host cueloop.dev, --port 22)",
       "  cueloop session <verb> [flags]   script the daemon (create|get|list|wait|annotate|resolve|submit-revision)",
       "  cueloop daemon                   run the daemon in the foreground",
     ].join("\n"),

package/src/open-target.test.ts

@@ -0,0 +1,214 @@
+/** Verb-first open resolution over a plain session list: latest-pending default, by-id, and fuzzy-by-title (exact wins, unique substring wins, else ambiguous). Pure over the array - no daemon, no TUI. */
+
+import { describe, expect, test } from "bun:test";
+import type { ArtifactType, ReviewSession } from "@cueloop/schema";
+import {
+  isDiffReview,
+  isPlanReview,
+  isPrReview,
+  isSessionId,
+  openTargetMessage,
+  resolveOpenTarget,
+} from "./open-target";
+
+function session(overrides: {
+  id: string;
+  type?: ArtifactType;
+  title?: string;
+  status?: "pending" | "resolved";
+  createdAt?: string;
+  pr?: string;
+}): ReviewSession {
+  return {
+    schemaVersion: "1",
+    id: overrides.id,
+    workspace: { repoRoot: "/repo", branch: "main" },
+    artifact: {
+      type: overrides.type ?? "plan",
+      content: "",
+      meta: { title: overrides.title, pr: overrides.pr },
+    },
+    revisions: [],
+    annotations: [],
+    verdict: overrides.status === "resolved" ? { kind: "approve", summary: "", feedback: "", resolvedAt: "" } : null,
+    status: overrides.status ?? "pending",
+    createdAt: overrides.createdAt ?? "2026-01-01T00:00:00.000Z",
+  };
+}
+
+const isPlan = isPlanReview;
+
+describe("verb scope predicates are disjoint", () => {
+  test("isPlanReview matches only plan artifacts", () => {
+    expect(isPlanReview(session({ id: "ses_p", type: "plan" }))).toBe(true);
+    expect(isPlanReview(session({ id: "ses_d", type: "diff" }))).toBe(false);
+  });
+
+  test("isDiffReview matches a plain diff but NOT a diff carrying meta.pr", () => {
+    expect(isDiffReview(session({ id: "ses_d", type: "diff" }))).toBe(true);
+    expect(isDiffReview(session({ id: "ses_pr", type: "diff", pr: "42" }))).toBe(false);
+    expect(isDiffReview(session({ id: "ses_p", type: "plan" }))).toBe(false);
+  });
+
+  test("isPrReview matches a diff carrying meta.pr, and only that", () => {
+    expect(isPrReview(session({ id: "ses_pr", type: "diff", pr: "42" }))).toBe(true);
+    expect(isPrReview(session({ id: "ses_d", type: "diff" }))).toBe(false);
+    expect(isPrReview(session({ id: "ses_p", type: "plan" }))).toBe(false);
+  });
+
+  test("a PR review resolves under exactly one scope - never both diff and review", () => {
+    // Arrange
+    const prReview = session({ id: "ses_pr", type: "diff", pr: "42" });
+
+    // Assert
+    expect(isDiffReview(prReview)).toBe(false);
+    expect(isPrReview(prReview)).toBe(true);
+  });
+});
+
+describe("isSessionId", () => {
+  test("only the ses_ prefix reads as an id", () => {
+    expect(isSessionId("ses_abc")).toBe(true);
+    expect(isSessionId("some title")).toBe(false);
+    expect(isSessionId("42")).toBe(false);
+  });
+});
+
+describe("resolveOpenTarget: latest pending default", () => {
+  test("picks the most recent pending session in scope", () => {
+    // Arrange
+    const sessions = [
+      session({ id: "ses_old", createdAt: "2026-01-01T00:00:00.000Z" }),
+      session({ id: "ses_new", createdAt: "2026-03-01T00:00:00.000Z" }),
+      session({ id: "ses_mid", createdAt: "2026-02-01T00:00:00.000Z" }),
+    ];
+
+    // Assert
+    expect(resolveOpenTarget(sessions, { match: isPlan })).toEqual({ kind: "session", sessionId: "ses_new" });
+  });
+
+  test("ignores resolved sessions and other artifact types", () => {
+    // Arrange
+    const sessions = [
+      session({ id: "ses_resolved", createdAt: "2026-05-01T00:00:00.000Z", status: "resolved" }),
+      session({ id: "ses_diff", type: "diff", createdAt: "2026-04-01T00:00:00.000Z" }),
+      session({ id: "ses_plan", createdAt: "2026-02-01T00:00:00.000Z" }),
+    ];
+
+    // Assert
+    expect(resolveOpenTarget(sessions, { match: isPlan })).toEqual({ kind: "session", sessionId: "ses_plan" });
+  });
+
+  test("no pending session in scope reports no-pending", () => {
+    // Arrange
+    const sessions = [session({ id: "ses_done", status: "resolved" })];
+
+    // Assert
+    expect(resolveOpenTarget(sessions, { match: isPlan })).toEqual({ kind: "no-pending" });
+  });
+});
+
+describe("resolveOpenTarget: by id", () => {
+  test("an exact session id in scope opens that session, pending or not", () => {
+    // Arrange
+    const sessions = [
+      session({ id: "ses_a" }),
+      session({ id: "ses_b", status: "resolved" }),
+    ];
+
+    // Assert
+    expect(resolveOpenTarget(sessions, { match: isPlan, selector: "ses_b" })).toEqual({
+      kind: "session",
+      sessionId: "ses_b",
+    });
+  });
+
+  test("an id outside the scope does not match", () => {
+    // Arrange
+    const sessions = [session({ id: "ses_diff", type: "diff" })];
+
+    // Assert
+    expect(resolveOpenTarget(sessions, { match: isPlan, selector: "ses_diff" })).toEqual({
+      kind: "no-match",
+      selector: "ses_diff",
+    });
+  });
+});
+
+describe("resolveOpenTarget: fuzzy by title", () => {
+  test("case-insensitive exact title wins over substring rivals", () => {
+    // Arrange
+    const sessions = [
+      session({ id: "ses_exact", title: "Rollout" }),
+      session({ id: "ses_sub", title: "Rollout plan v2" }),
+    ];
+
+    // Assert
+    expect(resolveOpenTarget(sessions, { match: isPlan, selector: "rollout" })).toEqual({
+      kind: "session",
+      sessionId: "ses_exact",
+    });
+  });
+
+  test("a unique case-insensitive substring match wins", () => {
+    // Arrange
+    const sessions = [
+      session({ id: "ses_auth", title: "Auth rewrite" }),
+      session({ id: "ses_cache", title: "Cache warmup" }),
+    ];
+
+    // Assert
+    expect(resolveOpenTarget(sessions, { match: isPlan, selector: "AUTH" })).toEqual({
+      kind: "session",
+      sessionId: "ses_auth",
+    });
+  });
+
+  test("several substring matches are ambiguous and list the candidate titles", () => {
+    // Arrange
+    const sessions = [
+      session({ id: "ses_1", title: "Payments rollout" }),
+      session({ id: "ses_2", title: "Rollout of search" }),
+    ];
+
+    // Assert
+    expect(resolveOpenTarget(sessions, { match: isPlan, selector: "rollout" })).toEqual({
+      kind: "ambiguous",
+      selector: "rollout",
+      titles: ["Payments rollout", "Rollout of search"],
+    });
+  });
+
+  test("no title match reports no-match", () => {
+    // Arrange
+    const sessions = [session({ id: "ses_1", title: "Auth rewrite" })];
+
+    // Assert
+    expect(resolveOpenTarget(sessions, { match: isPlan, selector: "billing" })).toEqual({
+      kind: "no-match",
+      selector: "billing",
+    });
+  });
+});
+
+describe("openTargetMessage", () => {
+  test("no-pending mirrors the clean-tree tone", () => {
+    expect(openTargetMessage("plan", { kind: "no-pending" })).toBe("no pending plan review - nothing to open");
+  });
+
+  test("no-match names the selector", () => {
+    expect(openTargetMessage("diff", { kind: "no-match", selector: "billing" })).toBe(
+      'no diff review matches "billing" - nothing to open',
+    );
+  });
+
+  test("ambiguous lists the candidate titles", () => {
+    // Act
+    const message = openTargetMessage("plan", { kind: "ambiguous", selector: "rollout", titles: ["A", "B"] });
+
+    // Assert
+    expect(message).toContain('"rollout" matches several plan reviews');
+    expect(message).toContain("  - A");
+    expect(message).toContain("  - B");
+  });
+});

package/src/open-target.ts

@@ -0,0 +1,106 @@
+/**
+ * Verb-first review-open resolution: turn a verb (plan/diff/review) plus an
+ * optional id-or-title selector into a single session to open, or a clear
+ * miss. Pure over a session list so it unit-tests without a daemon or a TUI -
+ * main.ts fetches the sessions and prints the miss messages.
+ *
+ * Rules, in order:
+ *   - no selector opens the latest pending session in scope (most recent
+ *     createdAt, verdict still open) - the `--latest` default;
+ *   - a selector that exactly equals a session id opens that session, pending
+ *     or resolved;
+ *   - otherwise the selector matches session titles, case-insensitive: an
+ *     exact title wins, else a unique substring match wins, else the substring
+ *     candidates are reported as ambiguous.
+ * Every lookup is scoped by the caller's `match` predicate, so a verb only
+ * ever resolves to its own artifact kind.
+ */
+
+import type { ReviewSession } from "@cueloop/schema";
+
+/**
+ * The verb scopes, kept disjoint on purpose so a single session never resolves
+ * under two verbs. A PR review is a diff artifact that carries a `pr`
+ * reference (openReview maps a top-level `pr` into `meta.pr`), so the plain
+ * diff scope must exclude those - otherwise `cueloop diff` and `cueloop
+ * review` would both open the same pending PR review.
+ */
+export function isPlanReview(session: ReviewSession): boolean {
+  return session.artifact.type === "plan";
+}
+export function isDiffReview(session: ReviewSession): boolean {
+  return session.artifact.type === "diff" && session.artifact.meta.pr === undefined;
+}
+export function isPrReview(session: ReviewSession): boolean {
+  return session.artifact.type === "diff" && session.artifact.meta.pr !== undefined;
+}
+
+/** Session ids are minted with this prefix; the id-vs-title split lives here. */
+export function isSessionId(value: string): boolean {
+  return value.startsWith("ses_");
+}
+
+export interface OpenTargetQuery {
+  /** Only sessions this predicate accepts are eligible - the verb's artifact scope. */
+  match: (session: ReviewSession) => boolean;
+  /** Positional id-or-title selector; absent means "latest pending". */
+  selector?: string;
+}
+
+export type OpenTarget =
+  | { kind: "session"; sessionId: string }
+  | { kind: "no-pending" }
+  | { kind: "no-match"; selector: string }
+  | { kind: "ambiguous"; selector: string; titles: string[] };
+
+/** Most-recent-first, so the head of a sorted list is always the latest. */
+function newestFirst(left: ReviewSession, right: ReviewSession): number {
+  return right.createdAt.localeCompare(left.createdAt);
+}
+
+export function resolveOpenTarget(sessions: ReviewSession[], query: OpenTargetQuery): OpenTarget {
+  const scoped = sessions.filter(query.match);
+
+  if (query.selector === undefined) {
+    const latestPending = scoped.filter((candidate) => candidate.status === "pending").sort(newestFirst)[0];
+    return latestPending ? { kind: "session", sessionId: latestPending.id } : { kind: "no-pending" };
+  }
+
+  const selector = query.selector;
+  const byId = scoped.find((candidate) => candidate.id === selector);
+  if (byId) return { kind: "session", sessionId: byId.id };
+
+  const loweredSelector = selector.toLowerCase();
+  const titled = scoped.filter((candidate) => (candidate.artifact.meta.title ?? "").length > 0);
+
+  const exactTitle = titled
+    .filter((candidate) => candidate.artifact.meta.title!.toLowerCase() === loweredSelector)
+    .sort(newestFirst)[0];
+  if (exactTitle) return { kind: "session", sessionId: exactTitle.id };
+
+  const substringMatches = titled
+    .filter((candidate) => candidate.artifact.meta.title!.toLowerCase().includes(loweredSelector))
+    .sort(newestFirst);
+  if (substringMatches.length === 1) return { kind: "session", sessionId: substringMatches[0]!.id };
+  if (substringMatches.length === 0) return { kind: "no-match", selector };
+  return { kind: "ambiguous", selector, titles: substringMatches.map((candidate) => candidate.artifact.meta.title!) };
+}
+
+/**
+ * The reviewer-facing line for a miss, in the "working tree is clean - nothing
+ * to review" tone. `label` is the human word for the verb's scope ("plan",
+ * "diff", "PR"). The "session" outcome has no message - the caller opens it.
+ */
+export function openTargetMessage(label: string, target: Exclude<OpenTarget, { kind: "session" }>): string {
+  switch (target.kind) {
+    case "no-pending":
+      return `no pending ${label} review - nothing to open`;
+    case "no-match":
+      return `no ${label} review matches "${target.selector}" - nothing to open`;
+    case "ambiguous":
+      return [
+        `"${target.selector}" matches several ${label} reviews - name one:`,
+        ...target.titles.map((title) => `  - ${title}`),
+      ].join("\n");
+  }
+}

package/src/session-commands.ts

@@ -6,6 +6,7 @@
 
 import { newAnnotationId, type ArtifactType, type VerdictKind } from "@cueloop/schema";
 import { DaemonClient } from "@cueloop/daemon/client";
+import { openHerdrPaneForReview } from "@cueloop/daemon/herdr-pane";
 import { openReview, verdictResponse, type ReviewNote } from "@cueloop/daemon/review";
 import { parseArgs, stringFlag } from "./args";
 
@@ -39,6 +40,10 @@ export async function sessionCommand(argv: string[]): Promise<number> {
           title: stringFlag(flags, "title"),
           notes,
         });
+        // herdr auto-open: a review created from inside herdr spawns a new tab
+        // that renders it. Guarded to genuinely new sessions and no-op outside
+        // herdr; a broken binary never blocks the create.
+        openHerdrPaneForReview(review.session);
         out(review.session);
         return 0;
       }
@@ -91,7 +96,12 @@ export async function sessionCommand(argv: string[]): Promise<number> {
         const id = required(positional[1], "session id");
         const contentFile = stringFlag(flags, "content-file");
         const content = contentFile ? await Bun.file(contentFile).text() : await readStdin();
-        out(await client.sessionSubmitRevision(id, content));
+        // --addressed a_1,a_2 - the annotation ids this revision acted on
+        const addressed = (stringFlag(flags, "addressed") ?? "")
+          .split(",")
+          .map((annotationId) => annotationId.trim())
+          .filter(Boolean);
+        out(await client.sessionSubmitRevision(id, content, addressed));
         return 0;
       }
       default:

package/src/share-command.test.ts

@@ -0,0 +1,87 @@
+import { describe, expect, mock, test } from "bun:test";
+import { SCHEMA_VERSION, type ReviewSession } from "@cueloop/schema";
+import type { SessionClient } from "@cueloop/daemon/client";
+import { shareSession, type ShareDeps } from "./share-command";
+
+function sessionFixture(id: string): ReviewSession {
+  return {
+    schemaVersion: SCHEMA_VERSION,
+    id,
+    workspace: { repoRoot: "/repo", branch: "main" },
+    artifact: { type: "plan", content: "# Plan\n", meta: {} },
+    revisions: [{ revision: 1, content: "# Plan\n", submittedAt: "2026-01-01T00:00:00.000Z" }],
+    annotations: [],
+    verdict: null,
+    status: "pending",
+    createdAt: "2026-01-01T00:00:00.000Z",
+  };
+}
+
+/** A SessionClient that answers get/list from a fixed list. */
+function fakeClient(sessions: ReviewSession[]): SessionClient {
+  return {
+    sessionGet: async (id: string) => sessions.find((session) => session.id === id)!,
+    sessionList: async () => sessions,
+  } as unknown as SessionClient;
+}
+
+function depsSpy(overrides: Partial<ShareDeps> = {}): ShareDeps & { lines: string[] } {
+  const lines: string[] = [];
+  return {
+    publish: mock(async () => ({ line: "ssh p_abc123xy@cueloop.dev", copied: true })),
+    out: (message: string) => void lines.push(message),
+    lines,
+    ...overrides,
+  };
+}
+
+describe(shareSession, () => {
+  test("publishes the named session and reports the copied ssh line", async () => {
+    // Arrange
+    const publish = mock(async (session: ReviewSession) => (expect(session.id).toBe("ses_2"), { line: "ssh p_abc123xy@cueloop.dev", copied: true }));
+    const deps = depsSpy({ publish });
+
+    // Act
+    const code = await shareSession(fakeClient([sessionFixture("ses_1"), sessionFixture("ses_2")]), { sessionId: "ses_2" }, deps);
+
+    // Assert
+    expect(code).toBe(0);
+    expect(deps.lines).toEqual(["share link copied - ssh p_abc123xy@cueloop.dev"]);
+  });
+
+  test("without an id, shares the most recent session", async () => {
+    // Arrange
+    const publish = mock(async (session: ReviewSession) => (expect(session.id).toBe("ses_2"), { line: "ssh p_zzzzzzzz@cueloop.dev", copied: true }));
+    const deps = depsSpy({ publish });
+
+    // Act
+    await shareSession(fakeClient([sessionFixture("ses_1"), sessionFixture("ses_2")]), {}, deps);
+
+    // Assert
+    expect(deps.publish).toHaveBeenCalledTimes(1);
+  });
+
+  test("prints the bare line when the clipboard is unavailable", async () => {
+    // Arrange
+    const deps = depsSpy({ publish: mock(async () => ({ line: "ssh p_abc123xy@cueloop.dev", copied: false })) });
+
+    // Act
+    await shareSession(fakeClient([sessionFixture("ses_1")]), { sessionId: "ses_1" }, deps);
+
+    // Assert
+    expect(deps.lines).toEqual(["ssh p_abc123xy@cueloop.dev"]);
+  });
+
+  test("reports nothing to share when the inbox is empty", async () => {
+    // Arrange
+    const deps = depsSpy();
+
+    // Act
+    const code = await shareSession(fakeClient([]), {}, deps);
+
+    // Assert
+    expect(code).toBe(1);
+    expect(deps.lines[0]).toContain("no plan to share");
+    expect(deps.publish).not.toHaveBeenCalled();
+  });
+});

package/src/share-command.ts

@@ -0,0 +1,54 @@
+/**
+ * `cueloop share [session-id]` - hand a plan to a teammate as one SSH line.
+ * This side just picks the session and delegates to the shared `publishShare`
+ * transport (the same one the in-TUI Share button uses); the gateway seals and
+ * stores. The transport and output are injected so the orchestration is
+ * testable without a live gateway.
+ */
+
+import { DaemonClient, type SessionClient } from "@cueloop/daemon/client";
+import { publishShare, type ShareResult, type ShareTarget } from "@cueloop/client";
+import type { ReviewSession } from "@cueloop/schema";
+
+export interface ShareParams {
+  sessionId?: string;
+  host?: string;
+  port?: number;
+  home?: string;
+}
+
+export interface ShareDeps {
+  publish: (session: ReviewSession, target: ShareTarget) => Promise<ShareResult>;
+  out: (message: string) => void;
+}
+
+const defaultDeps: ShareDeps = { publish: publishShare, out: (message) => console.log(message) };
+
+/** Connect to the local daemon, then share the chosen session. */
+export async function shareCommand(params: ShareParams, deps: ShareDeps = defaultDeps): Promise<number> {
+  const client = await DaemonClient.connect({ home: params.home, autostart: true });
+  try {
+    return await shareSession(client, params, deps);
+  } finally {
+    client.close();
+  }
+}
+
+/** The orchestration, over any SessionClient - the seam the tests drive. */
+export async function shareSession(client: SessionClient, params: ShareParams, deps: ShareDeps): Promise<number> {
+  const session = await pickSession(client, params.sessionId);
+  if (!session) {
+    deps.out("no plan to share - open a review first");
+    return 1;
+  }
+  const { line, copied } = await deps.publish(session, { host: params.host, port: params.port });
+  deps.out(copied ? `share link copied - ${line}` : line);
+  return 0;
+}
+
+/** The named session, or the most recent one when no id is given. */
+async function pickSession(client: SessionClient, sessionId?: string): Promise<ReviewSession | null> {
+  if (sessionId) return client.sessionGet(sessionId);
+  const sessions = await client.sessionList();
+  return sessions.at(-1) ?? null;
+}