cueloop 0.1.0-alpha.102 → 0.1.0-alpha.103

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cueloop",
-  "version": "0.1.0-alpha.102",
+  "version": "0.1.0-alpha.103",
   "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": {
@@ -30,11 +30,11 @@
     "build:binary": "bun build --compile --bytecode --format=esm --minify --external cpu-features ./src/main.ts --outfile dist/cueloop"
   },
   "dependencies": {
-    "@cueloop/adapters": "0.1.0-alpha.102",
-    "@cueloop/client": "0.1.0-alpha.102",
-    "@cueloop/daemon": "0.1.0-alpha.102",
-    "@cueloop/extension-api": "0.1.0-alpha.102",
-    "@cueloop/schema": "0.1.0-alpha.102",
+    "@cueloop/adapters": "0.1.0-alpha.103",
+    "@cueloop/client": "0.1.0-alpha.103",
+    "@cueloop/daemon": "0.1.0-alpha.103",
+    "@cueloop/extension-api": "0.1.0-alpha.103",
+    "@cueloop/schema": "0.1.0-alpha.103",
     "@modelcontextprotocol/server": "2.1.0",
     "@valibot/to-json-schema": "1.8.0",
     "valibot": "^1.5.0"

package/src/actions-command.ts

@@ -19,6 +19,7 @@ export async function actionsCommand(argv: string[]): Promise<number> {
 
     return 2;
   }
+
   const role = stringFlag(flags, "role") === "agent" ? "agent" : undefined;
   const repoRoot = await repoRootForSession(stringFlag(flags, "session"), role);
   const actions = loadConfig({ repoRoot }).actions;
@@ -39,6 +40,7 @@ async function repoRootForSession(
   role: "agent" | undefined,
 ): Promise<string> {
   if (sessionId === undefined) return process.cwd();
+
   const client = await DaemonClient.connect({ autostart: true, role });
 
   try {

package/src/agent-harness.ts

@@ -1,18 +1,17 @@
 import { createPiHarness } from "@cueloop/adapters/pi/durable-harness";
 import { cueloopHome } from "@cueloop/daemon";
+import { createThreadHarness } from "@cueloop/adapters/thread-harness";
 import { createFxHarness } from "@cueloop/adapters/fx/harness";
 import { loadConfig } from "@cueloop/client/config";
 import type { AgentHarnessAdapter } from "@cueloop/schema";
 
-/** Select a locally installed harness; unsupported providers fail before a daemon starts. */
-export function configuredAgentHarness(): AgentHarnessAdapter | undefined {
-  const id = process.env.CUELOOP_AGENT_HARNESS ?? "pi";
+/** Explicit startup selection overrides the owner and workspace preferences. */
+export function configuredAgentHarnessId(repoRoot?: string): "pi" | "fx" {
+  const id = process.env.CUELOOP_AGENT_HARNESS ?? loadConfig({ repoRoot }).thread.harness;
 
-  if (id === "pi") return createPiHarness({ home: cueloopHome() });
+  if (id !== "pi" && id !== "fx") throw new Error(`Thread agent harness is not installed: ${id}`);
 
-  if (id !== "fx") throw new Error(`Thread agent harness is not installed: ${id}`);
-
-  return fxHarness();
+  return id;
 }
 
 /** Resolve the experimental Thread agent flag from user and workspace TOML. */
@@ -28,5 +27,8 @@ export function installedAgentHarnesses() {
 }
 
 function fxHarness(): AgentHarnessAdapter {
-  return createFxHarness({ command: [process.env.CUELOOP_FX_EXECUTABLE ?? "fx", "acp"] });
+  return createThreadHarness({
+    home: cueloopHome(),
+    backend: createFxHarness({ command: [process.env.CUELOOP_FX_EXECUTABLE ?? "fx", "acp"] }),
+  });
 }

package/src/args.ts

@@ -18,6 +18,7 @@ export function parseArgs(argv: string[], booleanFlags: readonly string[] = []):
       positional.push(argument);
       continue;
     }
+
     const equalsIndex = argument.indexOf("=");
 
     if (equalsIndex !== -1) {

package/src/codex-delivery-worker-command.test.ts

@@ -38,6 +38,7 @@ test("a Codex reply is delivered without an MCP transport", async () => {
   );
 
   if (opened.operation !== "open") throw new Error("expected open Thread");
+
   const previousCodexBin = process.env.CUELOOP_CODEX_BIN;
 
   // A reused PID belonging to this test process must not impersonate the worker.
@@ -49,8 +50,10 @@ test("a Codex reply is delivered without an MCP transport", async () => {
     import.meta.dir + "/main.ts",
     "codex-delivery-worker",
   ]);
+
   if (previousCodexBin === undefined) delete process.env.CUELOOP_CODEX_BIN;
   else process.env.CUELOOP_CODEX_BIN = previousCodexBin;
+
   expect(worker).toBeDefined();
   const deadline = Date.now() + 5000;
 

package/src/codex-delivery-worker-command.ts

@@ -17,6 +17,7 @@ function claimWorker(path: string): boolean {
       return true;
     } catch (error) {
       if (!(error instanceof Error && "code" in error && error.code === "EEXIST")) throw error;
+
       const before = statSync(path);
       const owner = Number(readFileSync(path, "utf8"));
 
@@ -39,7 +40,9 @@ function claimWorker(path: string): boolean {
       } else if (Date.now() - before.mtimeMs < 5_000) {
         return false;
       }
+
       if (statSync(path).ino !== before.ino) return false;
+
       unlinkSync(path);
     }
   }
@@ -53,6 +56,7 @@ export async function codexDeliveryWorkerCommand(): Promise<number> {
   const lockPath = join(home, "codex-delivery-worker.pid");
 
   if (!claimWorker(lockPath)) return 0;
+
   const sessions = createCodexSessionRegistry(home);
   const delivery = createCodexDeliveryService({
     home,
@@ -70,6 +74,7 @@ export async function codexDeliveryWorkerCommand(): Promise<number> {
     }
   } finally {
     delivery.stop();
+
     if (readFileSync(lockPath, "utf8") === String(process.pid)) unlinkSync(lockPath);
   }
 

package/src/codex-mcp-command.ts

@@ -41,6 +41,7 @@ export function createCodexMcpServer(home = cueloopHome()): McpServer {
             "cueloop Codex session is not authorized; trust the plugin hooks and restart Codex",
           );
         }
+
         const { hookToken: _hookToken, ...threadInput } = input;
         const result = await runHarnessBridge(
           { operation: "open", harness: "codex", ...threadInput },

package/src/daemon-command.ts

@@ -8,20 +8,26 @@ export async function daemonCommand(argv: string[]): Promise<number> {
   let idleExitMs: number | undefined = 0;
 
   if (argv.includes("--autostart")) idleExitMs = envIdle ? Number(envIdle) : undefined;
-  const { configuredAgentHarness, installedAgentHarnesses, threadAgentEnabled } =
+
+  const { configuredAgentHarnessId, installedAgentHarnesses, threadAgentEnabled } =
     await import("./agent-harness");
+  const adapters = installedAgentHarnesses();
   let relay: OwnerAgentRelay | undefined;
   const server = new DaemonServer({
     onEvent: (event) => {
       relay?.notify(event);
+
       if (event.event !== "agent.updated") relay?.update(server.core.sessionList());
     },
     idleExitMs,
+    agentHarnessDefault: () => configuredAgentHarnessId(),
     threadAgent: {
       enabled: true,
       enabledForThread: (thread) => threadAgentEnabled(thread.workspace.repoRoot),
-      adapter: configuredAgentHarness(),
-      adapters: installedAgentHarnesses(),
+      adapter: adapters[configuredAgentHarnessId()],
+      adapters,
+      defaultHarnessForThread: (thread) =>
+        adapters[configuredAgentHarnessId(thread.workspace.repoRoot)],
     },
   });
   const path = server.start();
@@ -31,6 +37,7 @@ export async function daemonCommand(argv: string[]): Promise<number> {
 
     return 1;
   }
+
   server.resumeAgents();
   relay = new OwnerAgentRelay({
     home: server.home,

package/src/daemon-control.ts

@@ -21,6 +21,7 @@ function signalDaemonByProcessId(home: string): boolean {
   const path = pidPath(home);
 
   if (!existsSync(path)) return false;
+
   let raw: string;
 
   try {
@@ -31,6 +32,7 @@ function signalDaemonByProcessId(home: string): boolean {
   const parsed = v.safeParse(ProcessIdSchema, raw);
 
   if (!parsed.success) return false;
+
   try {
     process.kill(parsed.output);
 
@@ -47,6 +49,7 @@ async function waitForSocketGone(home: string): Promise<boolean> {
 
   while (Date.now() < deadline) {
     if (!existsSync(path)) return true;
+
     await Bun.sleep(50);
   }
 
@@ -62,6 +65,7 @@ async function waitForSocketGone(home: string): Promise<boolean> {
  */
 export async function stopDaemon(home = cueloopHome()): Promise<boolean> {
   if (!existsSync(socketPath(home))) return false;
+
   try {
     const client = await DaemonClient.connect({ home, autostart: false });
 
@@ -83,6 +87,7 @@ export async function stopCommand(): Promise<number> {
 
     return 0;
   }
+
   const stopped = await stopDaemon(home);
 
   console.log(stopped ? "cueloop daemon stopped" : "cueloop daemon did not stop in time");

package/src/dev-command.ts

@@ -97,17 +97,22 @@ async function refreshDevSeed(client: DaemonClient, home: string): Promise<void>
   writeFileSync(versionFile, String(SEED_VERSION));
 }
 
-/** `cueloop dev`: seed an isolated dev home (refreshing a stale seed), then open the TUI on it. */
-export async function devCommand(): Promise<number> {
-  const home = (process.env.CUELOOP_HOME ??= threadAgentEnabled(process.cwd())
+export function configureDevHome(): string {
+  return (process.env.CUELOOP_HOME ??= threadAgentEnabled(process.cwd())
     ? join(process.cwd(), ".cueloop-dev")
     : join(homedir(), ".cueloop-dev"));
+}
+
+/** `cueloop dev`: seed an isolated dev home (refreshing a stale seed), then open the TUI on it. */
+export async function devCommand(): Promise<number> {
+  const home = configureDevHome();
 
   let sessionId: string | undefined;
   const client = await DaemonClient.connect({ autostart: true });
 
   try {
     await refreshDevSeed(client, home);
+
     if (threadAgentEnabled(process.cwd()))
       sessionId = (await client.sessionList()).find(
         (thread) => thread.artifact.meta.title === "Read the repository",

package/src/harness-selection.test.ts

@@ -0,0 +1,22 @@
+import { expect, test } from "bun:test";
+import { parseHarnessSelection } from "./harness-selection";
+
+test("harness selection supports launcher and restart without stealing session flags", () => {
+  expect(parseHarnessSelection(["--harness", "fx"])).toEqual({ args: [], harness: "fx" });
+  expect(parseHarnessSelection(["restart", "--harness=pi"])).toEqual({
+    args: ["restart"],
+    harness: "pi",
+  });
+  expect(parseHarnessSelection(["--harness", "fx", "plan", "thread-id"])).toEqual({
+    args: ["plan", "thread-id"],
+    harness: "fx",
+  });
+  expect(parseHarnessSelection(["session", "bind-harness", "--harness", "codex"])).toEqual({
+    args: ["session", "bind-harness", "--harness", "codex"],
+  });
+  expect(() => parseHarnessSelection(["restart", "--harness"])).toThrow(
+    "--harness pi or --harness fx",
+  );
+  expect(() => parseHarnessSelection(["--harness=bad"])).toThrow("--harness pi or --harness fx");
+  expect(() => parseHarnessSelection(["--harness=pi", "--harness=fx"])).toThrow("only one");
+});

package/src/harness-selection.ts

@@ -0,0 +1,45 @@
+import { DaemonClient } from "@cueloop/daemon/client";
+
+/** Global harness flags never consume a session primitive's unrelated --harness argument. */
+interface HarnessSelection {
+  args: string[];
+  harness?: "pi" | "fx";
+}
+
+export function parseHarnessSelection(args: readonly string[]): HarnessSelection {
+  const remaining = [...args];
+  const global = args[0]?.startsWith("--harness") || args[0] === "restart" || args[0] === "daemon";
+
+  if (!global) return { args: remaining };
+
+  const index = remaining.findIndex((arg) => arg === "--harness" || arg.startsWith("--harness="));
+
+  if (index < 0) return { args: remaining };
+
+  const flag = remaining[index]!;
+  const value = flag === "--harness" ? remaining[index + 1] : flag.slice("--harness=".length);
+
+  if (value !== "pi" && value !== "fx")
+    throw new Error("Thread harness selection requires --harness pi or --harness fx");
+
+  remaining.splice(index, flag === "--harness" ? 2 : 1);
+
+  if (remaining.some((arg) => arg === "--harness" || arg.startsWith("--harness=")))
+    throw new Error("Thread harness selection accepts only one --harness flag");
+
+  return { args: remaining, harness: value };
+}
+
+/** A running daemon must confirm the requested default before a launcher opens its UI. */
+export async function assertDaemonHarness(harness: "pi" | "fx"): Promise<void> {
+  const client = await DaemonClient.connect({ autostart: true });
+
+  try {
+    const current = await client.ping();
+
+    if (current.agentHarness !== harness)
+      throw new Error(`Thread harness default mismatch. Run cueloop restart --harness ${harness}.`);
+  } finally {
+    client.close();
+  }
+}

package/src/install-command.test.ts

@@ -74,6 +74,7 @@ describe("cueloop install", () => {
       installRoot: root,
       runPackageCommand: async (args) => {
         commands.push(args);
+
         if (args[0] === "add") {
           const packageRoot = join(root, "node_modules", "example");
 
@@ -112,6 +113,7 @@ describe("cueloop install", () => {
       installRoot: root,
       runPackageCommand: async (args) => {
         commands.push(args);
+
         if (args.at(-1) === "example@2.0.0") {
           writeFileSync(
             join(root, "package.json"),

package/src/install-command.ts

@@ -34,6 +34,7 @@ function previousPackageSpec(installRoot: string, name: string): string | null {
   const path = join(installRoot, "node_modules", name, "package.json");
 
   if (!existsSync(path)) return null;
+
   try {
     const parsed = v.safeParse(
       v.object({ version: v.pipe(v.string(), v.minLength(1)) }),
@@ -59,6 +60,7 @@ export async function installExtensionCommand(
 
     return 2;
   }
+
   const name = match[1]!;
   const spec = source!.slice("npm:".length);
   const installRoot = options.installRoot ?? extensionInstallRoot();
@@ -74,6 +76,7 @@ export async function installExtensionCommand(
       JSON.stringify({ name: "cueloop-extensions", private: true }, null, 2),
     );
   }
+
   const { exitCode, stderr } = await runCommand([
     "add",
     "--ignore-scripts",
@@ -87,6 +90,7 @@ export async function installExtensionCommand(
 
     return 1;
   }
+
   const discovered = discoverInstalledExtensionPackages(installRoot);
   const installed = discovered.packages.find((entry) => entry.name === name);
 
@@ -107,6 +111,7 @@ export async function installExtensionCommand(
 
     return 1;
   }
+
   console.log(
     `Installed ${name}. Restart cueloop and run 'cueloop restart' to load daemon capabilities.`,
   );

package/src/main.ts

@@ -8,6 +8,7 @@
  * observers), `cueloop daemon` runs the daemon in the foreground.
  */
 
+import { parseHarnessSelection, assertDaemonHarness } from "./harness-selection";
 import { basename, resolve } from "node:path";
 import { parseArgs, stringFlag, type ParsedArgs } from "./args";
 import {
@@ -29,7 +30,11 @@ import { openReview } from "@cueloop/daemon/thread-review";
 // The CLI owns adapter composition; the daemon package still starts independently.
 process.env.CUELOOP_DAEMON_ENTRY = import.meta.path;
 
-const argv = process.argv.slice(2);
+const harnessSelection = parseHarnessSelection(process.argv.slice(2));
+const argv = harnessSelection.args;
+
+if (harnessSelection.harness) process.env.CUELOOP_AGENT_HARNESS = harnessSelection.harness;
+
 const cmd = argv[0];
 
 async function serveEntry(rest: string[]): Promise<number> {
@@ -116,20 +121,25 @@ 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;
@@ -170,11 +180,13 @@ async function openReviewOfKind(
   const target = resolveOpenTarget(sessions, { match, selector });
 
   if (target.kind === "session") return runTui(target.sessionId, layout);
+
   if (target.kind === "no-pending" && emptyMessage !== undefined) {
     console.error(emptyMessage);
 
     return 1;
   }
+
   console.error(openTargetMessage(label, target));
 
   return 1;
@@ -223,6 +235,7 @@ async function prototypeCommand(argv: string[]): Promise<number> {
 
     return 1;
   }
+
   const client = await DaemonClient.connect({ autostart: true });
   const review = await openReview(client, {
     type: "prototype",
@@ -262,6 +275,7 @@ async function diffCommand(argv: string[]): Promise<number> {
       initialReview = await client.workbenchReview(cwd);
     } catch (error) {
       if (!(error instanceof DaemonClientError) || error.code !== "unknown_method") throw error;
+
       const session = await client.sessionWorkbench(cwd);
       const diff = await client.repoDiff(cwd);
 
@@ -286,12 +300,14 @@ async function pairCommand(argv: string[]): Promise<number> {
 
     if (sessionId !== undefined) {
       thread = await client.sessionGet(sessionId);
+
       if (thread.artifact.meta.workbench !== true || thread.status !== "pending") {
         throw new Error(`Thread ${sessionId} is not an open workbench`);
       }
     } else {
       thread = await client.sessionWorkbench(process.cwd());
     }
+
     if (parsed.flags["open-tab"] === true) {
       const { openHerdrThreadSurface } = await import("@cueloop/daemon/herdr-thread-surface");
 
@@ -300,6 +316,7 @@ async function pairCommand(argv: string[]): Promise<number> {
   } finally {
     client.close();
   }
+
   if (parsed.flags["no-tui"] === true || parsed.flags["open-tab"] === true) {
     console.log(
       JSON.stringify({ threadId: thread.id, startedAt, ...(openStatus && { openStatus }) }),
@@ -405,13 +422,27 @@ function printHelp(): void {
       "  cueloop review-comment <id>      add or update an agent PR finding (see --help)",
       "  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",
+      "  cueloop restart [--harness pi|fx] restart with the preferred Thread harness",
       "  cueloop dev                      open the TUI on an isolated home seeded with example threads",
       "",
+      "  cueloop --harness pi|fx         select the default for new Threads",
       "  cueloop -v, --version            print the installed version",
       "  cueloop -h, --help               print this help",
     ].join("\n"),
   );
 }
 
+if (cmd === "dev") (await import("./dev-command")).configureDevHome();
+
+if (
+  harnessSelection.harness &&
+  cmd !== "restart" &&
+  cmd !== "daemon" &&
+  cmd !== "--help" &&
+  cmd !== "-h" &&
+  cmd !== "--version" &&
+  cmd !== "-v"
+)
+  await assertDaemonHarness(harnessSelection.harness);
+
 process.exit(await main());

package/src/open-target.ts

@@ -94,6 +94,7 @@ export function resolveOpenTarget(sessions: Thread[], query: OpenTargetQuery): O
     .sort(newestFirst);
 
   if (substringMatches.length === 1) return { kind: "session", sessionId: substringMatches[0]!.id };
+
   if (substringMatches.length === 0) return { kind: "no-match", selector };
 
   return {

package/src/pr.ts

@@ -65,7 +65,9 @@ function isReviewSeverity(value: string): value is ReviewSeverity {
 
 function reviewEvent(value: string): GitHubReviewEvent | undefined {
   if (value === "comment") return "COMMENT";
+
   if (value === "approve") return "APPROVE";
+
   if (value === "request-changes") return "REQUEST_CHANGES";
 
   return undefined;
@@ -75,6 +77,7 @@ function reviewSummary(event: GitHubReviewEvent, body?: string): string | undefi
   const trimmed = body?.trim();
 
   if (trimmed) return trimmed;
+
   if (event === "APPROVE") return undefined;
 
   return "Review submitted with cueloop.";
@@ -115,6 +118,7 @@ async function reanchorReviewComments(
         `finding ${annotation.id} is outdated or ambiguous - refresh the finding before posting`,
       );
     }
+
     const line = finding.side === "RIGHT" ? matched.newLine! : matched.oldLine!;
     let startLine: number | undefined;
 
@@ -124,6 +128,7 @@ async function reanchorReviewComments(
           `finding ${annotation.id} has no start anchor - refresh the finding before posting`,
         );
       }
+
       const matchedStart = resolveLine(finding.startAnchor);
 
       if (!matchedStart) {
@@ -131,6 +136,7 @@ async function reanchorReviewComments(
           `finding ${annotation.id} start is outdated or ambiguous - refresh the finding before posting`,
         );
       }
+
       startLine = finding.side === "RIGHT" ? matchedStart.newLine! : matchedStart.oldLine!;
 
       if (startLine >= line) {
@@ -174,11 +180,16 @@ function reviewFindingInput(flags: Record<string, string | boolean>): ReviewFind
   const suggestion = textFlag(flags, "suggestion", "suggestion-file");
 
   if (!body) throw new Error("--body or --body-file is required");
+
   if (side !== "LEFT" && side !== "RIGHT") throw new Error("--side must be LEFT or RIGHT");
+
   if (!isReviewSeverity(severity)) throw new Error("--severity must be p0, p1, or p2");
+
   if (!Number.isInteger(line) || line < 1) throw new Error("--line must be a positive integer");
+
   if (startLine !== undefined && (!Number.isInteger(startLine) || startLine < 1))
     throw new Error("--start-line must be a positive integer");
+
   if (suggestion?.trim() && side !== "RIGHT")
     throw new Error("suggestions must target the RIGHT side of a diff");
 
@@ -216,12 +227,14 @@ async function reviewFindingAnnotation(
     throw new Error(
       `${input.path}:${input.line} is not present on the ${input.side} side of this diff`,
     );
+
   const fileRange = fileRowRange(rows, input.path)!;
   const fileRows = rows.slice(fileRange.start, fileRange.end);
   let startAnchor: Annotation["anchor"] | undefined;
 
   if (input.startLine !== undefined) {
     if (input.startLine >= input.line) throw new Error("--start-line must be before --line");
+
     const startRowIndex = rows.findIndex(
       (candidate) =>
         candidate.file === input.path &&
@@ -234,8 +247,10 @@ async function reviewFindingAnnotation(
       throw new Error(
         `${input.path}:${input.startLine} is not present on the ${input.side} side of this diff`,
       );
+
     startAnchor = diffRowAnchor(fileRows, startRowIndex - fileRange.start);
   }
+
   const id = input.id ?? nextFindingId(session.annotations);
   const existing = session.annotations.find((annotation) => annotation.id === id);
 
@@ -275,6 +290,7 @@ export async function reviewCommentCommand(argv: string[]): Promise<number> {
 
     return 2;
   }
+
   try {
     const client = await DaemonClient.connect({ autostart: true, role: "agent", author: "agent" });
 
@@ -317,6 +333,7 @@ export async function reviewCommand(argv: string[]): Promise<number> {
 
     return 2;
   }
+
   let imported: Awaited<ReturnType<ReturnType<typeof forge>["importPullRequest"]>>;
 
   try {
@@ -335,6 +352,7 @@ export async function reviewCommand(argv: string[]): Promise<number> {
 
     return 1;
   }
+
   const client = await DaemonClient.connect({ autostart: true });
   // A PR diff is a partial patch with no full file contents, so no `files` here;
   // hunk curation stays disabled for PR reviews (see diff-hunk-curate.ts).
@@ -384,6 +402,7 @@ export async function reviewOpenCommand(argv: string[]): Promise<number> {
 
     return 2;
   }
+
   const client = await DaemonClient.connect({ autostart: true });
 
   try {
@@ -417,6 +436,7 @@ export async function reviewPostCommand(argv: string[]): Promise<number> {
 
     return 2;
   }
+
   const session = await getSession(sessionId);
   const pr = session.artifact.meta.pr;
 
@@ -430,11 +450,13 @@ export async function reviewPostCommand(argv: string[]): Promise<number> {
 
     return 1;
   }
+
   if (session.status !== "resolved" || !session.message) {
     console.error(`session ${sessionId} is unresolved - approve or request changes before posting`);
 
     return 1;
   }
+
   const selectedIds = new Set(
     (stringFlag(flags, "comments") ?? "")
       .split(",")
@@ -453,6 +475,7 @@ export async function reviewPostCommand(argv: string[]): Promise<number> {
 
     return 1;
   }
+
   const eventFlag = stringFlag(flags, "event") ?? "comment";
   const event = reviewEvent(eventFlag);
 
@@ -461,6 +484,7 @@ export async function reviewPostCommand(argv: string[]): Promise<number> {
 
     return 2;
   }
+
   try {
     const body = reviewSummary(event, textFlag(flags, "body", "body-file"));
     const forgePort = forge();
@@ -475,10 +499,12 @@ export async function reviewPostCommand(argv: string[]): Promise<number> {
     ) {
       throw new Error("pull request changed since this review - refresh before posting");
     }
+
     const comments = await reanchorReviewComments(session, selectedComments);
     const number = Number(new URL(session.artifact.meta.prUrl).pathname.split("/").at(-1));
 
     if (!Number.isInteger(number)) throw new Error("pull request URL has no numeric PR number");
+
     const posted = await forgePort.postPullRequestComments({
       publicationId: reviewPublicationId(
         session,

package/src/share-command.ts

@@ -80,6 +80,7 @@ export async function shareSession(
 
     return 1;
   }
+
   const session = params.fork ? await client.sessionFork(picked.id) : picked;
   // a workbench thread renders live locally; freeze its diff so the remote reviewer gets a stable snapshot
   const shared = client.repoDiff
@@ -98,7 +99,9 @@ export async function shareSession(
         shareBranch: session.history?.branch ?? "main",
       },
     ]);
+
   if (params.fork) deps.out(`forked ${picked.id} as ${session.id}`);
+
   deps.out(copied ? `share link copied - ${line}` : line);
 
   return 0;
@@ -121,6 +124,7 @@ export async function pullSession(
 
     return 1;
   }
+
   const remote = await deps.pull(session.shares!.at(-1)!.id, {
     host: params.host,
     port: params.port,
@@ -143,6 +147,7 @@ export async function pullSession(
 /** The named session, or the most recent one when no id is given. */
 async function pickSession(client: ThreadClient, sessionId?: string): Promise<Thread | null> {
   if (sessionId) return client.sessionGet(sessionId);
+
   const sessions = await client.sessionList();
 
   return sessions.at(-1) ?? null;
@@ -155,6 +160,7 @@ async function pickSharedSession(client: ThreadClient, sessionId?: string): Prom
 
     return session.shares?.length ? session : null;
   }
+
   const sessions = await client.sessionList();
 
   return sessions.filter((session) => session.shares?.length).at(-1) ?? null;

package/src/thread-commands.ts

@@ -46,6 +46,7 @@ async function sessionCreate({ client, flags }: SessionContext): Promise<number>
 
     return 2;
   }
+
   const contentFile = stringFlag(flags, "content-file");
   const content = contentFile ? await Bun.file(contentFile).text() : await readStdin();
   // per-file agent notes for diff sessions: a JSON array of { path, body }
@@ -76,6 +77,7 @@ async function sessionCreate({ client, flags }: SessionContext): Promise<number>
   if (openResult !== "opened" && openResult !== "focused") {
     console.error(manualThreadOpenCommand(review.id));
   }
+
   out(review.session);
 
   return 0;
@@ -113,6 +115,7 @@ async function sessionWaitCommand({ client, positional, flags }: SessionContext)
 
     return 0;
   }
+
   const { allow, message } = messageResponse(session);
 
   out({ status: "resolved", allow, message });
@@ -143,6 +146,7 @@ async function annotateAnchor(
       ? { anchor: root.anchor, replyTo: root.replyTo ?? root.id }
       : { anchor: root.anchor, replyTo: root.replyTo ?? root.id, target: root.target };
   }
+
   const selector = stringFlag(flags, "selector");
   const quote =
     selector === undefined
@@ -177,6 +181,7 @@ async function sessionAnnotateCommand({
   };
 
   if (replyTo !== undefined) base.replyTo = replyTo;
+
   const annotation: Omit<Annotation, "createdAt"> =
     target === undefined ? base : { ...base, target };
 
@@ -351,7 +356,9 @@ async function sessionEventsCommand({
   const stream = new Promise<number>((resolve) => {
     client.onEvent((event) => {
       if (event.sessionId !== id) return;
+
       out(event);
+
       if (once) resolve(0);
     });
   });
@@ -359,6 +366,7 @@ async function sessionEventsCommand({
   const disconnect = new Promise<number>((resolve) => {
     client.onDisconnect(() => {
       if (finished) return;
+
       console.error("daemon connection closed - restart cueloop session events to resume");
       resolve(1);
     });
@@ -366,6 +374,7 @@ async function sessionEventsCommand({
 
   await client.subscribe();
   await client.sessionGet(id);
+
   if (ready) console.log(JSON.stringify({ event: "events.ready", sessionId: id }));
 
   const code = await Promise.race([stream, disconnect]);
@@ -546,9 +555,11 @@ async function annotateBody(
   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);

package/src/update-command.ts

@@ -52,6 +52,7 @@ async function fetchLatestVersion(): Promise<string | undefined> {
     const response = await fetch(RELEASES_URL, { headers: { "user-agent": "cueloop-update" } });
 
     if (!response.ok) return undefined;
+
     const parsed = v.safeParse(ReleasesSchema, await response.json());
 
     if (!parsed.success) return undefined;
@@ -87,6 +88,7 @@ async function runInstaller(targetInstallDir: string): Promise<number> {
 
       return 1;
     }
+
     const parsed = v.safeParse(InstallerScriptSchema, await response.text());
 
     if (!parsed.success) {
@@ -94,6 +96,7 @@ async function runInstaller(targetInstallDir: string): Promise<number> {
 
       return 1;
     }
+
     const child = Bun.spawn(["sh"], {
       stdin: "pipe",
       stdout: "inherit",
@@ -143,11 +146,13 @@ export async function runUpdate(deps: UpdateDeps, dryRun: boolean): Promise<numb
 
     return 1;
   }
+
   if (!targetInstallDir.startsWith("/")) {
     deps.error("cueloop update: CUELOOP_INSTALL_DIR must be an absolute path");
 
     return 1;
   }
+
   deps.out(`Current version: ${deps.currentVersion}`);
 
   if (dryRun) {
@@ -155,6 +160,7 @@ export async function runUpdate(deps: UpdateDeps, dryRun: boolean): Promise<numb
 
     return 0;
   }
+
   deps.out("Checking for updates to latest version...");
   const latest = await deps.fetchLatestVersion();
 
@@ -163,6 +169,7 @@ export async function runUpdate(deps: UpdateDeps, dryRun: boolean): Promise<numb
 
     return 0;
   }
+
   deps.out(`updating cueloop in ${targetInstallDir}...`);
   const exitCode = await deps.runInstaller(targetInstallDir);