@cueloop/daemon 0.1.0-alpha.34 → 0.1.0-alpha.36

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cueloop/daemon",
-  "version": "0.1.0-alpha.34",
+  "version": "0.1.0-alpha.36",
   "description": "The cueloop session daemon and its client: socket protocol, atomic store, resumable waits",
   "homepage": "https://github.com/mmurakaru/cueloop#readme",
   "bugs": {
@@ -28,7 +28,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@cueloop/schema": "0.1.0-alpha.34",
+    "@cueloop/schema": "0.1.0-alpha.36",
     "valibot": "^1.4.2"
   },
   "engines": {

package/src/review.test.ts

@@ -7,7 +7,7 @@ import { join } from "node:path";
 import type { ReviewSession } from "@cueloop/schema";
 import { DaemonServer } from "./server";
 import { DaemonClient } from "./client";
-import { openReview, resolveWorkspace } from "./review";
+import { awaitResolve, openReview, resolveWorkspace } from "./review";
 
 const PLAN = "# Rollout Plan\n\nShip it in two stages.\n";
 
@@ -275,3 +275,88 @@ describe("awaitVerdict: chunked loop (the pi shape)", () => {
     expect(await review.awaitVerdict({ timeoutMs: 120, pollMs: 50 })).toBe("pending");
   });
 });
+
+describe("awaitResolve: the adapter wake seam (session id only)", () => {
+  test("resolves to the outcome when the verdict lands during the wait", async () => {
+    // Arrange
+    const review = await openReview(client, { type: "plan", content: PLAN, cwd: home });
+    const waiting = awaitResolve(client, review.id, { pollMs: 100 });
+
+    // Act
+    await client.sessionResolve(review.id, "approve", "Ship it.");
+    const verdict = await waiting;
+
+    // Assert
+    expect(verdict).not.toBeNull();
+    expect(verdict!.allow).toBe(true);
+    expect(verdict!.feedback).toContain("Ship it.");
+    expect(verdict!.session.verdict!.kind).toBe("approve");
+  });
+
+  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
+    const verdict = await awaitResolve(client, review.id);
+
+    // Assert
+    expect(verdict).not.toBeNull();
+    expect(verdict!.allow).toBe(false);
+    expect(verdict!.feedback).toContain("One stage only.");
+  });
+
+  test("returns null when the signal aborts first", async () => {
+    // Arrange
+    const review = await openReview(client, { type: "plan", content: PLAN, cwd: home });
+    const controller = new AbortController();
+    const waiting = awaitResolve(client, review.id, { pollMs: 100, signal: controller.signal });
+
+    // Act
+    controller.abort();
+
+    // Assert
+    expect(await waiting).toBeNull();
+    expect((await client.sessionGet(review.id)).status).toBe("pending");
+  });
+});
+
+describe("awaitResolve: the held wait keeps the daemon alive", () => {
+  test("a pending session does not idle-exit while a waiter is parked, then the verdict lands", async () => {
+    // Arrange - a daemon with an aggressive idle timer and its own home
+    const idleHome = mkdtempSync(join(tmpdir(), "cueloop-idle-"));
+    let idleExits = 0;
+    const idleServer = new DaemonServer({
+      home: idleHome,
+      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 });
+
+      // Act - wait well past the idle window while the review is still pending
+      await Bun.sleep(120);
+
+      // Assert - the parked waiter and the pending session both keep it alive
+      expect(idleExits).toBe(0);
+      expect((await waiterClient.ping()).pid).toBe(process.pid);
+
+      // 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;
+
+      // Assert
+      expect(verdict!.allow).toBe(true);
+    } finally {
+      waiterClient.close();
+      idleServer.stop();
+      rmSync(idleHome, { recursive: true, force: true });
+    }
+  }, 15_000);
+});

package/src/review.ts

@@ -187,6 +187,39 @@ function outcome(session: ReviewSession): VerdictOutcome {
   return { ...verdictResponse(session), session };
 }
 
+export interface AwaitResolveOptions {
+  /** Long-poll chunk length; the wait re-arms each chunk until resolved or aborted. Default 30s. */
+  pollMs?: number;
+  /** Abort the wait (the harness session shut down); resolves to null. */
+  signal?: AbortSignal;
+}
+
+/**
+ * Park until a review session resolves, then return the verdict outcome; null
+ * when the signal aborts first. Where ReviewHandle.awaitVerdict needs the handle
+ * that opened the review, this needs only a session id - so a background waiter
+ * that woke on a session it did not open (a detached Claude Code / Codex waiter,
+ * or pi's session_start listener) can collect the same verdict. This is the
+ * wake seam every non-blocking adapter builds on. Loops the daemon long-poll, so
+ * a verdict that lands between chunks is never missed and a session already
+ * resolved returns on the first chunk. The held connection also keeps the daemon
+ * off its idle-exit path for the whole wait.
+ */
+export async function awaitResolve(
+  client: DaemonClient,
+  sessionId: string,
+  options: AwaitResolveOptions = {},
+): 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);
+  }
+}
+
 /** Open a review session (or revise the agent session's existing one) and hand back the wait surface. */
 export async function openReview(
   client: DaemonClient,