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

package/package.json

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

package/src/api.ts

@@ -15,6 +15,7 @@ import {
   verdictAllows,
   type Annotation,
   type Artifact,
+  type Identity,
   type ReviewSession,
   type Verdict,
   type VerdictKind,
@@ -176,11 +177,28 @@ export class DaemonCore {
     return session;
   }
 
-  /** Union incoming annotations in by id; existing ids (the planner's) win. */
-  sessionMergeAnnotations(id: string, incoming: Annotation[]): ReviewSession {
+  /** Remove a session for good (inbox delete); resolved or pending, both go. */
+  sessionDelete(id: string): void {
+    if (!this.store.delete(id)) throw new DaemonError("not_found", `no session ${id}`);
+    this.emit("inbox.changed", id);
+  }
+
+  /**
+   * Merge a share's collaborator state back into the local session: annotations
+   * union by id with existing ones (the planner's) winning, and the participant
+   * registry union by id with the incoming identity winning (a collaborator is
+   * the authority on their own name). This is how a teammate's name reaches the
+   * planner after a pull, alongside their notes.
+   */
+  sessionMergeShared(id: string, incoming: { annotations: Annotation[]; participants?: Identity[] }): 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);
+    for (const annotation of incoming.annotations) if (!known.has(annotation.id)) session.annotations.push(annotation);
+    if (incoming.participants?.length) {
+      const registry = new Map((session.participants ?? []).map((participant) => [participant.id, participant]));
+      for (const participant of incoming.participants) registry.set(participant.id, participant);
+      session.participants = [...registry.values()];
+    }
     this.store.upsert(session);
     this.emit("session.updated", id);
     return session;

package/src/client.ts

@@ -5,7 +5,7 @@
  */
 
 import { existsSync, rmSync } from "node:fs";
-import type { Annotation, Artifact, ReviewSession, VerdictKind, WorkspaceKey } from "@cueloop/schema";
+import type { Annotation, Artifact, Identity, ReviewSession, VerdictKind, WorkspaceKey } from "@cueloop/schema";
 import { BackpressureWriter, LineBuffer, type EventFrame, type Response } from "./protocol";
 import { cueloopHome, socketPath } from "./paths";
 
@@ -35,7 +35,10 @@ export interface SessionClient {
   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>;
+  sessionMergeShared(id: string, incoming: { annotations: Annotation[]; participants?: Identity[] }): Promise<ReviewSession>;
+  sessionDelete(id: string): Promise<void>;
+  /** Record the caller's own identity name (collaborator self-naming on a share). */
+  sessionSetSelfName(id: string, name: string): Promise<ReviewSession>;
   sessionResolve(id: string, verdictKind: VerdictKind, summary: string): Promise<ReviewSession>;
   close(): void;
 }
@@ -188,8 +191,15 @@ export class DaemonClient implements SessionClient {
   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 });
+  sessionMergeShared(id: string, incoming: { annotations: Annotation[]; participants?: Identity[] }): Promise<ReviewSession> {
+    return this.request("session.mergeShared", { id, ...incoming });
+  }
+  sessionDelete(id: string): Promise<void> {
+    return this.request("session.delete", { id });
+  }
+  /** Local sessions have no collaborator self-name; the share client owns this. */
+  sessionSetSelfName(id: string, _name: string): Promise<ReviewSession> {
+    return this.sessionGet(id);
   }
   sessionResolve(id: string, verdictKind: VerdictKind, summary: string): Promise<ReviewSession> {
     return this.request("session.resolve", { id, verdictKind, summary });

package/src/server.test.ts

@@ -121,41 +121,61 @@ 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
+  test("share-sync verbs round-trip: setShareId persists, mergeShared unions notes and identities by id", async () => {
+    // Given a shared session with one local note
     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" },
-    ]);
+    // When a pull merges an update to the known id, a new collaborator note, and the collaborator's identity
+    const merged = await client.sessionMergeShared(session.id, {
+      annotations: [
+        { 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" },
+      ],
+      participants: [{ id: "SHA256:mate", provider: "ssh", name: "Sam" }],
+    });
 
-    // Assert - union by id: existing a1 kept as-is, a2 added with its author
+    // Then notes union by id (existing a1 kept), and the participant registry carries the collaborator's name
     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");
+    expect(merged.participants).toEqual([{ id: "SHA256:mate", provider: "ssh", name: "Sam" }]);
   });
 
-  test("mergeAnnotations validates each annotation at the socket boundary", async () => {
+  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)
-      await client.sessionMergeAnnotations(session.id, [{ id: "" }]);
+      await client.sessionMergeShared(session.id, { annotations: [{ id: "" }] });
       throw new Error("should have thrown");
     } catch (error) {
+      // Then it is rejected at the wire boundary
       expect((error as DaemonClientError).code).toBe("invalid_params");
     }
   });
 
+  test("session.delete removes a session over the wire", async () => {
+    // Given a created session
+    const session = await client.sessionCreate(WS, PLAN);
+
+    // When it is deleted
+    await client.sessionDelete(session.id);
+
+    // Then it is gone, and deleting an unknown id is a not_found error
+    expect(client.sessionGet(session.id)).rejects.toBeInstanceOf(DaemonClientError);
+    try {
+      await client.sessionDelete("ses_missing");
+      throw new Error("should have thrown");
+    } catch (error) {
+      expect((error as DaemonClientError).code).toBe("not_found");
+    }
+  });
+
   test("two clients see the same state (thin-renderer model)", async () => {
     // Arrange
     const second = await DaemonClient.connect({ home });

package/src/server.ts

@@ -249,9 +249,13 @@ export class DaemonServer {
         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.delete": {
+        core.sessionDelete(parseParams("session.delete", request.params).id);
+        return {};
+      }
+      case "session.mergeShared": {
+        const params = parseParams("session.mergeShared", request.params);
+        return core.sessionMergeShared(params.id, { annotations: params.annotations, participants: params.participants });
       }
       case "session.resolve": {
         const params = parseParams("session.resolve", request.params);

package/src/validate.test.ts

@@ -9,6 +9,7 @@ import {
   AnnotationSchema,
   ArtifactMetaSchema,
   ArtifactSchema,
+  IdentitySchema,
   RevisionSchema,
   SessionRecordSchema,
   VerdictSchema,
@@ -23,6 +24,7 @@ import {
   type Annotation,
   type Artifact,
   type ArtifactMeta,
+  type Identity,
   type ReviewSession,
   type Revision,
   type Verdict,
@@ -179,6 +181,7 @@ describe("wire pins", () => {
   const fullVerdict: Required<Verdict> = { kind: "approve", summary: "", feedback: "", resolvedAt: "now" };
   const fullRevision: Required<Revision> = { revision: 1, content: "# P", submittedAt: "now" };
   const fullWorkspace: Required<WorkspaceKey> = { repoRoot: "/repo", branch: "main" };
+  const fullIdentity: Required<Identity> = { id: "SHA256:abc", provider: "ssh", name: "Al", handle: "abc" };
   const fullSession: Required<ReviewSession> = {
     schemaVersion: SCHEMA_VERSION,
     id: "ses_1",
@@ -193,6 +196,7 @@ describe("wire pins", () => {
     createdAt: "now",
     shareId: "p_abc123xy",
     owner: "SHA256:owner",
+    participants: [fullIdentity],
   };
 
   test("schema key sets match the schema types", () => {
@@ -205,6 +209,7 @@ describe("wire pins", () => {
     expect(entryKeys(AnnotationSchema)).toEqual(keys(wireAnnotation));
     expect(entryKeys(RevisionSchema)).toEqual(keys(fullRevision));
     expect(entryKeys(VerdictSchema)).toEqual(keys(fullVerdict));
+    expect(entryKeys(IdentitySchema)).toEqual(keys(fullIdentity));
     expect(entryKeys(SessionRecordSchema)).toEqual(keys(fullSession));
     // persisted annotations carry the stamped createdAt
     const stored = SessionRecordSchema.entries.annotations.item;

package/src/validate.ts

@@ -16,6 +16,7 @@ import {
   type Annotation,
   type Artifact,
   type ArtifactMeta,
+  type Identity,
   type ReviewSession,
   type Revision,
   type Verdict,
@@ -86,6 +87,13 @@ 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 IdentitySchema = v.object({
+  id: NonEmpty,
+  provider: v.literal("ssh"),
+  name: v.optional(v.string()),
+  handle: v.optional(v.string()),
+} satisfies EntriesOf<Identity>);
+
 export const Params = {
   "session.create": v.object({ workspace: WorkspaceSchema, artifact: ArtifactSchema }),
   "session.get": v.object({ id: SessionId }),
@@ -107,7 +115,12 @@ export const Params = {
   "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.delete": v.object({ id: SessionId }),
+  "session.mergeShared": v.object({
+    id: SessionId,
+    annotations: v.array(FullAnnotationSchema),
+    participants: v.optional(v.array(IdentitySchema)),
+  }),
   "session.resolve": v.object({
     id: SessionId,
     verdictKind: v.picklist(["comment", "approve", "request_changes"]),
@@ -169,6 +182,7 @@ export const SessionRecordSchema = v.object({
   createdAt: v.string(),
   shareId: v.optional(v.string()),
   owner: v.optional(v.string()),
+  participants: v.optional(v.array(IdentitySchema)),
 } satisfies EntriesOf<ReviewSession>);
 
 export function validateSessionRecord(raw: unknown): { ok: true; value: v.InferOutput<typeof SessionRecordSchema> } | { ok: false; error: string } {