@cueloop/daemon 0.1.0-alpha.23 → 0.1.0-alpha.25

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cueloop/daemon",
-  "version": "0.1.0-alpha.23",
+  "version": "0.1.0-alpha.25",
   "license": "Apache-2.0",
   "type": "module",
   "exports": {
@@ -11,7 +11,7 @@
     "./share-blob": "./src/share-blob.ts"
   },
   "dependencies": {
-    "@cueloop/schema": "0.1.0-alpha.23",
+    "@cueloop/schema": "0.1.0-alpha.25",
     "valibot": "^1.4.2"
   },
   "publishConfig": {

package/src/api.ts

@@ -168,6 +168,24 @@ export class DaemonCore {
     return session;
   }
 
+  sessionSetShareId(id: string, shareId: string): ReviewSession {
+    const session = this.mutable(id);
+    session.shareId = shareId;
+    this.store.upsert(session);
+    this.emit("session.updated", id);
+    return session;
+  }
+
+  /** Union incoming annotations in by id; existing ids (the planner's) win. */
+  sessionMergeAnnotations(id: string, incoming: Annotation[]): ReviewSession {
+    const session = this.mutable(id);
+    const known = new Set(session.annotations.map((annotation) => annotation.id));
+    for (const annotation of incoming) if (!known.has(annotation.id)) session.annotations.push(annotation);
+    this.store.upsert(session);
+    this.emit("session.updated", id);
+    return session;
+  }
+
   sessionResolve(id: string, verdictKind: VerdictKind, summary: string): ReviewSession {
     const session = this.mutable(id);
     const verdict: Verdict = {

package/src/client.ts

@@ -34,6 +34,8 @@ export interface SessionClient {
   sessionRemoveAnnotation(id: string, annotationId: string): Promise<ReviewSession>;
   sessionSetWorkingCopy(id: string, workingCopy: string | undefined): Promise<ReviewSession>;
   sessionSetViewed(id: string, viewedPaths: string[]): Promise<ReviewSession>;
+  sessionSetShareId(id: string, shareId: string): Promise<ReviewSession>;
+  sessionMergeAnnotations(id: string, annotations: Annotation[]): Promise<ReviewSession>;
   sessionResolve(id: string, verdictKind: VerdictKind, summary: string): Promise<ReviewSession>;
   close(): void;
 }
@@ -183,6 +185,12 @@ export class DaemonClient implements SessionClient {
   sessionSetViewed(id: string, viewedPaths: string[]): Promise<ReviewSession> {
     return this.request("session.setViewed", { id, viewedPaths });
   }
+  sessionSetShareId(id: string, shareId: string): Promise<ReviewSession> {
+    return this.request("session.setShareId", { id, shareId });
+  }
+  sessionMergeAnnotations(id: string, annotations: Annotation[]): Promise<ReviewSession> {
+    return this.request("session.mergeAnnotations", { id, annotations });
+  }
   sessionResolve(id: string, verdictKind: VerdictKind, summary: string): Promise<ReviewSession> {
     return this.request("session.resolve", { id, verdictKind, summary });
   }

package/src/server.test.ts

@@ -121,6 +121,41 @@ describe("socket round-trip", () => {
     expect(got.artifact.meta.agent).toBe("claude-code");
   });
 
+  test("share-sync verbs round-trip: setShareId persists, mergeAnnotations unions by id", async () => {
+    // Arrange
+    const session = await client.sessionCreate(WS, PLAN);
+    const anchor = { quote: "Body text", prefix: "", suffix: "." };
+
+    // Act - stamp the share id, then a local note
+    await client.sessionSetShareId(session.id, "p_abc123xy");
+    await client.sessionAnnotate(session.id, { id: "a1", kind: "comment", anchor, body: "mine" });
+
+    // Assert - the share id came back over the wire
+    expect((await client.sessionGet(session.id)).shareId).toBe("p_abc123xy");
+
+    // Act - merge an update to the known id plus a new collaborator note
+    const merged = await client.sessionMergeAnnotations(session.id, [
+      { id: "a1", kind: "comment", anchor, body: "should not overwrite", createdAt: "2026-01-01T00:00:00.000Z" },
+      { id: "a2", kind: "comment", anchor, body: "theirs", author: "SHA256:mate", createdAt: "2026-01-01T00:00:00.000Z" },
+    ]);
+
+    // Assert - union by id: existing a1 kept as-is, a2 added with its author
+    expect(merged.annotations.map((annotation) => annotation.id).sort()).toEqual(["a1", "a2"]);
+    expect(merged.annotations.find((annotation) => annotation.id === "a1")!.body).toBe("mine");
+    expect(merged.annotations.find((annotation) => annotation.id === "a2")!.author).toBe("SHA256:mate");
+  });
+
+  test("mergeAnnotations validates each annotation at the socket boundary", async () => {
+    const session = await client.sessionCreate(WS, PLAN);
+    try {
+      // @ts-expect-error intentionally malformed annotation (empty id, missing fields)
+      await client.sessionMergeAnnotations(session.id, [{ id: "" }]);
+      throw new Error("should have thrown");
+    } catch (error) {
+      expect((error as DaemonClientError).code).toBe("invalid_params");
+    }
+  });
+
   test("two clients see the same state (thin-renderer model)", async () => {
     // Arrange
     const second = await DaemonClient.connect({ home });

package/src/server.ts

@@ -245,6 +245,14 @@ export class DaemonServer {
         const params = parseParams("session.setViewed", request.params);
         return core.sessionSetViewed(params.id, params.viewedPaths);
       }
+      case "session.setShareId": {
+        const params = parseParams("session.setShareId", request.params);
+        return core.sessionSetShareId(params.id, params.shareId);
+      }
+      case "session.mergeAnnotations": {
+        const params = parseParams("session.mergeAnnotations", request.params);
+        return core.sessionMergeAnnotations(params.id, params.annotations);
+      }
       case "session.resolve": {
         const params = parseParams("session.resolve", request.params);
         return core.sessionResolve(params.id, params.verdictKind, params.summary);

package/src/validate.test.ts

@@ -191,6 +191,8 @@ describe("wire pins", () => {
     verdict: fullVerdict,
     status: "pending",
     createdAt: "now",
+    shareId: "p_abc123xy",
+    owner: "SHA256:owner",
   };
 
   test("schema key sets match the schema types", () => {

package/src/validate.ts

@@ -83,6 +83,9 @@ export const AnnotationSchema = v.object({
 
 const SessionId = NonEmpty;
 
+/** A stored annotation: the wire shape plus the daemon-stamped createdAt. */
+export const FullAnnotationSchema = v.object({ ...AnnotationSchema.entries, createdAt: v.string() } satisfies EntriesOf<Annotation>);
+
 export const Params = {
   "session.create": v.object({ workspace: WorkspaceSchema, artifact: ArtifactSchema }),
   "session.get": v.object({ id: SessionId }),
@@ -103,6 +106,8 @@ export const Params = {
   "session.removeAnnotation": v.object({ id: SessionId, annotationId: NonEmpty }),
   "session.setWorkingCopy": v.object({ id: SessionId, workingCopy: v.optional(v.string()) }),
   "session.setViewed": v.object({ id: SessionId, viewedPaths: v.array(v.string()) }),
+  "session.setShareId": v.object({ id: SessionId, shareId: NonEmpty }),
+  "session.mergeAnnotations": v.object({ id: SessionId, annotations: v.array(FullAnnotationSchema) }),
   "session.resolve": v.object({
     id: SessionId,
     verdictKind: v.picklist(["comment", "approve", "request_changes"]),
@@ -156,12 +161,14 @@ export const SessionRecordSchema = v.object({
   workspace: WorkspaceSchema,
   artifact: ArtifactSchema,
   revisions: v.array(RevisionSchema),
-  annotations: v.array(v.object({ ...AnnotationSchema.entries, createdAt: v.string() } satisfies EntriesOf<Annotation>)),
+  annotations: v.array(FullAnnotationSchema),
   workingCopy: v.optional(v.string()),
   viewedPaths: v.optional(v.array(v.string())),
   verdict: v.nullable(VerdictSchema),
   status: v.picklist(["pending", "resolved"]),
   createdAt: v.string(),
+  shareId: v.optional(v.string()),
+  owner: v.optional(v.string()),
 } satisfies EntriesOf<ReviewSession>);
 
 export function validateSessionRecord(raw: unknown): { ok: true; value: v.InferOutput<typeof SessionRecordSchema> } | { ok: false; error: string } {