@cueloop/daemon 0.1.0-alpha.6 → 0.1.0-alpha.61

package/package.json

@@ -1,34 +1,42 @@
 {
   "name": "@cueloop/daemon",
-  "version": "0.1.0-alpha.6",
+  "version": "0.1.0-alpha.61",
+  "description": "The cueloop session daemon and its client: socket protocol, atomic store, resumable waits",
+  "homepage": "https://github.com/mmurakaru/cueloop#readme",
+  "bugs": {
+    "url": "https://github.com/mmurakaru/cueloop/issues"
+  },
   "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/mmurakaru/cueloop.git",
+    "directory": "packages/daemon"
+  },
+  "files": [
+    "src",
+    "README.md"
+  ],
   "type": "module",
   "exports": {
     ".": "./src/index.ts",
-    "./client": "./src/client.ts"
-  },
-  "dependencies": {
-    "@cueloop/schema": "0.1.0-alpha.6",
-    "valibot": "^1.4.2"
+    "./client": "./src/client.ts",
+    "./review": "./src/review.ts",
+    "./working-tree": "./src/working-tree.ts",
+    "./store": "./src/store.ts",
+    "./paths": "./src/paths.ts",
+    "./retention": "./src/retention.ts",
+    "./herdr-pane": "./src/herdr-pane.ts",
+    "./herdr-split": "./src/herdr-split.ts",
+    "./share-blob": "./src/share-blob.ts"
   },
   "publishConfig": {
     "access": "public"
   },
-  "files": [
-    "src",
-    "README.md"
-  ],
+  "dependencies": {
+    "@cueloop/schema": "0.1.0-alpha.61",
+    "valibot": "^1.4.2"
+  },
   "engines": {
     "bun": ">=1.3.0"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/mmurakaru/cueloop.git",
-    "directory": "packages/daemon"
-  },
-  "homepage": "https://github.com/mmurakaru/cueloop#readme",
-  "bugs": {
-    "url": "https://github.com/mmurakaru/cueloop/issues"
-  },
-  "description": "The cueloop session daemon and its client: socket protocol, atomic store, resumable waits"
-}
+  }
+}

package/src/api.test.ts

@@ -24,71 +24,174 @@ afterEach(() => rmSync(home, { recursive: true, force: true }));
 
 describe("session lifecycle", () => {
   test("create → get → list", () => {
-    const s = core.sessionCreate({ workspace: WS, artifact: PLAN });
-    expect(s.status).toBe("pending");
-    expect(s.revisions.length).toBe(1);
-    expect(core.sessionGet(s.id).id).toBe(s.id);
+    // Act
+    const session = core.sessionCreate({ workspace: WS, artifact: PLAN });
+
+    // Assert
+    expect(session.status).toBe("pending");
+    expect(session.revisions.length).toBe(1);
+    expect(core.sessionGet(session.id).id).toBe(session.id);
     expect(core.sessionList({ status: "pending" }).length).toBe(1);
   });
 
   test("annotate upserts by id; remove deletes", () => {
-    const s = core.sessionCreate({ workspace: WS, artifact: PLAN });
-    core.sessionAnnotate(s.id, {
+    // Arrange
+    const session = core.sessionCreate({ workspace: WS, artifact: PLAN });
+
+    // Act
+    core.sessionAnnotate(session.id, {
       id: "a1",
       kind: "comment",
       anchor: { quote: "carefully", prefix: "the thing ", suffix: "." },
       body: "How carefully?",
     });
-    core.sessionAnnotate(s.id, {
+    core.sessionAnnotate(session.id, {
       id: "a1",
       kind: "comment",
       anchor: { quote: "carefully", prefix: "the thing ", suffix: "." },
       body: "Define carefully.",
     });
-    expect(core.sessionGet(s.id).annotations.length).toBe(1);
-    expect(core.sessionGet(s.id).annotations[0]!.body).toBe("Define carefully.");
-    core.sessionRemoveAnnotation(s.id, "a1");
-    expect(core.sessionGet(s.id).annotations.length).toBe(0);
+
+    // Assert
+    expect(core.sessionGet(session.id).annotations.length).toBe(1);
+    expect(core.sessionGet(session.id).annotations[0]!.body).toBe("Define carefully.");
+
+    // Act
+    core.sessionRemoveAnnotation(session.id, "a1");
+
+    // Assert
+    expect(core.sessionGet(session.id).annotations.length).toBe(0);
+  });
+
+  test("annotate with an author registers them in the participant registry", () => {
+    // Arrange
+    const session = core.sessionCreate({ workspace: WS, artifact: PLAN });
+
+    // Act
+    core.sessionAnnotate(
+      session.id,
+      {
+        id: "a1",
+        kind: "comment",
+        anchor: { quote: "carefully", prefix: "the thing ", suffix: "." },
+        body: "A collaborator's note.",
+        author: "SHA256:ana",
+      },
+      "Ana",
+    );
+
+    // Assert
+    const stored = core.sessionGet(session.id);
+
+    expect(stored.annotations[0]!.author).toBe("SHA256:ana");
+    expect(stored.participants).toEqual([{ id: "SHA256:ana", provider: "ssh", name: "Ana" }]);
   });
 
   test("resolve produces feedback.md and maps to the agent contract", () => {
-    const s = core.sessionCreate({ workspace: WS, artifact: PLAN });
-    core.sessionAnnotate(s.id, {
+    // Arrange
+    const session = core.sessionCreate({ workspace: WS, artifact: PLAN });
+
+    core.sessionAnnotate(session.id, {
       id: "a1",
       kind: "comment",
       anchor: { quote: "carefully", prefix: "the thing ", suffix: "." },
       body: "Spell out the steps.",
     });
-    const resolved = core.sessionResolve(s.id, "request_changes", "Needs detail.");
+
+    // Act
+    const resolved = core.sessionResolve(session.id, "request_changes", "Needs detail.");
+
+    // Assert
     expect(resolved.verdict!.feedback).toContain("# Review: request changes");
     expect(resolved.verdict!.feedback).toContain("> carefully");
-    expect(verdictResponse(resolved)).toEqual({ allow: false, feedback: resolved.verdict!.feedback });
+    expect(verdictResponse(resolved)).toEqual({
+      allow: false,
+      feedback: resolved.verdict!.feedback,
+    });
+
+    // Arrange
     const approved = core.sessionCreate({ workspace: WS, artifact: PLAN });
+
+    // Act
     core.sessionResolve(approved.id, "approve", "LGTM");
+
+    // Assert
     expect(verdictResponse(core.sessionGet(approved.id)).allow).toBe(true);
   });
 
   test("mutating a resolved session throws", () => {
-    const s = core.sessionCreate({ workspace: WS, artifact: PLAN });
-    core.sessionResolve(s.id, "approve", "");
+    // Arrange
+    const session = core.sessionCreate({ workspace: WS, artifact: PLAN });
+
+    core.sessionResolve(session.id, "approve", "");
+
+    // Assert
     expect(() =>
-      core.sessionAnnotate(s.id, { id: "a1", kind: "comment", anchor: { quote: "x", prefix: "", suffix: "" }, body: "b" }),
+      core.sessionAnnotate(session.id, {
+        id: "a1",
+        kind: "comment",
+        anchor: { quote: "x", prefix: "", suffix: "" },
+        body: "b",
+      }),
     ).toThrow("already resolved");
   });
 
   test("working copy stores edits and clears on revert or no-op", () => {
-    const s = core.sessionCreate({ workspace: WS, artifact: PLAN });
-    core.sessionSetWorkingCopy(s.id, PLAN.content.replace("carefully", "very carefully"));
-    expect(core.sessionGet(s.id).workingCopy).toContain("very carefully");
-    core.sessionSetWorkingCopy(s.id, PLAN.content);
-    expect(core.sessionGet(s.id).workingCopy).toBeUndefined();
+    // Arrange
+    const session = core.sessionCreate({ workspace: WS, artifact: PLAN });
+
+    // Act
+    core.sessionSetWorkingCopy(session.id, PLAN.content.replace("carefully", "very carefully"));
+
+    // Assert
+    expect(core.sessionGet(session.id).workingCopy).toContain("very carefully");
+
+    // Act
+    core.sessionSetWorkingCopy(session.id, PLAN.content);
+
+    // Assert
+    expect(core.sessionGet(session.id).workingCopy).toBeUndefined();
+  });
+
+  test("viewed paths merge, dedupe, clear on empty, and survive a daemon restart", () => {
+    // Arrange
+    const session = core.sessionCreate({ workspace: WS, artifact: PLAN });
+
+    // Act
+    core.sessionSetViewed(session.id, ["src/a.ts", "src/b.ts", "src/a.ts"]);
+
+    // Assert
+    expect(core.sessionGet(session.id).viewedPaths).toEqual(["src/a.ts", "src/b.ts"]);
+
+    // Act
+    // merge-additive: a stale client sending only its own new mark loses nothing
+    core.sessionSetViewed(session.id, ["src/c.ts"]);
+
+    // Assert
+    expect(core.sessionGet(session.id).viewedPaths).toEqual(["src/a.ts", "src/b.ts", "src/c.ts"]);
+    // a resumed review reads its progress back after a daemon restart
+    const reborn = new DaemonCore(home);
+
+    expect(reborn.sessionGet(session.id).viewedPaths).toEqual(["src/a.ts", "src/b.ts", "src/c.ts"]);
+
+    // Act
+    core.sessionSetViewed(session.id, []);
+
+    // Assert
+    expect(core.sessionGet(session.id).viewedPaths).toBeUndefined();
   });
 
   test("revision reopens the session and resets working copy + verdict", () => {
-    const s = core.sessionCreate({ workspace: WS, artifact: PLAN });
-    core.sessionSetWorkingCopy(s.id, PLAN.content + "\nedit");
-    core.sessionResolve(s.id, "request_changes", "redo");
-    const revised = core.sessionSubmitRevision(s.id, "# Plan v2\n");
+    // Arrange
+    const session = core.sessionCreate({ workspace: WS, artifact: PLAN });
+
+    core.sessionSetWorkingCopy(session.id, PLAN.content + "\nedit");
+    core.sessionResolve(session.id, "request_changes", "redo");
+
+    // Act
+    const revised = core.sessionSubmitRevision(session.id, "# Plan v2\n");
+
+    // Assert
     expect(revised.status).toBe("pending");
     expect(revised.verdict).toBeNull();
     expect(revised.workingCopy).toBeUndefined();
@@ -97,47 +200,172 @@ describe("session lifecycle", () => {
   });
 });
 
+describe("revision marks addressed annotations", () => {
+  const annotate = (sessionId: string, id: string, quote: string, body = "note") =>
+    core.sessionAnnotate(sessionId, {
+      id,
+      kind: "comment",
+      anchor: { quote, prefix: "", suffix: "" },
+      body,
+    });
+
+  test("ids the agent reports are marked addressed by that revision", () => {
+    // Arrange
+    const session = core.sessionCreate({ workspace: WS, artifact: PLAN });
+
+    annotate(session.id, "a1", "carefully");
+    annotate(session.id, "a2", "Context");
+
+    // Act: the revision keeps both quoted texts, so only the reported id resolves
+    const revised = core.sessionSubmitRevision(session.id, PLAN.content + "\nMore.\n", ["a1"]);
+
+    // Assert
+    const [first, second] = revised.annotations;
+
+    expect(first!.resolution).toEqual({ revision: 2, source: "agent" });
+    expect(second!.resolution).toBeUndefined();
+  });
+
+  test("a plan annotation whose quoted text vanished is drift-addressed; a surviving quote stays open", () => {
+    // Arrange
+    const session = core.sessionCreate({ workspace: WS, artifact: PLAN });
+
+    annotate(session.id, "gone", "carefully");
+    annotate(session.id, "kept", "Context");
+
+    // Act: the revision rewrites the "carefully" sentence but keeps the Context heading
+    const revised = core.sessionSubmitRevision(
+      session.id,
+      "# Plan\n\n## Context\n\nDo the thing with tests.\n",
+    );
+
+    // Assert
+    expect(revised.annotations.find((a) => a.id === "gone")!.resolution).toEqual({
+      revision: 2,
+      source: "drift",
+    });
+    expect(revised.annotations.find((a) => a.id === "kept")!.resolution).toBeUndefined();
+  });
+
+  test("an unknown reported id is ignored, and an already-addressed annotation keeps its first resolution", () => {
+    // Arrange
+    const session = core.sessionCreate({ workspace: WS, artifact: PLAN });
+
+    annotate(session.id, "a1", "carefully");
+    core.sessionSubmitRevision(session.id, PLAN.content, ["a1"]);
+
+    // Act: a second revision reports a stale id and re-reports the settled one
+    const revised = core.sessionSubmitRevision(session.id, PLAN.content, ["a1", "a_never_existed"]);
+
+    // Assert
+    expect(revised.annotations[0]!.resolution).toEqual({ revision: 2, source: "agent" });
+    expect(revised.revisions.length).toBe(3);
+  });
+
+  test("a diff revision never drift-addresses - a new patch says nothing about the feedback", () => {
+    // Arrange
+    const diffArtifact: Artifact = { type: "diff", content: "+++ b/a.ts\n+new line\n", meta: {} };
+    const session = core.sessionCreate({ workspace: WS, artifact: diffArtifact });
+
+    annotate(session.id, "d1", "new line");
+
+    // Act: the revised patch no longer contains the quoted text
+    const revised = core.sessionSubmitRevision(session.id, "+++ b/b.ts\n+other\n");
+
+    // Assert
+    expect(revised.annotations[0]!.resolution).toBeUndefined();
+  });
+
+  test("the next feedback document omits addressed annotations and teaches the addressed-ids call", () => {
+    // Arrange
+    const session = core.sessionCreate({ workspace: WS, artifact: PLAN });
+
+    annotate(session.id, "settled", "carefully");
+    annotate(session.id, "open", "Context", "needs a diagram");
+    core.sessionSubmitRevision(session.id, PLAN.content, ["settled"]);
+
+    // Act
+    const resolved = core.sessionResolve(session.id, "request_changes", "one left");
+
+    // Assert
+    expect(resolved.verdict!.feedback).not.toContain("settled");
+    expect(resolved.verdict!.feedback).toContain("annotation id: `open`");
+    expect(resolved.verdict!.feedback).toContain(`submit-revision ${session.id}`);
+    expect(resolved.verdict!.feedback).toContain("--addressed");
+  });
+});
+
 describe("the wait contract: verdicts outlive waits", () => {
   test("wait resolves when the verdict arrives", async () => {
-    const s = core.sessionCreate({ workspace: WS, artifact: PLAN });
-    const wait = core.sessionWait(s.id, 5_000);
-    core.sessionResolve(s.id, "approve", "");
+    // Arrange
+    const session = core.sessionCreate({ workspace: WS, artifact: PLAN });
+    const wait = core.sessionWait(session.id, 5_000);
+
+    // Act
+    core.sessionResolve(session.id, "approve", "");
     const resolved = await wait;
+
+    // Assert
     expect(resolved!.verdict!.kind).toBe("approve");
   });
 
   test("wait times out to null; a later wait collects the stored verdict", async () => {
-    const s = core.sessionCreate({ workspace: WS, artifact: PLAN });
-    const first = await core.sessionWait(s.id, 30);
+    // Arrange
+    const session = core.sessionCreate({ workspace: WS, artifact: PLAN });
+
+    // Act
+    const first = await core.sessionWait(session.id, 30);
+
+    // Assert
     expect(first).toBeNull();
-    core.sessionResolve(s.id, "request_changes", "later");
-    const second = await core.sessionWait(s.id, 30);
+
+    // Act
+    core.sessionResolve(session.id, "request_changes", "later");
+    const second = await core.sessionWait(session.id, 30);
+
+    // Assert
     expect(second!.verdict!.summary).toBe("later");
   });
 
   test("multiple waiters all resolve", async () => {
-    const s = core.sessionCreate({ workspace: WS, artifact: PLAN });
-    const waits = [core.sessionWait(s.id, 5_000), core.sessionWait(s.id, 5_000)];
-    core.sessionResolve(s.id, "approve", "");
+    // Arrange
+    const session = core.sessionCreate({ workspace: WS, artifact: PLAN });
+    const waits = [core.sessionWait(session.id, 5_000), core.sessionWait(session.id, 5_000)];
+
+    // Act
+    core.sessionResolve(session.id, "approve", "");
     const results = await Promise.all(waits);
-    expect(results.every((r) => r?.status === "resolved")).toBe(true);
+
+    // Assert
+    expect(results.every((result) => result?.status === "resolved")).toBe(true);
   });
 });
 
 describe("persistence and recovery", () => {
   test("sessions survive a daemon restart", () => {
-    const s = core.sessionCreate({ workspace: WS, artifact: PLAN });
-    core.sessionResolve(s.id, "approve", "done");
+    // Arrange
+    const session = core.sessionCreate({ workspace: WS, artifact: PLAN });
+
+    core.sessionResolve(session.id, "approve", "done");
+
+    // Act
     const reborn = new DaemonCore(home);
-    const recovered = reborn.sessionGet(s.id);
+    const recovered = reborn.sessionGet(session.id);
+
+    // Assert
     expect(recovered.verdict!.summary).toBe("done");
   });
 
   test("corrupt records are skipped, not fatal, and never deleted", async () => {
+    // Arrange
     core.sessionCreate({ workspace: WS, artifact: PLAN });
     await Bun.write(join(home, "sessions", "broken.json"), "{ not json");
     const store = new SessionStore(home);
+
+    // Act
     const report = store.recover();
+
+    // Assert
     expect(report.recovered.length).toBe(1);
     expect(report.skipped.length).toBe(1);
     expect(await Bun.file(join(home, "sessions", "broken.json")).exists()).toBe(true);
@@ -146,11 +374,29 @@ describe("persistence and recovery", () => {
 
 describe("events", () => {
   test("lifecycle events fire in order", () => {
+    // Arrange
     const seen: string[] = [];
-    core.onEvent((e) => seen.push(e.event));
-    const s = core.sessionCreate({ workspace: WS, artifact: PLAN });
-    core.sessionAnnotate(s.id, { id: "a1", kind: "comment", anchor: { quote: "thing", prefix: "", suffix: "" }, body: "b" });
-    core.sessionResolve(s.id, "approve", "");
-    expect(seen).toEqual(["session.created", "inbox.changed", "session.updated", "session.resolved", "inbox.changed"]);
+
+    core.onEvent((event) => seen.push(event.event));
+
+    // Act
+    const session = core.sessionCreate({ workspace: WS, artifact: PLAN });
+
+    core.sessionAnnotate(session.id, {
+      id: "a1",
+      kind: "comment",
+      anchor: { quote: "thing", prefix: "", suffix: "" },
+      body: "b",
+    });
+    core.sessionResolve(session.id, "approve", "");
+
+    // Assert
+    expect(seen).toEqual([
+      "session.created",
+      "inbox.changed",
+      "session.updated",
+      "session.resolved",
+      "inbox.changed",
+    ]);
   });
 });