@cueloop/daemon 0.1.0-alpha.79 → 0.1.0-alpha.80

package/src/retention.ts

@@ -71,12 +71,13 @@ export function pruneExpiredSessions(
   store: ThreadStore,
   periodDays: number,
   nowMs: number,
+  protectedThreadIds: ReadonlySet<string> = new Set(),
 ): string[] {
   if (periodDays <= 0) return [];
   const pruned: string[] = [];
 
   for (const session of store.list()) {
-    if (session.status !== "resolved") continue;
+    if (session.status !== "resolved" || protectedThreadIds.has(session.id)) continue;
     if (isExpired(session.createdAt, periodDays, nowMs) && store.delete(session.id)) {
       pruned.push(session.id);
     }

package/src/server.test.ts

@@ -46,12 +46,58 @@ describe("socket round-trip", () => {
     });
     const wait = client.sessionWait(session.id, 5_000);
 
-    await client.sessionResolve(session.id, "request_changes", "Expand it.");
+    await client.sessionSendMessage(session.id, "changes_requested", "Expand it.");
     const resolved = (await wait)!;
 
     // Assert
-    expect(resolved.verdict!.kind).toBe("request_changes");
-    expect(resolved.verdict!.feedback).toContain("More detail please.");
+    expect(resolved.message!.outcome).toBe("changes_requested");
+    expect(resolved.message!.body).toContain("More detail please.");
+  });
+
+  test("harness binding and Message delivery round-trip over the wire", async () => {
+    const thread = await client.sessionCreate(WS, PLAN);
+    const binding = await client.harnessBind(thread.id, "fake", "fake_1");
+
+    expect(await client.harnessGetBinding(binding.id)).toEqual(binding);
+
+    const sent = await client.sessionSendMessage(thread.id, "approved", "Ready.");
+    const pending = await client.deliveryPending(binding.id);
+
+    expect(pending).toHaveLength(1);
+    expect(pending[0]!.message).toEqual(sent.message!);
+    expect(pending[0]!.delivery.status).toBe("pending");
+
+    const acknowledged = await client.deliveryAcknowledge(pending[0]!.delivery.id);
+
+    expect(acknowledged.status).toBe("acknowledged");
+    expect(await client.deliveryPending(binding.id)).toEqual([]);
+    expect(
+      await client.harnessConsumeApprovedRetry(binding.id, sent.message!.id, PLAN.content),
+    ).toBe(true);
+    expect(
+      await client.harnessConsumeApprovedRetry(binding.id, sent.message!.id, PLAN.content),
+    ).toBe(false);
+  });
+
+  test("diff revision replaces full changed-file contents over the wire", async () => {
+    const files = [
+      { path: "a.ts", status: "modified" as const, oldContents: "old", newContents: "first" },
+    ];
+    const thread = await client.sessionCreate(WS, {
+      type: "diff",
+      content: "first patch",
+      files,
+      meta: {},
+    });
+    const revised = await client.sessionSubmitRevision(
+      thread.id,
+      "second patch",
+      [],
+      [{ ...files[0]!, newContents: "second" }],
+    );
+
+    expect(revised.artifact.files?.[0]?.newContents).toBe("second");
+    expect((await client.sessionGet(thread.id)).artifact.files?.[0]?.newContents).toBe("second");
   });
 
   test("errors carry codes across the wire", async () => {
@@ -70,13 +116,13 @@ describe("socket round-trip", () => {
     // Act
     const session = await client.sessionCreate(WS, PLAN);
 
-    await client.sessionResolve(session.id, "approve", "");
+    await client.sessionSendMessage(session.id, "approved", "");
 
     // Assert
     // events are pushed async over the socket; give the loop a beat
     await Bun.sleep(50);
     expect(seen).toContain("session.created");
-    expect(seen).toContain("session.resolved");
+    expect(seen).toContain("message.sent");
     observer.close();
   });
 
@@ -344,7 +390,7 @@ describe("ownership is proven, never declared", () => {
       ).error,
     ).toBeUndefined();
     expect(
-      (await raw.call("session.resolve", { id: session.id, verdictKind: "approve", summary: "" }))
+      (await raw.call("session.sendMessage", { id: session.id, outcome: "approved", summary: "" }))
         .error?.code,
     ).toBe("forbidden");
     expect((await raw.call("session.delete", { id: session.id })).error?.code).toBe("forbidden");
@@ -422,7 +468,7 @@ describe("ownership is proven, never declared", () => {
     // Assert: the client in beforeEach connected as the owner through the token
     const session = await client.sessionCreate(WS, PLAN);
 
-    expect((await client.sessionResolve(session.id, "approve", "")).status).toBe("resolved");
+    expect((await client.sessionSendMessage(session.id, "approved", "")).status).toBe("resolved");
     expect(statSync(join(home, "owner.token")).mode & 0o777).toBe(0o600);
   });
 });

package/src/server.ts

@@ -449,16 +449,45 @@ export class DaemonServer {
         removals: params.removals,
       });
     },
-    "session.resolve": (_connection, request) => {
-      const params = parseParams("session.resolve", request.params);
+    "session.sendMessage": (_connection, request) => {
+      const params = parseParams("session.sendMessage", request.params);
 
-      return this.core.sessionResolve(
+      return this.core.sessionSendMessage(
         params.id,
-        params.verdictKind,
+        params.outcome,
         params.summary,
         params.actionBodies,
       );
     },
+    "harness.bind": (_connection, request) => {
+      const params = parseParams("harness.bind", request.params);
+
+      return this.core.harnessBind(params);
+    },
+    "harness.getBinding": (_connection, request) => {
+      const params = parseParams("harness.getBinding", request.params);
+
+      return this.core.harnessGetBinding(params.bindingId);
+    },
+    "harness.consumeApprovedRetry": (_connection, request) => {
+      const params = parseParams("harness.consumeApprovedRetry", request.params);
+
+      return this.core.harnessConsumeApprovedRetry(
+        params.bindingId,
+        params.messageId,
+        params.content,
+      );
+    },
+    "delivery.pending": (_connection, request) => {
+      const params = parseParams("delivery.pending", request.params);
+
+      return this.core.deliveryPending(params.bindingId);
+    },
+    "delivery.acknowledge": (_connection, request) => {
+      const params = parseParams("delivery.acknowledge", request.params);
+
+      return this.core.deliveryAcknowledge(params.deliveryId);
+    },
     "session.submitRevision": (_connection, request) => {
       const params = parseParams("session.submitRevision", request.params);
 
@@ -466,6 +495,7 @@ export class DaemonServer {
         params.id,
         params.content,
         params.addressedAnnotationIds,
+        params.files,
       );
     },
     "herdr.getTab": (_connection, request) =>

package/src/single-instance.test.ts

@@ -81,6 +81,18 @@ describe("one daemon per home", () => {
     expect(daemonServer.start()).toBe(socketPath(home));
   });
 
+  test("an autostarted daemon reclaims a stale socket after taking the lock", async () => {
+    writeFileSync(socketPath(home), "stale socket");
+    const client = await DaemonClient.connect({ home, autostart: true });
+
+    try {
+      expect((await client.ping()).pid).toBeGreaterThan(0);
+    } finally {
+      await client.shutdown();
+      client.close();
+    }
+  });
+
   test("stopping releases the lock so a restart works", () => {
     // Arrange
     const first = server();
@@ -125,4 +137,26 @@ describe("one daemon per home", () => {
       admin.close();
     }
   }, 60_000);
+
+  test("autostart joins a daemon that bound its socket after the first dial", async () => {
+    const running = server();
+    const path = running.start();
+    const created = running.core.sessionCreate({ workspace: WS, artifact: PLAN });
+    const client = new DaemonClient();
+    const previousTimeout = process.env.CUELOOP_START_TIMEOUT_MS;
+
+    client["home"] = home;
+    process.env.CUELOOP_START_TIMEOUT_MS = "250";
+
+    try {
+      await client["attachFreshDaemon"](home, path!);
+
+      expect((await client.sessionGet(created.id)).id).toBe(created.id);
+      expect(existsSync(path!)).toBe(true);
+    } finally {
+      client.close();
+      if (previousTimeout === undefined) delete process.env.CUELOOP_START_TIMEOUT_MS;
+      else process.env.CUELOOP_START_TIMEOUT_MS = previousTimeout;
+    }
+  });
 });

package/src/testing/store-conformance.ts

@@ -30,7 +30,7 @@ export function createTestThreadRecord(
     artifact: { type: "plan", content: `# ${id}`, meta: {} },
     revisions: [{ revision: 1, content: `# ${id}`, submittedAt: createdAt }],
     annotations: [],
-    verdict: null,
+    message: null,
     status: "pending",
     createdAt,
     ...overrides,

package/src/{review.test.ts → thread-review.test.ts}

@@ -1,4 +1,4 @@
-/** The shared review core against a real DaemonServer in a temp home: workspace resolution, title derivation, open-or-revise by agentSessionId, and both awaitVerdict shapes (one long-poll and the chunked loop with progress and abort). */
+/** The shared review core against a real DaemonServer in a temp home: workspace resolution, title derivation, open-or-revise by agentSessionId, and both awaitMessage shapes (one long-poll and the chunked loop with progress and abort). */
 
 import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 import { mkdtempSync, rmSync } from "node:fs";
@@ -7,7 +7,7 @@ import { join } from "node:path";
 import type { Thread } from "@cueloop/schema";
 import { DaemonServer } from "./server";
 import { DaemonClient } from "./client";
-import { awaitResolve, openReview, resolveWorkspace } from "./review";
+import { awaitResolve, openReview, resolveWorkspace } from "./thread-review";
 
 const PLAN = "# Rollout Plan\n\nShip it in two stages.\n";
 
@@ -205,49 +205,49 @@ describe("openReview", () => {
   });
 });
 
-describe("awaitVerdict: one long-poll (the hook shape)", () => {
-  test("times out to pending; a later wait collects the stored verdict", async () => {
+describe("awaitMessage: one long-poll (the hook shape)", () => {
+  test("times out to pending; a later wait collects the stored message", async () => {
     // Arrange
     const review = await openReview(client, { type: "plan", content: PLAN, cwd: home });
 
     // Assert
-    expect(await review.awaitVerdict({ timeoutMs: 50 })).toBe("pending");
+    expect(await review.awaitMessage({ timeoutMs: 50 })).toBe("pending");
 
     // Act
-    await client.sessionResolve(review.id, "approve", "Fine.");
-    const verdict = await review.awaitVerdict({ timeoutMs: 1_000 });
+    await client.sessionSendMessage(review.id, "approved", "Fine.");
+    const message = await review.awaitMessage({ timeoutMs: 1_000 });
 
     // Assert
-    expect(verdict).not.toBe("pending");
-    if (verdict === "pending") throw new Error("unreachable");
-    expect(verdict.allow).toBe(true);
-    expect(verdict.feedback).toContain("Fine.");
-    expect(verdict.session.verdict!.kind).toBe("approve");
+    expect(message).not.toBe("pending");
+    if (message === "pending") throw new Error("unreachable");
+    expect(message.allow).toBe(true);
+    expect(message.message.body).toContain("Fine.");
+    expect(message.session.message!.outcome).toBe("approved");
   });
 
-  test("request_changes maps to allow=false with feedback.md attached", async () => {
+  test("changes_requested maps to allow=false with feedback.md attached", async () => {
     // Arrange
     const review = await openReview(client, { type: "plan", content: PLAN, cwd: home });
-    const waiting = review.awaitVerdict({ timeoutMs: 5_000 });
+    const waiting = review.awaitMessage({ timeoutMs: 5_000 });
 
     // Act
-    await client.sessionResolve(review.id, "request_changes", "One stage only.");
-    const verdict = await waiting;
+    await client.sessionSendMessage(review.id, "changes_requested", "One stage only.");
+    const message = await waiting;
 
     // Assert
-    if (verdict === "pending") throw new Error("expected a verdict");
-    expect(verdict.allow).toBe(false);
-    expect(verdict.feedback).toContain("# Review: request changes");
-    expect(verdict.feedback).toContain("One stage only.");
+    if (message === "pending") throw new Error("expected a message");
+    expect(message.allow).toBe(false);
+    expect(message.message.body).toContain("# Review: changes requested");
+    expect(message.message.body).toContain("One stage only.");
   });
 });
 
-describe("awaitVerdict: chunked loop (the pi shape)", () => {
-  test("onProgress sees fresh sessions between chunks; the verdict ends the loop", async () => {
+describe("awaitMessage: chunked loop (the pi shape)", () => {
+  test("onProgress sees fresh sessions between chunks; the message ends the loop", async () => {
     // Arrange
     const review = await openReview(client, { type: "plan", content: PLAN, cwd: home });
     const seen: Thread[] = [];
-    const waiting = review.awaitVerdict({
+    const waiting = review.awaitMessage({
       timeoutMs: Infinity,
       pollMs: 100,
       onProgress: (progress) => seen.push(progress),
@@ -268,20 +268,20 @@ describe("awaitVerdict: chunked loop (the pi shape)", () => {
     expect(seen.some((snapshot) => snapshot.annotations.length === 1)).toBe(true);
 
     // Act
-    await client.sessionResolve(review.id, "request_changes", "Too vague.");
-    const verdict = await waiting;
+    await client.sessionSendMessage(review.id, "changes_requested", "Too vague.");
+    const message = await waiting;
 
     // Assert
-    if (verdict === "pending") throw new Error("expected a verdict");
-    expect(verdict.allow).toBe(false);
-    expect(verdict.session.annotations.length).toBe(1);
+    if (message === "pending") throw new Error("expected a message");
+    expect(message.allow).toBe(false);
+    expect(message.session.annotations.length).toBe(1);
   }, 15_000);
 
   test("abort surfaces as pending and leaves the session collectable", async () => {
     // Arrange
     const review = await openReview(client, { type: "plan", content: PLAN, cwd: home });
     const controller = new AbortController();
-    const waiting = review.awaitVerdict({
+    const waiting = review.awaitMessage({
       timeoutMs: Infinity,
       pollMs: 100,
       signal: controller.signal,
@@ -300,40 +300,40 @@ describe("awaitVerdict: chunked loop (the pi shape)", () => {
     const review = await openReview(client, { type: "plan", content: PLAN, cwd: home });
 
     // Assert
-    expect(await review.awaitVerdict({ timeoutMs: 120, pollMs: 50 })).toBe("pending");
+    expect(await review.awaitMessage({ 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 () => {
+  test("resolves to the outcome when the message 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;
+    await client.sessionSendMessage(review.id, "approved", "Ship it.");
+    const message = 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");
+    expect(message).not.toBeNull();
+    expect(message!.allow).toBe(true);
+    expect(message!.message.body).toContain("Ship it.");
+    expect(message!.session.message!.outcome).toBe("approved");
   });
 
-  test("returns the stored verdict immediately when the session already resolved", async () => {
+  test("returns the stored message 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.");
+    await client.sessionSendMessage(review.id, "changes_requested", "One stage only.");
 
     // Act
-    const verdict = await awaitResolve(client, review.id);
+    const message = await awaitResolve(client, review.id);
 
     // Assert
-    expect(verdict).not.toBeNull();
-    expect(verdict!.allow).toBe(false);
-    expect(verdict!.feedback).toContain("One stage only.");
+    expect(message).not.toBeNull();
+    expect(message!.allow).toBe(false);
+    expect(message!.message.body).toContain("One stage only.");
   });
 
   test("returns null when the signal aborts first", async () => {
@@ -352,7 +352,7 @@ describe("awaitResolve: the adapter wake seam (session id only)", () => {
 });
 
 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 () => {
+  test("a pending session does not idle-exit while a waiter is parked, then the message lands", async () => {
     // Arrange - a daemon with an aggressive idle timer and its own home
     const idleHome = mkdtempSync(join(tmpdir(), "cueloop-idle-"));
     let idleExits = 0;
@@ -376,15 +376,15 @@ describe("awaitResolve: the held wait keeps the daemon alive", () => {
       expect(idleExits).toBe(0);
       expect((await waiterClient.ping()).pid).toBe(process.pid);
 
-      // Act - the human returns a verdict; the parked wait collects it
+      // Act - the human returns a message; the parked wait collects it
       const resolver = await DaemonClient.connect({ home: idleHome });
 
-      await resolver.sessionResolve(review.id, "approve", "Good to go.");
+      await resolver.sessionSendMessage(review.id, "approved", "Good to go.");
       resolver.close();
-      const verdict = await waiting;
+      const message = await waiting;
 
       // Assert
-      expect(verdict!.allow).toBe(true);
+      expect(message!.allow).toBe(true);
     } finally {
       waiterClient.close();
       idleServer.stop();