@cueloop/daemon 0.1.0-alpha.59 → 0.1.0-alpha.60

package/src/herdr-pane.ts

@@ -32,17 +32,20 @@ export interface HerdrTabPersistence {
  */
 export function openHerdrPane(options: OpenHerdrPaneOptions): HerdrTabHandle | null {
   const { sessionId, cwd, binPath, label } = options;
+
   try {
     const created = Bun.spawnSync(
       [binPath, "tab", "create", "--cwd", cwd, "--label", label, "--focus"],
       { stdout: "pipe", stderr: "ignore", timeout: HERDR_SPAWN_TIMEOUT_MS },
     );
+
     if (created.exitCode !== 0) return null;
     const parsed = JSON.parse(created.stdout.toString()) as {
       result?: { root_pane?: { pane_id?: string; tab_id?: string } };
     };
     const paneId = parsed.result?.root_pane?.pane_id;
     const tabId = parsed.result?.root_pane?.tab_id;
+
     if (!paneId || !tabId) return null;
     // A fresh tab hosts a plain shell, so the review is typed in like a human.
     const typed = Bun.spawnSync([binPath, "pane", "send-text", paneId, `cueloop ${sessionId}`], {
@@ -50,12 +53,14 @@ export function openHerdrPane(options: OpenHerdrPaneOptions): HerdrTabHandle | n
       stderr: "ignore",
       timeout: HERDR_SPAWN_TIMEOUT_MS,
     });
+
     if (typed.exitCode !== 0) return null;
     const entered = Bun.spawnSync([binPath, "pane", "send-keys", paneId, "enter"], {
       stdout: "ignore",
       stderr: "ignore",
       timeout: HERDR_SPAWN_TIMEOUT_MS,
     });
+
     return entered.exitCode === 0 ? { tabId, paneId } : null;
   } catch {
     return null;
@@ -70,8 +75,10 @@ function herdrPaneAlive(binPath: string, paneId: string): boolean {
       stderr: "ignore",
       timeout: HERDR_SPAWN_TIMEOUT_MS,
     });
+
     if (got.exitCode !== 0) return false;
     const parsed = JSON.parse(got.stdout.toString()) as { result?: { pane?: unknown } };
+
     return parsed.result?.pane != null;
   } catch {
     return false;
@@ -102,10 +109,13 @@ export async function openHerdrPaneForReview(
   env: HerdrEnv = process.env,
 ): Promise<void> {
   const herdr = detectHerdr(env);
+
   if (!herdr) return;
   const recorded = await recallHerdrTab(persistence, session.id);
+
   if (recorded && herdrPaneAlive(herdr.binPath, recorded.paneId)) {
     focusHerdrTab(herdr.binPath, recorded.tabId);
+
     return;
   }
   const opened = openHerdrPane({
@@ -114,6 +124,7 @@ export async function openHerdrPaneForReview(
     binPath: herdr.binPath,
     label: session.artifact.meta.title ?? session.id,
   });
+
   if (opened) await rememberHerdrTab(persistence, session.id, opened);
 }
 

package/src/herdr-split.test.ts

@@ -15,6 +15,7 @@ function makeStub(name: string, splitOk = true): { binPath: string; logPath: str
   const splitResult = splitOk
     ? `printf '{"result":{"pane":{"pane_id":"w1:p9"}}}'`
     : `printf '{"result":{}}'`;
+
   writeFileSync(
     binPath,
     `#!/bin/sh
@@ -24,11 +25,13 @@ exit 0
 `,
   );
   chmodSync(binPath, 0o755);
+
   return { binPath, logPath };
 }
 
 function readLines(logPath: string): string[] {
   if (!existsSync(logPath)) return [];
+
   return readFileSync(logPath, "utf8").split("\n").filter(Boolean);
 }
 

package/src/herdr-split.ts

@@ -35,6 +35,7 @@ export function launchHarnessInSplit(
   env: HerdrEnv = process.env,
 ): boolean {
   const herdr = detectHerdr(env);
+
   if (!herdr) return false;
   try {
     const split = Bun.spawnSync(
@@ -52,15 +53,18 @@ export function launchHarnessInSplit(
       ],
       { stdout: "pipe", stderr: "ignore", timeout: HERDR_SPAWN_TIMEOUT_MS },
     );
+
     if (split.exitCode !== 0) return false;
     const parsed = JSON.parse(split.stdout.toString()) as {
       result?: { pane?: { pane_id?: string } };
     };
     const paneId = parsed.result?.pane?.pane_id;
+
     if (!paneId) return false;
     sendText(herdr.binPath, paneId, options.command);
     sendKeys(herdr.binPath, paneId, "enter");
     if (options.seedText) sendText(herdr.binPath, paneId, options.seedText);
+
     return true;
   } catch {
     return false;

package/src/herdr-tab-store.test.ts

@@ -43,6 +43,7 @@ describe("HerdrTabStore", () => {
   test("delete removes the handle", () => {
     // Arrange
     const store = new HerdrTabStore(home);
+
     store.set("ses_1", { tabId: "w1:t2", paneId: "w1:p2" });
 
     // Act

package/src/herdr-tab-store.ts

@@ -36,6 +36,7 @@ export class HerdrTabStore {
   private load(): void {
     try {
       const parsed: unknown = JSON.parse(readFileSync(this.path, "utf8"));
+
       if (typeof parsed !== "object" || parsed === null) return;
       for (const [sessionId, value] of Object.entries(parsed)) {
         if (isHerdrTabHandle(value))
@@ -48,6 +49,7 @@ export class HerdrTabStore {
 
   private persist(): void {
     const tempPath = this.path + ".tmp";
+
     writeFileSync(tempPath, JSON.stringify(Object.fromEntries(this.tabs), null, 2));
     renameSync(tempPath, this.path);
   }

package/src/main.ts

@@ -7,6 +7,7 @@ const idleExitMs = process.env.CUELOOP_IDLE_EXIT_MS
   : undefined;
 const server = new DaemonServer({ idleExitMs });
 const path = server.start();
+
 if (path === null) {
   // another daemon already owns this home; the client will attach to it
   console.log("cueloop daemon already running for this home");

package/src/protocol.ts

@@ -31,8 +31,10 @@ export class LineBuffer {
     this.buffered += chunk;
     for (;;) {
       const newlineIndex = this.buffered.indexOf("\n");
+
       if (newlineIndex === -1) return;
       const line = this.buffered.slice(0, newlineIndex).trim();
+
       this.buffered = this.buffered.slice(newlineIndex + 1);
       if (line) onLine(line);
     }
@@ -58,11 +60,14 @@ export class BackpressureWriter {
 
   write(data: string): void {
     const bytes = Buffer.from(data, "utf8");
+
     if (this.pending) {
       this.pending = Buffer.concat([this.pending, bytes]);
+
       return;
     }
     const written = Math.max(0, this.socket.write(bytes));
+
     if (written < bytes.length) this.pending = bytes.subarray(written);
   }
 
@@ -70,8 +75,10 @@ export class BackpressureWriter {
   drain(): void {
     if (!this.pending) return;
     const tail = this.pending;
+
     this.pending = null;
     const written = Math.max(0, this.socket.write(tail));
+
     if (written < tail.length) this.pending = tail.subarray(written);
   }
 }

package/src/retention.test.ts

@@ -57,6 +57,7 @@ describe("resolveCleanupPeriodDays", () => {
   test("honors [cleanup] period_days", () => {
     // Arrange
     const path = join(tempDir("cueloop-retention-"), "config.toml");
+
     writeFileSync(path, "[cleanup]\nperiod_days = 7\n");
 
     // Act
@@ -69,6 +70,7 @@ describe("resolveCleanupPeriodDays", () => {
   test("falls back to the default when the value is not a number", () => {
     // Arrange
     const path = join(tempDir("cueloop-retention-"), "config.toml");
+
     writeFileSync(path, '[cleanup]\nperiod_days = "soon"\n');
 
     // Act
@@ -111,6 +113,7 @@ describe("pruneExpiredSessions", () => {
     // Arrange
     const home = tempDir("cueloop-retention-home-");
     const store = new SessionStore(home);
+
     store.upsert(session("ses_old", daysAgo(40)));
     store.upsert(session("ses_new", daysAgo(2)));
 
@@ -127,6 +130,7 @@ describe("pruneExpiredSessions", () => {
     // Arrange
     const home = tempDir("cueloop-retention-home-");
     const store = new SessionStore(home);
+
     store.upsert(session("ses_active", daysAgo(400), "pending"));
 
     // Act
@@ -141,6 +145,7 @@ describe("pruneExpiredSessions", () => {
     // Arrange
     const home = tempDir("cueloop-retention-home-");
     const store = new SessionStore(home);
+
     store.upsert(session("ses_old", daysAgo(999)));
 
     // Act
@@ -157,12 +162,15 @@ describe("pruneExpiredReports", () => {
     // Arrange
     const home = tempDir("cueloop-retention-home-");
     const directory = reportsDir(home);
+
     mkdirSync(directory, { recursive: true });
     const latest = join(directory, LATEST_REPORT_FILENAME);
     const stale = join(directory, "refine-2026-06-01T00-00-00-000Z.md");
     const fresh = join(directory, "refine-2026-08-25T00-00-00-000Z.md");
+
     for (const path of [latest, stale, fresh]) writeFileSync(path, "report");
     const staleSeconds = (NOW_MS - 60 * DAY_MS) / 1000;
+
     utimesSync(stale, staleSeconds, staleSeconds);
 
     // Act

package/src/retention.ts

@@ -22,28 +22,35 @@ export type RefineState = v.InferOutput<typeof RefineStateSchema>;
 
 export function parseRefineState(raw: unknown): Map<string, string> {
   const parsed = v.safeParse(RefineStateSchema, raw);
+
   if (!parsed.success) return new Map();
+
   return new Map(Object.entries(parsed.output.analyzed));
 }
 
 function userConfigPath(env: NodeJS.ProcessEnv): string {
   const explicit = env.CUELOOP_CONFIG;
+
   if (explicit && explicit.trim()) return explicit;
   const xdgConfigHome = env.XDG_CONFIG_HOME;
   const base = xdgConfigHome && xdgConfigHome.trim() ? xdgConfigHome : join(homedir(), ".config");
+
   return join(base, "cueloop", "config.toml");
 }
 
 function readConfiguredPeriodDays(path: string): number | undefined {
   let raw: unknown;
+
   try {
     raw = Bun.TOML.parse(readFileSync(path, "utf8"));
   } catch {
     return undefined;
   }
   const parsed = v.safeParse(CleanupConfigSchema, raw);
+
   if (!parsed.success) return undefined;
   const value = parsed.output.cleanup?.period_days;
+
   return value !== undefined && Number.isFinite(value) && value >= 0 ? value : undefined;
 }
 
@@ -54,7 +61,9 @@ export function resolveCleanupPeriodDays(env: NodeJS.ProcessEnv = process.env):
 export function isExpired(createdAt: string, periodDays: number, nowMs: number): boolean {
   if (periodDays <= 0) return false;
   const createdMs = Date.parse(createdAt);
+
   if (Number.isNaN(createdMs)) return false;
+
   return nowMs - createdMs > periodDays * MILLISECONDS_PER_DAY;
 }
 
@@ -65,17 +74,20 @@ export function pruneExpiredSessions(
 ): string[] {
   if (periodDays <= 0) return [];
   const pruned: string[] = [];
+
   for (const session of store.list()) {
     if (session.status !== "resolved") continue;
     if (isExpired(session.createdAt, periodDays, nowMs) && store.delete(session.id)) {
       pruned.push(session.id);
     }
   }
+
   return pruned;
 }
 
 export function timestampedReportFilename(nowMs: number): string {
   const stamp = new Date(nowMs).toISOString().replace(/[:.]/g, "-");
+
   return `${TIMESTAMPED_REPORT_PREFIX}${stamp}.md`;
 }
 
@@ -86,6 +98,7 @@ export function pruneExpiredReports(
 ): string[] {
   if (periodDays <= 0) return [];
   let entries: string[];
+
   try {
     entries = readdirSync(reportsDirectory);
   } catch {
@@ -93,14 +106,17 @@ export function pruneExpiredReports(
   }
   const cutoffMs = nowMs - periodDays * MILLISECONDS_PER_DAY;
   const pruned: string[] = [];
+
   for (const entry of entries) {
     if (entry === LATEST_REPORT_FILENAME) continue;
     if (!entry.startsWith(TIMESTAMPED_REPORT_PREFIX)) continue;
     const path = join(reportsDirectory, entry);
+
     if (statSync(path).mtimeMs < cutoffMs) {
       rmSync(path, { force: true });
       pruned.push(entry);
     }
   }
+
   return pruned;
 }

package/src/review.test.ts

@@ -29,12 +29,14 @@ afterEach(() => {
 
 function sh(args: string[], cwd: string): void {
   const gitResult = Bun.spawnSync(args, { cwd, stdout: "ignore", stderr: "ignore" });
+
   if (gitResult.exitCode !== 0) throw new Error(`${args.join(" ")} failed`);
 }
 
 describe("resolveWorkspace", () => {
   test("a git repo resolves to its root and branch", async () => {
     const repo = mkdtempSync(join(tmpdir(), "cueloop-ws-"));
+
     try {
       // Arrange
       sh(["git", "init", "-q", "-b", "main"], repo);
@@ -75,6 +77,7 @@ describe("openReview", () => {
 
     // Assert
     const session = review.session;
+
     expect(session.status).toBe("pending");
     expect(session.artifact.type).toBe("plan");
     expect(session.artifact.meta.agent).toBe("test-agent");
@@ -170,6 +173,7 @@ describe("openReview", () => {
 
     // Assert
     const notes = review.session.annotations;
+
     expect(notes.length).toBe(2);
     expect(notes.every((annotation) => annotation.kind === "note")).toBe(true);
     expect(notes.map((annotation) => annotation.anchor.quote)).toEqual(["src/a.ts", "src/b.ts"]);
@@ -296,6 +300,7 @@ describe("awaitResolve: the adapter wake seam (session id only)", () => {
   test("returns the stored verdict immediately when the session already resolved", async () => {
     // Arrange - a detached waiter that only attaches after the human decided
     const review = await openReview(client, { type: "plan", content: PLAN, cwd: home });
+
     await client.sessionResolve(review.id, "request_changes", "One stage only.");
 
     // Act
@@ -332,8 +337,10 @@ describe("awaitResolve: the held wait keeps the daemon alive", () => {
       idleExitMs: 30,
       onIdleExit: () => idleExits++,
     });
+
     idleServer.start();
     const waiterClient = await DaemonClient.connect({ home: idleHome });
+
     try {
       const review = await openReview(waiterClient, { type: "plan", content: PLAN, cwd: idleHome });
       const waiting = awaitResolve(waiterClient, review.id, { pollMs: 40 });
@@ -347,6 +354,7 @@ describe("awaitResolve: the held wait keeps the daemon alive", () => {
 
       // Act - the human returns a verdict; the parked wait collects it
       const resolver = await DaemonClient.connect({ home: idleHome });
+
       await resolver.sessionResolve(review.id, "approve", "Good to go.");
       resolver.close();
       const verdict = await waiting;

package/src/review.ts

@@ -8,6 +8,7 @@
  */
 
 import {
+  isMarkdownArtifact,
   newAnnotationId,
   type ArtifactType,
   type DiffFileContents,
@@ -25,7 +26,9 @@ async function git(args: string[], cwd: string): Promise<string | null> {
   try {
     const proc = Bun.spawn(["git", ...args], { cwd, stdout: "pipe", stderr: "ignore" });
     const out = await new Response(proc.stdout).text();
+
     if ((await proc.exited) !== 0) return null;
+
     return out.trim();
   } catch {
     return null;
@@ -36,11 +39,13 @@ async function git(args: string[], cwd: string): Promise<string | null> {
 export async function resolveWorkspace(cwd = process.cwd()): Promise<WorkspaceKey> {
   const repoRoot = (await git(["rev-parse", "--show-toplevel"], cwd)) ?? cwd;
   const branch = (await git(["rev-parse", "--abbrev-ref", "HEAD"], cwd)) ?? "detached";
+
   return { repoRoot, branch };
 }
 
 function firstHeading(markdown: string): string | undefined {
   const headingMatch = markdown.match(/^#\s+(.+)$/m);
+
   return headingMatch?.[1]?.trim();
 }
 
@@ -63,7 +68,7 @@ export interface OpenReviewOptions {
    * the artifact so hunk curation produces an exactly applyable patch.
    */
   files?: DiffFileContents[];
-  /** Defaults to the plan's first markdown heading; diffs get no derived title. */
+  /** Defaults to a markdown artifact's first heading (plan, reply); diffs get no derived title. */
   title?: string;
   /**
    * Per-file agent notes for diff sessions: the submitting agent's own
@@ -123,8 +128,10 @@ function raceAbort<T>(
   if (!signal) return promise;
   if (signal.aborted) {
     promise.catch(() => {});
+
     return Promise.resolve(ABORTED);
   }
+
   return new Promise<T | typeof ABORTED>((resolve, reject) => {
     const onAbort = () => {
       // The daemon request keeps running until the client closes; swallow its
@@ -132,6 +139,7 @@ function raceAbort<T>(
       promise.catch(() => {});
       resolve(ABORTED);
     };
+
     signal.addEventListener("abort", onAbort, { once: true });
     promise.then(
       (value) => {
@@ -164,20 +172,26 @@ export class ReviewHandle {
    */
   async awaitVerdict(options: AwaitVerdictOptions): Promise<VerdictOutcome | "pending"> {
     const { timeoutMs, pollMs, onProgress, signal } = options;
+
     if (pollMs === undefined && onProgress === undefined && signal === undefined) {
       const resolved = await this.client.sessionWait(this.session.id, timeoutMs);
+
       return resolved === null ? "pending" : outcome(resolved);
     }
     const chunkMs = pollMs ?? 10_000;
     const deadline = Number.isFinite(timeoutMs) ? Date.now() + timeoutMs : undefined;
+
     for (;;) {
       const budget = deadline === undefined ? chunkMs : Math.min(chunkMs, deadline - Date.now());
+
       if (budget <= 0 || signal?.aborted) return "pending";
       const resolved = await raceAbort(this.client.sessionWait(this.session.id, budget), signal);
+
       if (resolved === ABORTED) return "pending";
       if (resolved !== null) return outcome(resolved);
       // Still pending after this chunk: re-read to surface reviewer progress.
       const current = await raceAbort(this.client.sessionGet(this.session.id), signal);
+
       if (current === ABORTED) return "pending";
       onProgress?.(current);
     }
@@ -213,9 +227,11 @@ export async function awaitResolve(
 ): Promise<VerdictOutcome | null> {
   const chunkMs = options.pollMs ?? 30_000;
   const { signal } = options;
+
   for (;;) {
     if (signal?.aborted) return null;
     const resolved = await raceAbort(client.sessionWait(sessionId, chunkMs), signal);
+
     if (resolved === ABORTED) return null;
     if (resolved !== null) return outcome(resolved);
   }
@@ -228,17 +244,21 @@ export async function openReview(
 ): Promise<ReviewHandle> {
   const cwd = options.cwd ?? process.cwd();
   const workspace = options.workspace ?? (await resolveWorkspace(cwd));
+
   // Resubmits from the same agent session become revisions, not new sessions.
   if (options.agentSessionId !== undefined) {
     const existing = (await client.sessionList()).find(
       (candidate) => candidate.artifact.meta.agentSessionId === options.agentSessionId,
     );
+
     if (existing !== undefined) {
       let revised = await client.sessionSubmitRevision(existing.id, options.content);
+
       if (options.notes?.length) {
         await attachNotes(client, revised.id, options.notes);
         revised = await client.sessionGet(revised.id);
       }
+
       return new ReviewHandle(client, revised);
     }
   }
@@ -253,13 +273,17 @@ export async function openReview(
       prototypePath: options.prototypePath,
       pr: options.pr,
       herdrPane: options.herdrPane,
-      title: options.title ?? (options.type === "plan" ? firstHeading(options.content) : undefined),
+      title:
+        options.title ??
+        (isMarkdownArtifact(options.type) ? firstHeading(options.content) : undefined),
       cwd,
     },
   });
+
   if (options.notes?.length) {
     await attachNotes(client, session.id, options.notes);
     session = await client.sessionGet(session.id);
   }
+
   return new ReviewHandle(client, session);
 }

package/src/server.test.ts

@@ -44,6 +44,7 @@ describe("socket round-trip", () => {
       body: "More detail please.",
     });
     const wait = client.sessionWait(session.id, 5_000);
+
     await client.sessionResolve(session.id, "request_changes", "Expand it.");
     const resolved = (await wait)!;
 
@@ -65,11 +66,13 @@ describe("socket round-trip", () => {
     // Arrange
     const observer = await DaemonClient.connect({ home });
     const seen: string[] = [];
+
     observer.onEvent((event) => seen.push(event.event));
     await observer.subscribe();
 
     // Act
     const session = await client.sessionCreate(WS, PLAN);
+
     await client.sessionResolve(session.id, "approve", "");
 
     // Assert
@@ -107,6 +110,7 @@ describe("socket round-trip", () => {
       client.request("toString", {}),
       client.request("constructor", {}),
     ]);
+
     for (const result of prototypeMethods) {
       expect(result.status).toBe("rejected");
       expect(((result as PromiseRejectedResult).reason as DaemonClientError).code).toBe(
@@ -115,6 +119,7 @@ describe("socket round-trip", () => {
     }
     // the daemon is still fully alive afterwards
     const session = await client.sessionCreate(WS, PLAN);
+
     expect((await client.sessionGet(session.id)).id).toBe(session.id);
   });
 
@@ -136,6 +141,7 @@ describe("socket round-trip", () => {
     // Given a shared session with one local note
     const session = await client.sessionCreate(WS, PLAN);
     const anchor = { quote: "Body text", prefix: "", suffix: "." };
+
     await client.sessionSetShareId(session.id, "p_abc123xy");
     await client.sessionAnnotate(session.id, { id: "a1", kind: "comment", anchor, body: "mine" });
     expect((await client.sessionGet(session.id)).shareId).toBe("p_abc123xy");
@@ -174,6 +180,7 @@ describe("socket round-trip", () => {
   test("mergeShared validates each annotation at the socket boundary", async () => {
     // Given a session
     const session = await client.sessionCreate(WS, PLAN);
+
     try {
       // When a malformed annotation is merged
       // @ts-expect-error intentionally malformed annotation (empty id, missing fields)