cueloop 0.1.0-alpha.59 → 0.1.0-alpha.60

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cueloop",
-  "version": "0.1.0-alpha.59",
+  "version": "0.1.0-alpha.60",
   "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.59",
-    "@cueloop/client": "0.1.0-alpha.59",
-    "@cueloop/daemon": "0.1.0-alpha.59",
-    "@cueloop/schema": "0.1.0-alpha.59"
+    "@cueloop/adapters": "0.1.0-alpha.60",
+    "@cueloop/client": "0.1.0-alpha.60",
+    "@cueloop/daemon": "0.1.0-alpha.60",
+    "@cueloop/schema": "0.1.0-alpha.60"
   },
   "engines": {
     "bun": ">=1.3.0"

package/src/actions-command.ts

@@ -13,8 +13,10 @@ import { parseArgs, stringFlag } from "./args";
 export async function actionsCommand(argv: string[]): Promise<number> {
   const { positional, flags } = parseArgs(argv);
   const verb = positional[0] ?? "list";
+
   if (verb !== "list") {
     console.error("usage: cueloop actions list [--session <id>]");
+
     return 2;
   }
   const role = stringFlag(flags, "role") === "agent" ? "agent" : undefined;
@@ -25,7 +27,9 @@ export async function actionsCommand(argv: string[]): Promise<number> {
     prompt: action.prompt,
     metadata: action.metadata,
   }));
+
   console.log(JSON.stringify(numbered, null, 2));
+
   return 0;
 }
 
@@ -36,6 +40,7 @@ async function repoRootForSession(
 ): Promise<string> {
   if (sessionId === undefined) return process.cwd();
   const client = await DaemonClient.connect({ autostart: true, role });
+
   try {
     return (await client.sessionGet(sessionId)).workspace.repoRoot;
   } finally {

package/src/args.ts

@@ -8,18 +8,22 @@ export interface ParsedArgs {
 export function parseArgs(argv: string[]): ParsedArgs {
   const positional: string[] = [];
   const flags: Record<string, string | boolean> = {};
+
   for (let i = 0; i < argv.length; i++) {
     const argument = argv[i]!;
+
     if (!argument.startsWith("--")) {
       positional.push(argument);
       continue;
     }
     const equalsIndex = argument.indexOf("=");
+
     if (equalsIndex !== -1) {
       flags[argument.slice(2, equalsIndex)] = argument.slice(equalsIndex + 1);
     } else {
       const key = argument.slice(2);
       const next = argv[i + 1];
+
       if (next !== undefined && !next.startsWith("--")) {
         flags[key] = next;
         i++;
@@ -28,6 +32,7 @@ export function parseArgs(argv: string[]): ParsedArgs {
       }
     }
   }
+
   return { positional, flags };
 }
 
@@ -36,5 +41,6 @@ export function stringFlag(
   key: string,
 ): string | undefined {
   const value = flags[key];
+
   return typeof value === "string" ? value : undefined;
 }

package/src/main.ts

@@ -1,8 +1,8 @@
 #!/usr/bin/env bun
 /**
  * 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
+ * openers `cueloop plan|reply|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.
@@ -15,6 +15,7 @@ import {
   isPlanReview,
   isPrototypeReview,
   isPrReview,
+  isReplyReview,
   isSessionId,
   openTargetMessage,
   resolveOpenTarget,
@@ -33,12 +34,15 @@ async function daemonCommand(): Promise<number> {
   const { DaemonServer } = await import("@cueloop/daemon");
   const server = new DaemonServer({ idleExitMs: 0 });
   const path = server.start();
+
   if (path === null) {
     console.error("a cueloop daemon already owns this home - nothing to do");
+
     return 1;
   }
   console.log(`cueloop daemon (foreground) on ${path}`);
   await new Promise(() => {}); // run until signalled
+
   return 0;
 }
 
@@ -51,6 +55,7 @@ async function serveEntry(rest: string[]): Promise<number> {
     host: stringFlag(flags, "host"),
     sessionId: positional[0],
   });
+
   console.log(
     [
       "",
@@ -63,9 +68,11 @@ async function serveEntry(rest: string[]): Promise<number> {
     ].join("\n"),
   );
   const stop = () => void handle.close().finally(() => process.exit(0));
+
   process.on("SIGINT", stop);
   process.on("SIGTERM", stop);
   await new Promise(() => {}); // serve until signalled
+
   return 0;
 }
 
@@ -77,7 +84,9 @@ async function shareEntry(rest: string[]): Promise<number> {
     host: stringFlag(flags, "host"),
     port: port !== undefined ? Number(port) : undefined,
   };
+
   if (positional[0] === "pull") return sharePullCommand({ ...target, sessionId: positional[1] });
+
   return shareCommand({ ...target, sessionId: positional[0] });
 }
 
@@ -87,6 +96,7 @@ const commandHandlers: Record<string, CommandHandler> = {
   session: (rest) => sessionCommand(rest),
   daemon: () => daemonCommand(),
   plan: (rest) => planCommand(rest),
+  reply: (rest) => replyCommand(rest),
   diff: (rest) => diffCommand(rest),
   prototype: (rest) => prototypeCommand(rest),
   serve: (rest) => serveEntry(rest),
@@ -104,17 +114,21 @@ const helpAliases = new Set(["-h", "--help", "help"]);
 async function main(): Promise<number> {
   if (cmd === undefined) return runTui();
   const handler = commandHandlers[cmd];
+
   if (handler !== undefined) return handler(argv.slice(1));
   if (versionAliases.has(cmd)) {
     console.log(CLI_VERSION);
+
     return 0;
   }
   if (helpAliases.has(cmd)) {
     printHelp();
+
     return 0;
   }
   if (cmd.startsWith("ses_")) return runTui(cmd);
   printHelp();
+
   return 2;
 }
 
@@ -143,18 +157,22 @@ async function openReviewOfKind(
 ): 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;
 }
 
@@ -163,6 +181,15 @@ async function planCommand(argv: string[]): Promise<number> {
   return openReviewOfKind(isPlanReview, "plan", openSelector(parseArgs(argv)));
 }
 
+/**
+ * `cueloop reply [id|title]` - open the latest pending reply review, or address
+ * one. A reply artifact is the agent's previous message, submitted for review
+ * 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)));
+}
+
 /**
  * `cueloop prototype <file.html>` creates a review of a rendered HTML file;
  * a selector or `--open`/`--latest` (or a bare call with no file) opens the
@@ -174,6 +201,7 @@ async function prototypeCommand(argv: string[]): Promise<number> {
   const wantsOpen = "open" in parsed.flags || "latest" in parsed.flags;
   const looksLikeFile =
     selector !== undefined && !isSessionId(selector) && selector.endsWith(".html");
+
   if (wantsOpen || !looksLikeFile)
     return openReviewOfKind(isPrototypeReview, "prototype", selector);
 
@@ -181,8 +209,10 @@ async function prototypeCommand(argv: string[]): Promise<number> {
   const html = await Bun.file(path)
     .text()
     .catch(() => undefined);
+
   if (html === undefined) {
     console.error(`prototype: cannot read ${path}`);
+
     return 1;
   }
   const client = await DaemonClient.connect({ autostart: true });
@@ -192,7 +222,9 @@ async function prototypeCommand(argv: string[]): Promise<number> {
     prototypePath: path,
     title: basename(path),
   });
+
   client.close();
+
   return runTui(review.id);
 }
 
@@ -208,10 +240,12 @@ 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.patch.trim()) {
     return openReviewOfKind(
       isDiffReview,
@@ -228,7 +262,9 @@ async function diffCommand(argv: string[]): Promise<number> {
     workspace,
     title: `working tree @ ${workspace.branch}`,
   });
+
   client.close();
+
   return runTui(review.id);
 }
 
@@ -244,10 +280,13 @@ async function reviewEntry(argv: string[]): Promise<number> {
   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",
@@ -257,6 +296,7 @@ async function reviewEntry(argv: string[]): Promise<number> {
 
 async function runTui(sessionId?: string): Promise<number> {
   const { runClient } = await import("@cueloop/client");
+
   return runClient({ sessionId });
 }
 
@@ -270,6 +310,7 @@ function printHelp(): void {
       "common commands:",
       "  cueloop                          open the inbox",
       "  cueloop plan [id|title]          open the latest pending plan review (or one by id/title)",
+      "  cueloop reply [id|title]         open the latest pending reply review (the agent's previous message)",
       "  cueloop diff [id|title]          review your working tree (untracked files included);",
       "                                   with a clean tree, open the latest pending diff review",
       "  cueloop review <pr>              review a pull request (--no-tui prints the session)",

package/src/open-target.test.ts

@@ -7,6 +7,7 @@ import {
   isPlanReview,
   isPrototypeReview,
   isPrReview,
+  isReplyReview,
   isSessionId,
   openTargetMessage,
   resolveOpenTarget,
@@ -66,6 +67,13 @@ describe("verb scope predicates are disjoint", () => {
     expect(isPrototypeReview(session({ id: "ses_d", type: "diff" }))).toBe(false);
   });
 
+  test("isReplyReview matches only reply artifacts, and never a plan", () => {
+    expect(isReplyReview(session({ id: "ses_r", type: "reply" }))).toBe(true);
+    expect(isReplyReview(session({ id: "ses_p", type: "plan" }))).toBe(false);
+    expect(isReplyReview(session({ id: "ses_d", type: "diff" }))).toBe(false);
+    expect(isPlanReview(session({ id: "ses_r", type: "reply" }))).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" });

package/src/open-target.ts

@@ -28,6 +28,9 @@ import type { ReviewSession } from "@cueloop/schema";
 export function isPlanReview(session: ReviewSession): boolean {
   return session.artifact.type === "plan";
 }
+export function isReplyReview(session: ReviewSession): boolean {
+  return session.artifact.type === "reply";
+}
 export function isPrototypeReview(session: ReviewSession): boolean {
   return session.artifact.type === "prototype";
 }
@@ -68,6 +71,7 @@ export function resolveOpenTarget(sessions: ReviewSession[], query: OpenTargetQu
     const latestPending = scoped
       .filter((candidate) => candidate.status === "pending")
       .sort(newestFirst)[0];
+
     return latestPending
       ? { kind: "session", sessionId: latestPending.id }
       : { kind: "no-pending" };
@@ -75,6 +79,7 @@ export function resolveOpenTarget(sessions: ReviewSession[], query: OpenTargetQu
 
   const selector = query.selector;
   const byId = scoped.find((candidate) => candidate.id === selector);
+
   if (byId) return { kind: "session", sessionId: byId.id };
 
   const loweredSelector = selector.toLowerCase();
@@ -83,13 +88,16 @@ export function resolveOpenTarget(sessions: ReviewSession[], query: OpenTargetQu
   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,

package/src/pr.ts

@@ -29,6 +29,7 @@ async function gh(args: string[]): Promise<GhResult> {
     new Response(proc.stderr).text(),
     proc.exited,
   ]);
+
   return { code, stdout, stderr };
 }
 
@@ -42,17 +43,22 @@ const VERDICT_FLAG: Record<VerdictKind, string> = {
 export async function reviewCommand(argv: string[]): Promise<number> {
   const { positional, flags } = parseArgs(argv);
   const pr = positional[0];
+
   if (!pr) {
     console.error("usage: cueloop review <pr> [--no-tui]");
+
     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})`);
+
     return 1;
   }
   if (!diff.stdout.trim()) {
     console.error(`PR ${pr} has an empty diff - nothing to review`);
+
     return 1;
   }
   const client = await DaemonClient.connect({ autostart: true });
@@ -65,21 +71,27 @@ export async function reviewCommand(argv: string[]): Promise<number> {
     pr,
   });
   const session = review.session;
+
   client.close();
 
   if (flags["no-tui"]) {
     console.log(JSON.stringify(session, null, 2));
+
     return 0;
   }
 
   const { runClient } = await import("@cueloop/client");
+
   await runClient({ sessionId: session.id });
 
   const after = await getSession(session.id);
+
   if (after.status !== "resolved" || !after.verdict) {
     console.log(`session ${session.id} is unresolved - nothing was posted to PR ${pr}`);
+
     return 0;
   }
+
   return postVerdict(after, pr);
 }
 
@@ -87,20 +99,26 @@ export async function reviewPostCommand(argv: string[]): Promise<number> {
   const { positional } = parseArgs(argv);
   const sessionId = positional[0];
   const pr = positional[1];
+
   if (!sessionId || !pr) {
     console.error("usage: cueloop review-post <session-id> <pr>");
+
     return 2;
   }
   const session = await getSession(sessionId);
+
   if (session.status !== "resolved" || !session.verdict) {
     console.error(`session ${sessionId} is unresolved - nothing was posted to PR ${pr}`);
+
     return 1;
   }
+
   return postVerdict(session, pr);
 }
 
 async function getSession(id: string): Promise<ReviewSession> {
   const client = await DaemonClient.connect({ autostart: true });
+
   try {
     return await client.sessionGet(id);
   } finally {
@@ -119,10 +137,13 @@ async function postVerdict(session: ReviewSession, pr: string): Promise<number>
     "--body",
     verdict.feedback,
   ]);
+
   if (result.code !== 0) {
     console.error(result.stderr.trim() || `gh pr review ${pr} failed (exit ${result.code})`);
+
     return 1;
   }
   console.log(`posted ${verdict.kind} review to PR ${pr} (session ${session.id})`);
+
   return 0;
 }

package/src/refine-command.test.ts

@@ -32,6 +32,7 @@ function session(
   overrides: Partial<ReviewSession> & { type?: ReviewSession["artifact"]["type"] } = {},
 ): ReviewSession {
   const { type, ...rest } = overrides;
+
   return {
     schemaVersion: "1",
     id,
@@ -87,6 +88,7 @@ describe("refineCommand", () => {
     // Arrange
     const home = tempHome();
     const store = new SessionStore(home);
+
     store.upsert(session("ses_a", { verdict: verdict("approve"), status: "resolved" }));
     store.upsert(
       session("ses_b", {
@@ -119,6 +121,7 @@ describe("refineCommand", () => {
     // Arrange
     const home = tempHome();
     const store = new SessionStore(home);
+
     store.upsert(
       session("ses_x", {
         verdict: verdict("approve"),
@@ -148,6 +151,7 @@ describe("refineCommand", () => {
 
     // Assert
     const secondReport = readFileSync(reportPath, "utf8");
+
     expect(secondReport).toContain("1 sessions analyzed (1 total).");
     expect(secondReport).toContain("two");
   });

package/src/refine-command.ts

@@ -28,6 +28,7 @@ export async function refineCommand(argv: string[]): Promise<number> {
   const nowMs = Date.now();
 
   const store = new SessionStore(home);
+
   store.recover();
   const all = store.list();
 
@@ -40,10 +41,12 @@ export async function refineCommand(argv: string[]): Promise<number> {
   const markdown = buildRefineReport(analyzed, all.length, new Date(nowMs).toISOString());
 
   const directory = reportsDir(home);
+
   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);
 
@@ -64,6 +67,7 @@ export async function refineCommand(argv: string[]): Promise<number> {
       2,
     ),
   );
+
   return 0;
 }
 
@@ -104,6 +108,7 @@ export function buildRefineReport(
           verdictLabel(session),
           isoWeek(annotation.createdAt),
         ].join(" · ");
+
         lines.push(
           `- "${truncate(annotation.anchor.quote, QUOTE_LIMIT)}": ${truncate(annotation.body, BODY_LIMIT)} · ${meta}`,
         );
@@ -140,21 +145,26 @@ function hasReviewSignal(session: ReviewSession): boolean {
 
 function flattenReviewAnnotations(sessions: ReviewSession[]): 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]),
   );
@@ -174,15 +184,19 @@ function byKey<T>(items: T[], keyOf: (item: T) => string): [string, number][] {
 
 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: ReviewSession): string {
   if (session.artifact.type === "diff" && session.artifact.meta.pr) return "pull request";
+
   return session.artifact.type;
 }
 
@@ -201,22 +215,27 @@ function verdictLabel(session: ReviewSession): string {
 
 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;
 }
 
@@ -238,5 +257,6 @@ function readState(home: string): Map<string, string> {
 
 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/session-commands.ts

@@ -42,20 +42,25 @@ async function sessionCreate({ client, flags }: SessionContext): Promise<number>
     title: stringFlag(flags, "title"),
     notes,
   });
+
   // herdr auto-open: render the review in a tab (no-op outside herdr).
   await openHerdrPaneForReview(review.session, client);
   out(review.session);
+
   return 0;
 }
 
 async function sessionGetCommand({ client, positional }: SessionContext): Promise<number> {
   out(await client.sessionGet(required(positional[1], "session id")));
+
   return 0;
 }
 
 async function sessionListCommand({ client, flags }: SessionContext): Promise<number> {
   const status = stringFlag(flags, "status") as "pending" | "resolved" | undefined;
+
   out(await client.sessionList(status ? { status } : undefined));
+
   return 0;
 }
 
@@ -63,12 +68,16 @@ async function sessionWaitCommand({ client, positional, flags }: SessionContext)
   const id = required(positional[1], "session id");
   const timeoutMs = Number(stringFlag(flags, "timeout-ms") ?? "60000");
   const session = await client.sessionWait(id, timeoutMs);
+
   if (session === null) {
     out({ status: "pending" });
+
     return 0;
   }
   const { allow, feedback } = verdictResponse(session);
+
   out({ status: "resolved", allow, verdict: session.verdict!.kind, feedback });
+
   return 0;
 }
 
@@ -81,6 +90,7 @@ async function sessionAnnotateCommand({
   const quote = required(stringFlag(flags, "quote"), "--quote");
   const author = stringFlag(flags, "author");
   const body = await annotateBody(flags, client, id);
+
   out(
     await client.sessionAnnotate(
       id,
@@ -98,6 +108,7 @@ async function sessionAnnotateCommand({
       stringFlag(flags, "author-name"),
     ),
   );
+
   return 0;
 }
 
@@ -108,7 +119,9 @@ async function sessionResolveCommand({
 }: SessionContext): Promise<number> {
   const id = required(positional[1], "session id");
   const kind = required(stringFlag(flags, "verdict"), "--verdict") as VerdictKind;
+
   out(await client.sessionResolve(id, kind, stringFlag(flags, "summary") ?? ""));
+
   return 0;
 }
 
@@ -125,7 +138,9 @@ async function sessionSubmitRevisionCommand({
     .split(",")
     .map((annotationId) => annotationId.trim())
     .filter(Boolean);
+
   out(await client.sessionSubmitRevision(id, content, addressed));
+
   return 0;
 }
 
@@ -146,14 +161,18 @@ export async function sessionCommand(argv: string[]): Promise<number> {
   // review-side agent passes it so the daemon rejects any escalation attempt.
   const role = stringFlag(flags, "role") === "agent" ? "agent" : undefined;
   const client = await DaemonClient.connect({ autostart: true, role });
+
   try {
     const handler = verb !== undefined ? sessionVerbHandlers[verb] : undefined;
+
     if (handler === undefined) {
       console.error(
         "usage: cueloop session <create|get|list|wait|annotate|resolve|submit-revision> [flags]",
       );
+
       return 2;
     }
+
     return await handler({ client, positional, flags });
   } finally {
     client.close();
@@ -162,6 +181,7 @@ export async function sessionCommand(argv: string[]): Promise<number> {
 
 function required<T>(value: T | undefined, description: string): T {
   if (value === undefined) throw new Error(`missing ${description}`);
+
   return value;
 }
 
@@ -177,12 +197,16 @@ async function annotateBody(
   id: string,
 ): Promise<string> {
   const explicit = stringFlag(flags, "body");
+
   if (explicit !== undefined) return explicit;
   const actionRef = stringFlag(flags, "action");
+
   if (actionRef === undefined) return "";
   const session = await client.sessionGet(id);
   const actions = loadConfig({ repoRoot: session.workspace.repoRoot }).actions;
   const action = resolveQuickAction(actions, actionRef);
+
   if (!action) throw new Error(`no quick action ${actionRef} - see: cueloop actions list`);
+
   return quickActionBody(action);
 }

package/src/share-command.test.ts

@@ -26,6 +26,7 @@ function annotationFixture(id: string, author?: string): Annotation {
     body: "note",
     createdAt: "2026-01-01T00:00:00.000Z",
   };
+
   return author ? { ...base, author } : base;
 }
 
@@ -36,14 +37,18 @@ function fakeClient(sessions: ReviewSession[]): SessionClient {
     sessionList: async () => sessions,
     sessionSetShareId: mock(async (id: string, shareId: string) => {
       const session = sessions.find((candidate) => candidate.id === id)!;
+
       session.shareId = shareId;
+
       return session;
     }),
     sessionMergeShared: mock(async (id: string, incoming: { annotations: Annotation[] }) => {
       const session = sessions.find((candidate) => candidate.id === id)!;
       const known = new Set(session.annotations.map((annotation) => annotation.id));
+
       for (const annotation of incoming.annotations)
         if (!known.has(annotation.id)) session.annotations.push(annotation);
+
       return session;
     }),
   } as unknown as SessionClient;
@@ -51,6 +56,7 @@ function fakeClient(sessions: ReviewSession[]): 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),
@@ -141,6 +147,7 @@ describe(shareSession, () => {
 
 function pullDepsSpy(remote: ReviewSession): PullDeps & { lines: string[] } {
   const lines: string[] = [];
+
   return {
     pull: mock(async () => remote),
     out: (message: string) => void lines.push(message),

package/src/share-command.ts

@@ -43,6 +43,7 @@ export async function shareCommand(
   deps: ShareDeps = defaultDeps,
 ): Promise<number> {
   const client = await DaemonClient.connect({ home: params.home, autostart: true });
+
   try {
     return await shareSession(client, params, deps);
   } finally {
@@ -56,6 +57,7 @@ export async function sharePullCommand(
   deps: PullDeps = defaultPullDeps,
 ): Promise<number> {
   const client = await DaemonClient.connect({ home: params.home, autostart: true });
+
   try {
     return await pullSession(client, params, deps);
   } finally {
@@ -70,14 +72,18 @@ export async function shareSession(
   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 });
   const shareId = shareIdFromLine(line);
+
   if (shareId) await client.sessionSetShareId(session.id, shareId);
   deps.out(copied ? `share link copied - ${line}` : line);
+
   return 0;
 }
 
@@ -92,8 +98,10 @@ export async function pullSession(
   deps: PullDeps,
 ): Promise<number> {
   const session = await pickSharedSession(client, params.sessionId);
+
   if (!session) {
     deps.out("no shared plan to pull - run `cueloop share` first");
+
     return 1;
   }
   const remote = await deps.pull(session.shareId!, { host: params.host, port: params.port });
@@ -103,9 +111,11 @@ export async function pullSession(
     participants: remote.participants,
   });
   const added = merged.annotations.length - before;
+
   deps.out(
     added > 0 ? `pulled ${added} new annotation${added === 1 ? "" : "s"}` : "no new annotations",
   );
+
   return 0;
 }
 
@@ -116,6 +126,7 @@ async function pickSession(
 ): Promise<ReviewSession | null> {
   if (sessionId) return client.sessionGet(sessionId);
   const sessions = await client.sessionList();
+
   return sessions.at(-1) ?? null;
 }
 
@@ -126,8 +137,10 @@ async function pickSharedSession(
 ): Promise<ReviewSession | null> {
   if (sessionId) {
     const session = await client.sessionGet(sessionId);
+
     return session.shareId ? session : null;
   }
   const sessions = await client.sessionList();
+
   return sessions.filter((session) => session.shareId).at(-1) ?? null;
 }

package/src/wake-command.ts

@@ -16,22 +16,29 @@ import { parseArgs, stringFlag } from "./args";
 export async function wakeCommand(argv: string[]): Promise<number> {
   const { positional, flags } = parseArgs(argv);
   const sessionId = positional[0];
+
   if (sessionId === undefined) {
     console.error(
       "usage: cueloop wake <session-id> [--harness claude-code|codex] [--thread <codex-thread-id>]",
     );
+
     return 2;
   }
   const harness = stringFlag(flags, "harness") ?? "claude-code";
+
   if (harness === "codex") {
     const threadId = stringFlag(flags, "thread");
+
     if (threadId === undefined) {
       console.error("cueloop wake --harness codex needs --thread <codex-thread-id>");
+
       return 2;
     }
     const { runCodexWake } = await import("@cueloop/adapters/codex/wake");
+
     return (await runCodexWake(sessionId, threadId)) ? 0 : 1;
   }
   const { runInboxWake } = await import("@cueloop/adapters/claude-code/wake");
+
   return (await runInboxWake(sessionId)) ? 0 : 1;
 }