cueloop 0.1.0-alpha.79 → 0.1.0-alpha.80

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "cueloop",
-  "version": "0.1.0-alpha.79",
-  "description": "Terminal review surface for coding agents: annotate plans and diffs, return a verdict, send structured feedback back",
+  "version": "0.1.0-alpha.80",
+  "description": "Terminal review surface for coding agents: annotate plans and diffs, return a message, send structured feedback back",
   "homepage": "https://github.com/mmurakaru/cueloop#readme",
   "bugs": {
     "url": "https://github.com/mmurakaru/cueloop/issues"
@@ -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.79",
-    "@cueloop/client": "0.1.0-alpha.79",
-    "@cueloop/daemon": "0.1.0-alpha.79",
-    "@cueloop/schema": "0.1.0-alpha.79",
+    "@cueloop/adapters": "0.1.0-alpha.80",
+    "@cueloop/client": "0.1.0-alpha.80",
+    "@cueloop/daemon": "0.1.0-alpha.80",
+    "@cueloop/schema": "0.1.0-alpha.80",
     "valibot": "^1.4.2"
   },
   "engines": {

package/src/daemon-control.test.ts

@@ -10,7 +10,7 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { DaemonClient } from "@cueloop/daemon/client";
 import { pidPath, socketPath } from "@cueloop/daemon/paths";
-import { stopDaemon } from "./daemon-control";
+import { restartCommand, stopDaemon } from "./daemon-control";
 
 let home: string;
 
@@ -41,3 +41,28 @@ test("stopDaemon stops a running daemon and clears its socket and pid", async ()
 test("stopDaemon reports nothing to stop when no daemon is running", async () => {
   expect(await stopDaemon(home)).toBe(false);
 });
+
+test("restartCommand replaces the daemon and reconnects", async () => {
+  const previousHome = process.env.CUELOOP_HOME;
+  const first = await DaemonClient.connect({ home, autostart: true });
+  const firstPid = (await first.ping()).pid;
+
+  first.close();
+  process.env.CUELOOP_HOME = home;
+
+  try {
+    expect(await restartCommand()).toBe(0);
+
+    const restarted = await DaemonClient.connect({ home, autostart: false });
+
+    try {
+      expect((await restarted.ping()).pid).not.toBe(firstPid);
+      expect(existsSync(socketPath(home))).toBe(true);
+    } finally {
+      restarted.close();
+    }
+  } finally {
+    if (previousHome === undefined) delete process.env.CUELOOP_HOME;
+    else process.env.CUELOOP_HOME = previousHome;
+  }
+}, 60_000);

package/src/daemon-control.ts

@@ -4,7 +4,7 @@
  * talking to the old-version daemon (which refuses the handshake).
  */
 
-import { existsSync, readFileSync, rmSync } from "node:fs";
+import { existsSync, readFileSync } from "node:fs";
 import * as v from "valibot";
 import { DaemonClient } from "@cueloop/daemon/client";
 import { cueloopHome, pidPath, socketPath } from "@cueloop/daemon/paths";
@@ -95,10 +95,6 @@ export async function restartCommand(): Promise<number> {
   const home = cueloopHome();
 
   await stopDaemon(home);
-  // a wedged daemon that never released its socket would otherwise be reused, not replaced
-  const socket = socketPath(home);
-
-  if (existsSync(socket)) rmSync(socket, { force: true });
   const client = await DaemonClient.connect({ home, autostart: true });
 
   client.close();

package/src/dev-command.ts

@@ -9,7 +9,7 @@ import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { homedir, tmpdir } from "node:os";
 import { dirname, join } from "node:path";
 import { DaemonClient } from "@cueloop/daemon/client";
-import { resolveWorkspace } from "@cueloop/daemon/review";
+import { resolveWorkspace } from "@cueloop/daemon/thread-review";
 
 /** Bump whenever the seed content below changes, so a long-lived dev home refreshes instead of keeping
  *  stale threads (an old seed's diff had no files, which showed as "No changes"). */

package/src/main.ts

@@ -20,11 +20,11 @@ import {
   openTargetMessage,
   resolveOpenTarget,
 } from "./open-target";
-import { sessionCommand } from "./session-commands";
+import { sessionCommand } from "./thread-commands";
 import { CLI_VERSION } from "./version";
 import { DaemonClient } from "@cueloop/daemon/client";
 import type { Thread } from "@cueloop/schema";
-import { openReview } from "@cueloop/daemon/review";
+import { openReview } from "@cueloop/daemon/thread-review";
 
 const argv = process.argv.slice(2);
 const cmd = argv[0];
@@ -340,12 +340,12 @@ function printHelp(): void {
       "  cueloop <plan|diff|review> --latest  open the latest pending review of that type",
       "",
       "scripting:",
-      "  cueloop session <primitive> [flags]   script the daemon (create|get|list|wait|annotate|remove|cut|restore|curate|set-viewed|navigate|branch|switch|label|fork|name-self|events|resolve|submit-revision)",
+      "  cueloop session <primitive> [flags]   script the daemon (create|get|list|wait|annotate|remove|cut|restore|curate|set-viewed|navigate|branch|switch|label|fork|name-self|events|send-message|bind-harness|pending-deliveries|acknowledge-delivery|submit-revision)",
       "  cueloop actions list             list the quick-action vocabulary (for annotate --action)",
       "  cueloop refine                   mine past reviews into a markdown report + writeback proposals",
       "  cueloop update [--dry-run]       update the installed cueloop binary (--dry-run reports the target only)",
-      "  cueloop wake <id> [--harness codex --thread <id>]  resume the agent with the verdict (spawn detached)",
-      "  cueloop review-post <id> <pr>    post a resolved session's verdict back to the PR",
+      "  cueloop wake <id> [--harness codex --thread <id>]  resume the agent with the message (spawn detached)",
+      "  cueloop review-post <id> <pr>    post a resolved session's message back to the PR",
       "  cueloop daemon                   run the daemon in the foreground",
       "  cueloop stop                     stop the local daemon",
       "  cueloop restart                  stop the local daemon and start a fresh one",

package/src/open-target.test.ts

@@ -32,9 +32,9 @@ function session(overrides: {
     },
     revisions: [],
     annotations: [],
-    verdict:
+    message:
       overrides.status === "resolved"
-        ? { kind: "approve", summary: "", feedback: "", resolvedAt: "" }
+        ? { id: "msg_1", outcome: "approved", summary: "", body: "", sentAt: "" }
         : null,
     status: overrides.status ?? "pending",
     createdAt: overrides.createdAt ?? "2026-01-01T00:00:00.000Z",

package/src/open-target.ts

@@ -6,7 +6,7 @@
  *
  * Rules, in order:
  *   - no selector opens the latest pending session in scope (most recent
- *     createdAt, verdict still open) - the `--latest` default;
+ *     createdAt, message 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

package/src/pr.ts

@@ -1,14 +1,18 @@
 /**
  * PR review entry: `cueloop review <pr>` fetches the PR diff through the
  * user's `gh` CLI (auth fully delegated), opens a diff session, and posts the
- * verdict back to the PR as a real review when the session resolves.
+ * message back to the PR as a real review when the session resolves.
  * `cueloop review-post <session-id> <pr>` is the non-interactive post-back
  * half for agents and scripts.
  */
 
-import type { Thread, VerdictKind } from "@cueloop/schema";
+import type { Thread } from "@cueloop/schema";
+import { join } from "node:path";
+import { GitHubForgeReviewPort } from "@cueloop/adapters/forge-review";
+import { DeliveredMessageStore } from "@cueloop/adapters/delivered-message-store";
 import { DaemonClient } from "@cueloop/daemon/client";
-import { openReview } from "@cueloop/daemon/review";
+import { cueloopHome } from "@cueloop/daemon/paths";
+import { openReview } from "@cueloop/daemon/thread-review";
 import { parseArgs } from "./args";
 
 /** The gh binary is injectable so tests can stub it. */
@@ -16,30 +20,13 @@ function ghBin(): string {
   return process.env.CUELOOP_GH || "gh";
 }
 
-interface GhResult {
-  code: number;
-  stdout: string;
-  stderr: string;
+function forge(): GitHubForgeReviewPort {
+  return new GitHubForgeReviewPort(
+    new DeliveredMessageStore(join(cueloopHome(), "forge-delivered-messages.json")),
+    ghBin(),
+  );
 }
 
-async function gh(args: string[]): Promise<GhResult> {
-  const proc = Bun.spawn([ghBin(), ...args], { stdout: "pipe", stderr: "pipe" });
-  const [stdout, stderr, code] = await Promise.all([
-    new Response(proc.stdout).text(),
-    new Response(proc.stderr).text(),
-    proc.exited,
-  ]);
-
-  return { code, stdout, stderr };
-}
-
-/** Verdict kinds map 1:1 onto gh review flags. */
-const VERDICT_FLAG: Record<VerdictKind, string> = {
-  approve: "--approve",
-  request_changes: "--request-changes",
-  comment: "--comment",
-};
-
 export async function reviewCommand(argv: string[]): Promise<number> {
   const { positional, flags } = parseArgs(argv);
   const pr = positional[0];
@@ -49,15 +36,12 @@ export async function reviewCommand(argv: string[]): Promise<number> {
 
     return 2;
   }
-  const diff = await gh(["pr", "diff", pr]);
-
-  if (diff.code !== 0) {
-    console.error(diff.stderr.trim() || `gh pr diff ${pr} failed (exit ${diff.code})`);
+  let imported: { content: string; title: string };
 
-    return 1;
-  }
-  if (!diff.stdout.trim()) {
-    console.error(`PR ${pr} has an empty diff - nothing to review`);
+  try {
+    imported = await forge().importPullRequest(pr);
+  } catch (error) {
+    console.error(error instanceof Error ? error.message : String(error));
 
     return 1;
   }
@@ -66,8 +50,8 @@ export async function reviewCommand(argv: string[]): Promise<number> {
   // hunk curation stays disabled for PR reviews (see diff-hunk-curate.ts).
   const review = await openReview(client, {
     type: "diff",
-    content: diff.stdout,
-    title: `PR ${pr}`,
+    content: imported.content,
+    title: imported.title,
     pr,
   });
   const session = review.session;
@@ -86,13 +70,13 @@ export async function reviewCommand(argv: string[]): Promise<number> {
 
   const after = await getSession(session.id);
 
-  if (after.status !== "resolved" || !after.verdict) {
+  if (after.status !== "resolved" || !after.message) {
     console.log(`session ${session.id} is unresolved - nothing was posted to PR ${pr}`);
 
     return 0;
   }
 
-  return postVerdict(after, pr);
+  return postMessage(after, pr);
 }
 
 export async function reviewPostCommand(argv: string[]): Promise<number> {
@@ -107,13 +91,13 @@ export async function reviewPostCommand(argv: string[]): Promise<number> {
   }
   const session = await getSession(sessionId);
 
-  if (session.status !== "resolved" || !session.verdict) {
+  if (session.status !== "resolved" || !session.message) {
     console.error(`session ${sessionId} is unresolved - nothing was posted to PR ${pr}`);
 
     return 1;
   }
 
-  return postVerdict(session, pr);
+  return postMessage(session, pr);
 }
 
 async function getSession(id: string): Promise<Thread> {
@@ -126,24 +110,18 @@ async function getSession(id: string): Promise<Thread> {
   }
 }
 
-/** Post the resolved session's verdict to the PR: feedback.md is the review body. */
-async function postVerdict(session: Thread, pr: string): Promise<number> {
-  const verdict = session.verdict!;
-  const result = await gh([
-    "pr",
-    "review",
-    pr,
-    VERDICT_FLAG[verdict.kind],
-    "--body",
-    verdict.feedback,
-  ]);
+/** Post the resolved session's message to the PR: feedback.md is the review body. */
+async function postMessage(session: Thread, pr: string): Promise<number> {
+  const message = session.message!;
 
-  if (result.code !== 0) {
-    console.error(result.stderr.trim() || `gh pr review ${pr} failed (exit ${result.code})`);
+  try {
+    await forge().postPullRequestMessage(pr, message);
+  } catch (error) {
+    console.error(error instanceof Error ? error.message : String(error));
 
     return 1;
   }
-  console.log(`posted ${verdict.kind} review to PR ${pr} (session ${session.id})`);
+  console.log(`posted ${message.outcome} review to PR ${pr} (session ${session.id})`);
 
   return 0;
 }

package/src/refine-command.test.ts

@@ -4,10 +4,12 @@ import { describe, expect, test } from "bun:test";
 import { mkdtempSync, readFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import type { Annotation, Thread, Verdict, VerdictKind } from "@cueloop/schema";
+import type { Annotation, Thread, Message, MessageOutcome } from "@cueloop/schema";
 import { ThreadStore } from "@cueloop/daemon/store";
+import { DaemonServer } from "@cueloop/daemon";
 import { reportsDir } from "@cueloop/daemon/paths";
-import { buildRefineReport, refineCommand } from "./refine-command";
+import { buildRefineReport } from "@cueloop/adapters/refine-corpus";
+import { refineCommand } from "./refine-command";
 
 function tempHome(): string {
   return mkdtempSync(join(tmpdir(), "cueloop-refine-home-"));
@@ -23,8 +25,14 @@ function annotation(quote: string, body: string): Annotation {
   };
 }
 
-function verdict(kind: VerdictKind): Verdict {
-  return { kind, summary: "", feedback: "", resolvedAt: "2026-08-20T11:00:00Z" };
+function message(outcome: MessageOutcome): Message {
+  return {
+    id: `msg_${outcome}`,
+    outcome,
+    summary: "",
+    body: "",
+    sentAt: "2026-08-20T11:00:00Z",
+  };
 }
 
 function session(
@@ -40,9 +48,9 @@ function session(
     artifact: { type: type ?? "plan", content: "", meta: {} },
     revisions: [],
     annotations: [],
-    verdict: null,
+    message: null,
     status: "pending",
-    createdAt: "2026-08-20T10:00:00Z",
+    createdAt: new Date().toISOString(),
     ...rest,
   };
 }
@@ -51,10 +59,10 @@ describe("buildRefineReport", () => {
   test("reports the analyzed and total counts, distributions, and annotations", () => {
     // Arrange
     const analyzed = [
-      session("ses_a", { verdict: verdict("approve"), status: "resolved" }),
+      session("ses_a", { message: message("approved"), status: "resolved" }),
       session("ses_b", {
         type: "diff",
-        verdict: verdict("request_changes"),
+        message: message("changes_requested"),
         status: "resolved",
         annotations: [annotation("skip tests", "please add a regression test")],
       }),
@@ -67,7 +75,7 @@ describe("buildRefineReport", () => {
     expect(markdown).toContain("2 sessions analyzed (3 total).");
     expect(markdown).toContain("- plan: 1");
     expect(markdown).toContain("- diff: 1");
-    expect(markdown).toContain("- approve: 1");
+    expect(markdown).toContain("- approved: 1");
     expect(markdown).toContain("- request changes: 1");
     expect(markdown).toContain("skip tests");
     expect(markdown).toContain("please add a regression test");
@@ -89,10 +97,10 @@ describe("refineCommand", () => {
     const home = tempHome();
     const store = new ThreadStore(home);
 
-    store.upsert(session("ses_a", { verdict: verdict("approve"), status: "resolved" }));
+    store.upsert(session("ses_a", { message: message("approved"), status: "resolved" }));
     store.upsert(
       session("ses_b", {
-        verdict: verdict("request_changes"),
+        message: message("changes_requested"),
         status: "resolved",
         annotations: [annotation("wrong file", "this belongs in store.ts")],
       }),
@@ -102,19 +110,26 @@ describe("refineCommand", () => {
     );
     store.upsert(session("ses_empty"));
     const reportPath = join(reportsDir(home), "report.md");
+    const server = new DaemonServer({ home, idleExitMs: 0 });
+
+    server.start();
 
     // Act
-    const firstCode = await refineCommand(["--home", home]);
+    try {
+      const firstCode = await refineCommand(["--home", home]);
 
-    // Assert
-    expect(firstCode).toBe(0);
-    expect(readFileSync(reportPath, "utf8")).toContain("3 sessions analyzed (4 total).");
+      // Assert
+      expect(firstCode).toBe(0);
+      expect(readFileSync(reportPath, "utf8")).toContain("3 sessions analyzed (4 total).");
 
-    // Act
-    await refineCommand(["--home", home]);
+      // Act
+      await refineCommand(["--home", home]);
 
-    // Assert
-    expect(readFileSync(reportPath, "utf8")).toContain("1 sessions analyzed (4 total).");
+      // Assert
+      expect(readFileSync(reportPath, "utf8")).toContain("1 sessions analyzed (4 total).");
+    } finally {
+      server.stop();
+    }
   });
 
   test("re-analyzes a resolved session that is reopened and resolved again with new feedback", async () => {
@@ -124,15 +139,22 @@ describe("refineCommand", () => {
 
     store.upsert(
       session("ses_x", {
-        verdict: verdict("approve"),
+        message: message("approved"),
         status: "resolved",
         annotations: [annotation("first", "one")],
       }),
     );
     const reportPath = join(reportsDir(home), "report.md");
+    const firstServer = new DaemonServer({ home, idleExitMs: 0 });
+
+    firstServer.start();
 
     // Act
-    await refineCommand(["--home", home]);
+    try {
+      await refineCommand(["--home", home]);
+    } finally {
+      firstServer.stop();
+    }
 
     // Assert
     expect(readFileSync(reportPath, "utf8")).toContain("1 sessions analyzed (1 total).");
@@ -140,14 +162,21 @@ describe("refineCommand", () => {
     // Arrange
     store.upsert(
       session("ses_x", {
-        verdict: { ...verdict("request_changes"), resolvedAt: "2026-08-21T09:00:00Z" },
+        message: { ...message("changes_requested"), sentAt: "2026-08-21T09:00:00Z" },
         status: "resolved",
         annotations: [annotation("first", "one"), annotation("second", "two")],
       }),
     );
+    const secondServer = new DaemonServer({ home, idleExitMs: 0 });
+
+    secondServer.start();
 
     // Act
-    await refineCommand(["--home", home]);
+    try {
+      await refineCommand(["--home", home]);
+    } finally {
+      secondServer.stop();
+    }
 
     // Assert
     const secondReport = readFileSync(reportPath, "utf8");

package/src/refine-command.ts

@@ -1,67 +1,37 @@
-import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
-import { cueloopHome, reportsDir } from "@cueloop/daemon/paths";
-import { ThreadStore } from "@cueloop/daemon/store";
-import {
-  LATEST_REPORT_FILENAME,
-  parseRefineState,
-  pruneExpiredReports,
-  resolveCleanupPeriodDays,
-  timestampedReportFilename,
-} from "@cueloop/daemon/retention";
-import { isAgentNote, type Annotation, type Thread } from "@cueloop/schema";
-import { parseArgs, stringFlag } from "./args";
-
-const DEFAULT_SESSION_LIMIT = 200;
-const QUOTE_LIMIT = 60;
-const BODY_LIMIT = 100;
+/** CLI wrapper around the shared corpus analysis used by harness refine workflows. */
 
-interface AnnotatedEntry {
-  annotation: Annotation;
-  session: Thread;
-}
+import { cueloopHome } from "@cueloop/daemon/paths";
+import { LocalRefineCorpusPort } from "@cueloop/adapters/refine-corpus";
+import { DaemonClient } from "@cueloop/daemon/client";
+import { parseArgs, stringFlag } from "./args";
 
+/** Generate the same refine report the shared harness controller consumes. */
 export async function refineCommand(argv: string[]): Promise<number> {
   const { flags } = parseArgs(argv);
   const home = stringFlag(flags, "home") ?? cueloopHome();
-  const limit = parseLimit(stringFlag(flags, "limit"));
-  const nowMs = Date.now();
-
-  const store = new ThreadStore(home);
-
-  store.recover();
-  const all = store.list();
-
-  const analyzedState = readState(home);
-  const fresh = all.filter(
-    (session) => analyzedState.get(session.id) !== analysisFingerprint(session),
-  );
-  const analyzed = fresh.filter(hasReviewSignal).slice(0, limit);
-
-  const markdown = buildRefineReport(analyzed, all.length, new Date(nowMs).toISOString());
-
-  const directory = reportsDir(home);
+  const rawLimit = stringFlag(flags, "limit");
+  const client = await DaemonClient.connect({ home, autostart: true });
+  let result: Awaited<ReturnType<LocalRefineCorpusPort["analyzeRefineCorpus"]>>;
 
-  mkdirSync(directory, { recursive: true });
-  pruneExpiredReports(directory, resolveCleanupPeriodDays(), nowMs);
-  const latestPath = join(directory, LATEST_REPORT_FILENAME);
-  const timestampedPath = join(directory, timestampedReportFilename(nowMs));
-
-  writeFileSync(latestPath, markdown);
-  writeFileSync(timestampedPath, markdown);
+  try {
+    const corpus = new LocalRefineCorpusPort(
+      client,
+      home,
+      rawLimit === undefined ? undefined : Number(rawLimit),
+    );
 
-  for (const session of analyzed) {
-    if (session.status === "resolved") analyzedState.set(session.id, analysisFingerprint(session));
+    result = await corpus.analyzeRefineCorpus();
+  } finally {
+    client.close();
   }
-  writeState(home, analyzedState);
 
   console.log(
     JSON.stringify(
       {
-        report: latestPath,
-        timestamped: timestampedPath,
-        analyzed: analyzed.length,
-        total: all.length,
+        report: result.reportPath,
+        timestamped: result.timestampedPath,
+        analyzed: result.analyzed,
+        total: result.total,
       },
       null,
       2,
@@ -70,193 +40,3 @@ export async function refineCommand(argv: string[]): Promise<number> {
 
   return 0;
 }
-
-export function buildRefineReport(
-  analyzed: Thread[],
-  totalCount: number,
-  generatedAt: string,
-): string {
-  const entries = flattenReviewAnnotations(analyzed);
-  const lines: string[] = [
-    "# refine report",
-    "",
-    `Generated ${generatedAt}.`,
-    "",
-    `${analyzed.length} sessions analyzed (${totalCount} total).`,
-    "",
-    "## Corpus",
-    "",
-    "By primitive:",
-    ...byCount(analyzed, primitiveLabel).map(([label, count]) => `- ${label}: ${count}`),
-    "",
-    "By verdict:",
-    ...byCount(analyzed, verdictLabel).map(([label, count]) => `- ${label}: ${count}`),
-    "",
-    "## Annotations by kind",
-    "",
-  ];
-
-  if (entries.length === 0) {
-    lines.push("No reviewer annotations in the analyzed sessions.", "");
-  } else {
-    for (const [kind, group] of groupByKind(entries)) {
-      lines.push(`### ${kind} (${group.length})`, "");
-      for (const { annotation, session } of group) {
-        const meta = [
-          session.id,
-          primitiveLabel(session),
-          verdictLabel(session),
-          isoWeek(annotation.createdAt),
-        ].join(" · ");
-
-        lines.push(
-          `- "${truncate(annotation.anchor.quote, QUOTE_LIMIT)}": ${truncate(annotation.body, BODY_LIMIT)} · ${meta}`,
-        );
-      }
-      lines.push("");
-    }
-  }
-
-  lines.push("## Weekly volume", "");
-  for (const [week, count] of byKey(
-    entries.map((entry) => entry.annotation),
-    (annotation) => isoWeek(annotation.createdAt),
-  )) {
-    lines.push(`- ${week}: ${count}`);
-  }
-  lines.push(
-    "",
-    "## Next",
-    "",
-    "Group the annotations above into named patterns of three or more members.",
-    "Rank each pattern by how often its members sit on a request-changes or comment verdict.",
-    "Draft one writeback per pattern, routed to a skill, AGENTS.md, CLAUDE.md, or memory.",
-    "",
-  );
-
-  return lines.join("\n");
-}
-
-function hasReviewSignal(session: Thread): boolean {
-  return (
-    session.verdict !== null || session.annotations.some((annotation) => !isAgentNote(annotation))
-  );
-}
-
-function flattenReviewAnnotations(sessions: Thread[]): AnnotatedEntry[] {
-  const entries: AnnotatedEntry[] = [];
-
-  for (const session of sessions) {
-    for (const annotation of session.annotations) {
-      if (!isAgentNote(annotation)) entries.push({ annotation, session });
-    }
-  }
-
-  return entries;
-}
-
-function groupByKind(entries: AnnotatedEntry[]): [string, AnnotatedEntry[]][] {
-  const groups = new Map<string, AnnotatedEntry[]>();
-
-  for (const entry of entries) {
-    const group = groups.get(entry.annotation.kind) ?? [];
-
-    group.push(entry);
-    groups.set(entry.annotation.kind, group);
-  }
-
-  return [...groups.entries()].toSorted(
-    (left, right) => right[1].length - left[1].length || left[0].localeCompare(right[0]),
-  );
-}
-
-function byCount<T>(items: T[], keyOf: (item: T) => string): [string, number][] {
-  return [...tally(items, keyOf).entries()].toSorted(
-    (left, right) => right[1] - left[1] || left[0].localeCompare(right[0]),
-  );
-}
-
-function byKey<T>(items: T[], keyOf: (item: T) => string): [string, number][] {
-  return [...tally(items, keyOf).entries()].toSorted((left, right) =>
-    left[0].localeCompare(right[0]),
-  );
-}
-
-function tally<T>(items: T[], keyOf: (item: T) => string): Map<string, number> {
-  const counts = new Map<string, number>();
-
-  for (const item of items) {
-    const key = keyOf(item);
-
-    counts.set(key, (counts.get(key) ?? 0) + 1);
-  }
-
-  return counts;
-}
-
-function primitiveLabel(session: Thread): string {
-  if (session.artifact.type === "diff" && session.artifact.meta.pr) return "pull request";
-
-  return session.artifact.type;
-}
-
-function verdictLabel(session: Thread): string {
-  switch (session.verdict?.kind) {
-    case "approve":
-      return "approve";
-    case "request_changes":
-      return "request changes";
-    case "comment":
-      return "comment";
-    default:
-      return "none";
-  }
-}
-
-function isoWeek(iso: string): string {
-  const date = new Date(iso);
-
-  if (Number.isNaN(date.getTime())) return "undated";
-  const utc = new Date(Date.UTC(date.getUTCFullYear(), date.getUTCMonth(), date.getUTCDate()));
-  const weekday = utc.getUTCDay() || 7;
-
-  utc.setUTCDate(utc.getUTCDate() + 4 - weekday);
-  const yearStart = new Date(Date.UTC(utc.getUTCFullYear(), 0, 1));
-  const week = Math.ceil(((utc.getTime() - yearStart.getTime()) / (24 * 60 * 60 * 1000) + 1) / 7);
-
-  return `${utc.getUTCFullYear()}-W${String(week).padStart(2, "0")}`;
-}
-
-function truncate(text: string, max: number): string {
-  const collapsed = text.replace(/\s+/g, " ").trim();
-
-  return collapsed.length > max ? `${collapsed.slice(0, max - 1)}…` : collapsed;
-}
-
-function parseLimit(raw: string | undefined): number {
-  const value = Number(raw);
-
-  return Number.isInteger(value) && value > 0 ? value : DEFAULT_SESSION_LIMIT;
-}
-
-function analysisFingerprint(session: Thread): string {
-  return `${session.revisions.length}:${session.annotations.length}:${session.verdict?.resolvedAt ?? "pending"}`;
-}
-
-function statePath(home: string): string {
-  return join(home, "refine-state.json");
-}
-
-function readState(home: string): Map<string, string> {
-  try {
-    return parseRefineState(JSON.parse(readFileSync(statePath(home), "utf8")));
-  } catch {
-    return new Map();
-  }
-}
-
-function writeState(home: string, analyzed: Map<string, string>): void {
-  const state = { analyzed: Object.fromEntries(analyzed) };
-
-  writeFileSync(statePath(home), JSON.stringify(state, null, 2));
-}

package/src/share-command.test.ts

@@ -6,7 +6,7 @@ import {
   type Annotation,
   type Thread,
 } from "@cueloop/schema";
-import type { SessionClient } from "@cueloop/daemon/client";
+import type { ThreadClient } from "@cueloop/daemon/client";
 import { pullSession, shareSession, type PullDeps, type ShareDeps } from "./share-command";
 
 function sessionFixture(id: string, overrides: Partial<Thread> = {}): Thread {
@@ -17,7 +17,7 @@ function sessionFixture(id: string, overrides: Partial<Thread> = {}): Thread {
     artifact: { type: "plan", content: "# Plan\n", meta: {} },
     revisions: [{ revision: 1, content: "# Plan\n", submittedAt: "2026-01-01T00:00:00.000Z" }],
     annotations: [],
-    verdict: null,
+    message: null,
     status: "pending",
     createdAt: "2026-01-01T00:00:00.000Z",
     ...overrides,
@@ -39,8 +39,8 @@ function annotationFixture(id: string, author?: string): Annotation {
 const unimplemented = (member: string) => () =>
   Promise.reject(new Error(`fakeClient does not implement ${member}`));
 
-/** A SessionClient that answers get/list from a fixed list and records the share/merge primitives. */
-function fakeClient(sessions: Thread[]): SessionClient {
+/** A ThreadClient that answers get/list from a fixed list and records the share/merge primitives. */
+function fakeClient(sessions: Thread[]): ThreadClient {
   return {
     onEvent: () => () => {},
     subscribe: async () => {},
@@ -96,7 +96,7 @@ function fakeClient(sessions: Thread[]): SessionClient {
     ),
     sessionDelete: unimplemented("sessionDelete"),
     sessionSetSelfName: unimplemented("sessionSetSelfName"),
-    sessionResolve: unimplemented("sessionResolve"),
+    sessionSendMessage: unimplemented("sessionSendMessage"),
     close: () => {},
   };
 }

package/src/share-command.ts

@@ -6,7 +6,7 @@
  * testable without a live gateway.
  */
 
-import { DaemonClient, type SessionClient } from "@cueloop/daemon/client";
+import { DaemonClient, type ThreadClient } from "@cueloop/daemon/client";
 import {
   mergeFromShare,
   publishShare,
@@ -68,9 +68,9 @@ export async function sharePullCommand(
   }
 }
 
-/** The share orchestration, over any SessionClient - the seam the tests drive. */
+/** The share orchestration, over any ThreadClient - the seam the tests drive. */
 export async function shareSession(
-  client: SessionClient,
+  client: ThreadClient,
   params: ShareParams,
   deps: ShareDeps,
 ): Promise<number> {
@@ -102,7 +102,7 @@ export async function shareSession(
  * ones land. The gateway lets only the fingerprint that shared it pull.
  */
 export async function pullSession(
-  client: SessionClient,
+  client: ThreadClient,
   params: ShareParams,
   deps: PullDeps,
 ): Promise<number> {
@@ -127,7 +127,7 @@ export async function pullSession(
 }
 
 /** The named session, or the most recent one when no id is given. */
-async function pickSession(client: SessionClient, sessionId?: string): Promise<Thread | null> {
+async function pickSession(client: ThreadClient, sessionId?: string): Promise<Thread | null> {
   if (sessionId) return client.sessionGet(sessionId);
   const sessions = await client.sessionList();
 
@@ -135,10 +135,7 @@ async function pickSession(client: SessionClient, sessionId?: string): Promise<T
 }
 
 /** The named session (if shared), or the most recent shared one. */
-async function pickSharedSession(
-  client: SessionClient,
-  sessionId?: string,
-): Promise<Thread | null> {
+async function pickSharedSession(client: ThreadClient, sessionId?: string): Promise<Thread | null> {
   if (sessionId) {
     const session = await client.sessionGet(sessionId);
 

package/src/{session-commands.ts → thread-commands.ts}

@@ -1,5 +1,5 @@
 /**
- * `cueloop session *` - mirrors the daemon socket API 1:1. One surface,
+ * `cueloop session *` - mirrors the daemon socket API 1:1. One Thread surface,
  * three consumers: agent adapters, the dev loop, and integrations. Output is
  * JSON on stdout; exit code 0 unless the daemon returned an error.
  */
@@ -14,7 +14,7 @@ import {
 import * as v from "valibot";
 import { DaemonClient } from "@cueloop/daemon/client";
 import { openHerdrPaneForReview } from "@cueloop/daemon/herdr-pane";
-import { openReview, verdictResponse } from "@cueloop/daemon/review";
+import { openReview, messageResponse } from "@cueloop/daemon/thread-review";
 import { loadConfig, quickActionBody, resolveQuickAction } from "@cueloop/client/config";
 import { slashItemsFrom } from "@cueloop/client/slash-palette";
 import { parseArgs, stringFlag } from "./args";
@@ -29,7 +29,7 @@ function out(value: Parameters<typeof JSON.stringify>[0]): void {
 
 const ReviewNotesSchema = v.array(v.object({ path: v.string(), body: v.string() }));
 const SessionStatusSchema = v.picklist(["pending", "resolved"]);
-const VerdictKindSchema = v.picklist(["comment", "approve", "request_changes"]);
+const MessageOutcomeSchema = v.picklist(["approved", "changes_requested"]);
 
 type SessionFlags = Record<string, string | boolean>;
 type SessionContext = { client: DaemonClient; positional: string[]; flags: SessionFlags };
@@ -93,9 +93,9 @@ async function sessionWaitCommand({ client, positional, flags }: SessionContext)
 
     return 0;
   }
-  const { allow, feedback } = verdictResponse(session);
+  const { allow, message } = messageResponse(session);
 
-  out({ status: "resolved", allow, verdict: session.verdict!.kind, feedback });
+  out({ status: "resolved", allow, message });
 
   return 0;
 }
@@ -336,14 +336,17 @@ async function sessionEventsCommand({
   return stream;
 }
 
-async function sessionResolveCommand({
+async function sessionSendMessageCommand({
   client,
   positional,
   flags,
 }: SessionContext): Promise<number> {
   const id = required(positional[1], "session id");
-  const kind = v.parse(VerdictKindSchema, required(stringFlag(flags, "verdict"), "--verdict"));
-  // expand /name quick-action references in TUI-authored comments, so a CLI resolve sends the agent
+  const outcome = v.parse(
+    MessageOutcomeSchema,
+    required(stringFlag(flags, "outcome"), "--outcome"),
+  );
+  // Expand /name quick-action references in TUI-authored comments, so send-message sends the agent
   // the action bodies too, not the bare references
   const session = await client.sessionGet(id);
   const actions = loadConfig({ repoRoot: session.workspace.repoRoot }).actions;
@@ -351,7 +354,38 @@ async function sessionResolveCommand({
     slashItemsFrom(actions).map((item) => [item.name, item.body]),
   );
 
-  out(await client.sessionResolve(id, kind, stringFlag(flags, "summary") ?? "", actionBodies));
+  out(
+    await client.sessionSendMessage(id, outcome, stringFlag(flags, "summary") ?? "", actionBodies),
+  );
+
+  return 0;
+}
+
+async function harnessBindCommand({ client, positional, flags }: SessionContext): Promise<number> {
+  const threadId = required(positional[1], "thread id");
+  const harness = required(stringFlag(flags, "harness"), "--harness");
+  const harnessSessionId = required(
+    stringFlag(flags, "harness-session-id"),
+    "--harness-session-id",
+  );
+
+  out(await client.harnessBind(threadId, harness, harnessSessionId));
+
+  return 0;
+}
+
+async function deliveryPendingCommand({ client, positional }: SessionContext): Promise<number> {
+  const bindingId = required(positional[1], "binding id");
+
+  out(await client.deliveryPending(bindingId));
+
+  return 0;
+}
+
+async function deliveryAcknowledgeCommand({ client, positional }: SessionContext): Promise<number> {
+  const deliveryId = required(positional[1], "delivery id");
+
+  out(await client.deliveryAcknowledge(deliveryId));
 
   return 0;
 }
@@ -397,7 +431,10 @@ const sessionVerbHandlers: SessionVerbHandlers = {
   fork: sessionForkCommand,
   "name-self": sessionNameSelfCommand,
   events: sessionEventsCommand,
-  resolve: sessionResolveCommand,
+  "send-message": sessionSendMessageCommand,
+  "bind-harness": harnessBindCommand,
+  "pending-deliveries": deliveryPendingCommand,
+  "acknowledge-delivery": deliveryAcknowledgeCommand,
   "submit-revision": sessionSubmitRevisionCommand,
 };
 
@@ -419,7 +456,7 @@ export async function sessionCommand(argv: string[]): Promise<number> {
 
     if (handler === undefined) {
       console.error(
-        "usage: cueloop session <create|get|list|wait|annotate|remove|cut|restore|curate|set-viewed|navigate|branch|switch|label|fork|name-self|events|resolve|submit-revision> [flags]",
+        "usage: cueloop session <create|get|list|wait|annotate|remove|cut|restore|curate|set-viewed|navigate|branch|switch|label|fork|name-self|events|send-message|bind-harness|pending-deliveries|acknowledge-delivery|submit-revision> [flags]",
       );
 
       return 2;

package/src/wake-command.ts

@@ -1,6 +1,6 @@
 /**
  * `cueloop wake <session-id>` - the production caller for the non-blocking wake.
- * A detached child of a coding-agent session parks on the review's verdict and
+ * A detached child of a coding-agent session parks on the review's message and
  * injects it back into that same live session when the human decides, so the
  * agent resumes itself without a blocked, pinned tool call. The plan skill (and
  * the Claude Code hook's non-blocking path) spawn this right after a