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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cueloop/daemon",
-  "version": "0.1.0-alpha.79",
+  "version": "0.1.0-alpha.80",
   "description": "The cueloop session daemon and its client: socket protocol, atomic store, resumable waits",
   "homepage": "https://github.com/mmurakaru/cueloop#readme",
   "bugs": {
@@ -20,7 +20,8 @@
   "exports": {
     ".": "./src/index.ts",
     "./client": "./src/client.ts",
-    "./review": "./src/review.ts",
+    "./thread-review": "./src/thread-review.ts",
+    "./api": "./src/api.ts",
     "./working-tree": "./src/working-tree.ts",
     "./store": "./src/store.ts",
     "./validate": "./src/validate.ts",
@@ -35,7 +36,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@cueloop/schema": "0.1.0-alpha.79",
+    "@cueloop/schema": "0.1.0-alpha.80",
     "@pierre/diffs": "^1.4.1",
     "effect": "^4.0.0-rc.115",
     "valibot": "^1.4.2"

package/src/api.test.ts

@@ -2,7 +2,7 @@ import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import { DaemonCore, verdictResponse } from "./api";
+import { DaemonCore, messageResponse } from "./api";
 import { ThreadStore } from "./store";
 import { derivePath, tipOf, type Artifact, type WorkspaceKey } from "@cueloop/schema";
 import { MAX_BLOB_BYTES, packSessionBlob, unpackSessionBlob } from "./share-blob";
@@ -117,31 +117,31 @@ describe("session lifecycle", () => {
     });
 
     // Act
-    const resolved = core.sessionResolve(session.id, "request_changes", "Needs detail.");
+    const resolved = core.sessionSendMessage(session.id, "changes_requested", "Needs detail.");
 
     // Assert
-    expect(resolved.verdict!.feedback).toContain("# Review: request changes");
-    expect(resolved.verdict!.feedback).toContain("> carefully");
-    expect(verdictResponse(resolved)).toEqual({
+    expect(resolved.message!.body).toContain("# Review: changes requested");
+    expect(resolved.message!.body).toContain("> carefully");
+    expect(messageResponse(resolved)).toEqual({
       allow: false,
-      feedback: resolved.verdict!.feedback,
+      message: resolved.message!,
     });
 
     // Arrange
     const approved = core.sessionCreate({ workspace: WS, artifact: PLAN });
 
     // Act
-    core.sessionResolve(approved.id, "approve", "LGTM");
+    core.sessionSendMessage(approved.id, "approved", "LGTM");
 
     // Assert
-    expect(verdictResponse(core.sessionGet(approved.id)).allow).toBe(true);
+    expect(messageResponse(core.sessionGet(approved.id)).allow).toBe(true);
   });
 
   test("mutating a resolved session throws", () => {
     // Arrange
     const session = core.sessionCreate({ workspace: WS, artifact: PLAN });
 
-    core.sessionResolve(session.id, "approve", "");
+    core.sessionSendMessage(session.id, "approved", "");
 
     // Assert
     expect(() =>
@@ -217,19 +217,19 @@ describe("session lifecycle", () => {
     expect(core.sessionGet(session.id).viewedPaths).toBeUndefined();
   });
 
-  test("revision reopens the session and resets working copy + verdict", () => {
+  test("revision reopens the session and resets working copy + message", () => {
     // Arrange
     const session = core.sessionCreate({ workspace: WS, artifact: PLAN });
 
     core.sessionSetWorkingCopy(session.id, PLAN.content + "\nedit");
-    core.sessionResolve(session.id, "request_changes", "redo");
+    core.sessionSendMessage(session.id, "changes_requested", "redo");
 
     // Act
     const revised = core.sessionSubmitRevision(session.id, "# Plan v2\n");
 
     // Assert
     expect(revised.status).toBe("pending");
-    expect(revised.verdict).toBeNull();
+    expect(revised.message).toBeNull();
     expect(revised.workingCopy).toBeUndefined();
     expect(revised.revisions.length).toBe(2);
     expect(revised.artifact.content).toBe("# Plan v2\n");
@@ -345,31 +345,31 @@ describe("revision marks addressed annotations", () => {
     core.sessionSubmitRevision(session.id, PLAN.content, ["settled"]);
 
     // Act
-    const resolved = core.sessionResolve(session.id, "request_changes", "one left");
+    const resolved = core.sessionSendMessage(session.id, "changes_requested", "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");
+    expect(resolved.message!.body).not.toContain("settled");
+    expect(resolved.message!.body).toContain("annotation id: `open`");
+    expect(resolved.message!.body).toContain(`submit-revision ${session.id}`);
+    expect(resolved.message!.body).toContain("--addressed");
   });
 });
 
-describe("the wait contract: verdicts outlive waits", () => {
-  test("wait resolves when the verdict arrives", async () => {
+describe("the wait contract: messages outlive waits", () => {
+  test("wait resolves when the message arrives", async () => {
     // Arrange
     const session = core.sessionCreate({ workspace: WS, artifact: PLAN });
     const wait = core.sessionWait(session.id, 5_000);
 
     // Act
-    core.sessionResolve(session.id, "approve", "");
+    core.sessionSendMessage(session.id, "approved", "");
     const resolved = await wait;
 
     // Assert
-    expect(resolved!.verdict!.kind).toBe("approve");
+    expect(resolved!.message!.outcome).toBe("approved");
   });
 
-  test("wait times out to null; a later wait collects the stored verdict", async () => {
+  test("wait times out to null; a later wait collects the stored message", async () => {
     // Arrange
     const session = core.sessionCreate({ workspace: WS, artifact: PLAN });
 
@@ -380,11 +380,11 @@ describe("the wait contract: verdicts outlive waits", () => {
     expect(first).toBeNull();
 
     // Act
-    core.sessionResolve(session.id, "request_changes", "later");
+    core.sessionSendMessage(session.id, "changes_requested", "later");
     const second = await core.sessionWait(session.id, 30);
 
     // Assert
-    expect(second!.verdict!.summary).toBe("later");
+    expect(second!.message!.summary).toBe("later");
   });
 
   test("multiple waiters all resolve", async () => {
@@ -393,7 +393,7 @@ describe("the wait contract: verdicts outlive waits", () => {
     const waits = [core.sessionWait(session.id, 5_000), core.sessionWait(session.id, 5_000)];
 
     // Act
-    core.sessionResolve(session.id, "approve", "");
+    core.sessionSendMessage(session.id, "approved", "");
     const results = await Promise.all(waits);
 
     // Assert
@@ -406,14 +406,14 @@ describe("persistence and recovery", () => {
     // Arrange
     const session = core.sessionCreate({ workspace: WS, artifact: PLAN });
 
-    core.sessionResolve(session.id, "approve", "done");
+    core.sessionSendMessage(session.id, "approved", "done");
 
     // Act
     const reborn = new DaemonCore(home);
     const recovered = reborn.sessionGet(session.id);
 
     // Assert
-    expect(recovered.verdict!.summary).toBe("done");
+    expect(recovered.message!.summary).toBe("done");
   });
 
   test("corrupt records are skipped, not fatal, and never deleted", async () => {
@@ -448,14 +448,14 @@ describe("events", () => {
       anchor: { quote: "thing", prefix: "", suffix: "" },
       body: "b",
     });
-    core.sessionResolve(session.id, "approve", "");
+    core.sessionSendMessage(session.id, "approved", "");
 
     // Assert
     expect(seen).toEqual([
       "session.created",
       "inbox.changed",
       "session.updated",
-      "session.resolved",
+      "message.sent",
       "inbox.changed",
     ]);
   });
@@ -484,7 +484,7 @@ describe("the session history records every write as an entry", () => {
     annotate(created.id, "a2", "Context");
     core.sessionRemoveAnnotation(created.id, "a2");
     core.sessionRemoveAnnotation(created.id, "never-existed");
-    core.sessionResolve(created.id, "request_changes", "tighten");
+    core.sessionSendMessage(created.id, "changes_requested", "tighten");
     const revised = core.sessionSubmitRevision(created.id, PLAN.content + "\nMore.\n", ["a1"]);
 
     // Assert: an edit of an existing comment and a removal of an unknown id leave no entry
@@ -495,7 +495,7 @@ describe("the session history records every write as an entry", () => {
       "comment",
       "comment",
       "comment-removed",
-      "verdict",
+      "message",
       "revision",
     ]);
     expect(history.branch).toBe("main");
@@ -653,6 +653,25 @@ describe("curation primitives", () => {
     // Assert
     expect(() => core.sessionCurate(created.id, [])).toThrow(/only a diff review/);
   });
+
+  test("rejects hunk curation after a patch-only diff revision clears file snapshots", () => {
+    const created = core.sessionCreate({
+      workspace: WS,
+      artifact: {
+        type: "diff",
+        content: "diff --git a/a.ts b/a.ts\n",
+        meta: {},
+        files: [{ path: "a.ts", status: "modified", oldContents: "old", newContents: "new" }],
+      },
+    });
+
+    core.sessionSubmitRevision(created.id, "diff --git a/b.ts b/b.ts\n", [], []);
+
+    expect(() => core.sessionCurate(created.id, [{ path: "b.ts", hunkIndex: 0 }])).toThrow(
+      /hunk curation needs full file contents/,
+    );
+    expect(core.sessionGet(created.id).workingCopy).toBeUndefined();
+  });
 });
 
 describe("tree primitives", () => {
@@ -709,11 +728,11 @@ describe("tree primitives", () => {
     core.sessionNavigate(created.id, between);
 
     // Act
-    const resolved = core.sessionResolve(created.id, "request_changes", "one note");
+    const resolved = core.sessionSendMessage(created.id, "changes_requested", "one note");
 
     // Assert
-    expect(resolved.verdict!.feedback).toContain("keep this one");
-    expect(resolved.verdict!.feedback).not.toContain("not this one");
+    expect(resolved.message!.body).toContain("keep this one");
+    expect(resolved.message!.body).not.toContain("not this one");
   });
 
   test("a navigate names the branch to stand on, so a move on another branch is one request", () => {
@@ -846,13 +865,13 @@ describe("tree primitives", () => {
     ).toEqual(["c1"]);
   });
 
-  test("a fork is a new pending session on the copied path, without verdict, edits, or share", () => {
+  test("a fork is a new pending session on the copied path, without message, edits, or share", () => {
     // Arrange: comment, edit, resolve, then a second round
     const created = core.sessionCreate({ workspace: WS, artifact: PLAN });
 
     core.sessionAnnotate(created.id, comment("a1", "first"), "Ana");
     core.sessionSetShareId(created.id, "share-1");
-    core.sessionResolve(created.id, "request_changes", "again");
+    core.sessionSendMessage(created.id, "changes_requested", "again");
     core.sessionSubmitRevision(created.id, "# Plan\n\nRound two.\n", ["a1"]);
     core.sessionLabel(created.id, "round two");
     core.sessionSetWorkingCopy(created.id, "# Plan\n\nRound two, edited.\n");
@@ -864,7 +883,7 @@ describe("tree primitives", () => {
     expect(fork.id).not.toBe(created.id);
     expect(fork.parentSessionId).toBe(created.id);
     expect(fork.status).toBe("pending");
-    expect(fork.verdict).toBeNull();
+    expect(fork.message).toBeNull();
     expect(fork.shareId).toBeUndefined();
     expect(fork.workingCopy).toBeUndefined();
     expect(fork.artifact.content).toBe("# Plan\n\nRound two.\n");
@@ -956,7 +975,7 @@ describe("workbench session", () => {
     try {
       const first = await core.workbenchSession(repo);
 
-      core.sessionResolve(first.id, "comment", "");
+      core.sessionSendMessage(first.id, "changes_requested", "");
       const second = await core.workbenchSession(repo);
 
       expect(second.id).not.toBe(first.id);

package/src/api.ts

@@ -1,8 +1,8 @@
 /**
  * The daemon's method surface. Transport-independent: the socket
  * server and the in-process test harness both call these handlers.
- * The wait contract: verdicts outlive waits - session.wait long-polls,
- * and a verdict resolved while nobody waited is delivered on next contact.
+ * The wait contract: messages outlive waits - session.wait long-polls,
+ * and a message resolved while nobody waited is delivered on next contact.
  */
 
 import {
@@ -27,33 +27,39 @@ import {
   parseBlocks,
   registerParticipant,
   resolveAnchor,
+  newMessageId,
   isBlockCut,
   restoreBlock,
   switchBranch,
-  verdictAllows,
+  messageAllows,
   type Annotation,
   type DiffFileStatus,
+  type DiffFileContents,
   type HunkRejection,
   type NewEntry,
   type Artifact,
   type ShareLink,
   type Identity,
+  type HarnessBinding,
+  type Delivery,
+  type PendingDelivery,
   type Thread,
   type SessionHistory,
-  type Verdict,
-  type VerdictKind,
+  type Message,
+  type MessageOutcome,
   type WorkspaceKey,
 } from "@cueloop/schema";
 import { curateDiff } from "./curate";
 import { ThreadStore, withHistory } from "./store";
 import { pruneExpiredSessions, resolveCleanupPeriodDays } from "./retention";
 import { HerdrTabStore, type HerdrTabHandle } from "./herdr-tab-store";
+import { HarnessStateStore } from "./harness-state-store";
 import { DiffWatcher } from "./diff-watcher";
 import { PrReviewPoller } from "./pr-poller";
 import { prDiff } from "./gh";
 import { workingTreeDiff, workingChangeList, type WorkingTreeDiff } from "./working-tree";
 import { listProjectFiles, readProjectFile } from "./project-files";
-import { resolveWorkspace } from "./review";
+import { resolveWorkspace } from "./thread-review";
 import { DaemonError } from "./errors";
 
 /** What a share hands back: the notes and names it collected, and the removals it recorded. */
@@ -67,7 +73,7 @@ export interface SharedMerge {
 export type EventName =
   | "session.created"
   | "session.updated"
-  | "session.resolved"
+  | "message.sent"
   | "session.revised"
   | "inbox.changed";
 
@@ -83,6 +89,7 @@ type EventListener = (event: DaemonEvent) => void;
 export class DaemonCore {
   readonly store: ThreadStore;
   readonly herdrTabs: HerdrTabStore;
+  readonly harnessState: HarnessStateStore;
   private waiters = new Map<string, ((session: Thread) => void)[]>();
   private listeners = new Set<EventListener>();
   private seq = 0;
@@ -102,12 +109,21 @@ export class DaemonCore {
   constructor(home: string) {
     this.store = new ThreadStore(home);
     this.store.recover();
-    pruneExpiredSessions(this.store, resolveCleanupPeriodDays(), Date.now());
+    this.harnessState = new HarnessStateStore(home);
+    for (const session of this.store.list()) this.reconcileDeliveries(session);
+    pruneExpiredSessions(
+      this.store,
+      resolveCleanupPeriodDays(),
+      Date.now(),
+      this.harnessState.pendingThreadIds(),
+    );
     this.herdrTabs = new HerdrTabStore(home);
     this.diffWatcher = new DiffWatcher((repoRoot) => void this.refreshDiffsForRepo(repoRoot));
     this.prPoller = new PrReviewPoller((sessionId) => void this.sessionRefreshPrDiff(sessionId));
     // resume hot-reload for diff sessions that survived a daemon restart
-    for (const session of this.store.list()) this.trackLiveDiffSession(session);
+    for (const session of this.store.list()) {
+      this.trackLiveDiffSession(session);
+    }
   }
 
   /** Release the watchers and pollers behind diff hot-reload; call on daemon shutdown. */
@@ -125,6 +141,81 @@ export class DaemonCore {
     this.herdrTabs.set(sessionId, handle);
   }
 
+  harnessBind(input: {
+    threadId: string;
+    harness: string;
+    harnessSessionId: string;
+  }): HarnessBinding {
+    this.sessionGet(input.threadId);
+    const binding = this.harnessState.bind(input);
+
+    this.reconcileDeliveries(this.sessionGet(input.threadId));
+
+    return binding;
+  }
+
+  harnessGetBinding(bindingId: string): HarnessBinding {
+    const binding = this.harnessState.binding(bindingId);
+
+    if (!binding) throw new DaemonError("not_found", `no harness binding ${bindingId}`);
+
+    return binding;
+  }
+
+  harnessConsumeApprovedRetry(bindingId: string, messageId: string, content: string): boolean {
+    const binding = this.harnessState.binding(bindingId);
+
+    if (!binding) throw new DaemonError("not_found", `no harness binding ${bindingId}`);
+    const session = this.sessionGet(binding.threadId);
+
+    if (
+      session.artifact.type !== "plan" ||
+      session.status !== "resolved" ||
+      session.message?.id !== messageId ||
+      session.message.outcome !== "approved" ||
+      session.artifact.content !== content ||
+      this.harnessState.submittingBinding(session.id)?.id !== bindingId ||
+      !this.harnessState.acknowledged(bindingId, messageId)
+    ) {
+      throw new DaemonError("invalid_state", `no unchanged approved plan for ${bindingId}`);
+    }
+
+    return this.harnessState.consumeApprovedRetry(bindingId, messageId);
+  }
+
+  deliveryPending(bindingId: string): PendingDelivery[] {
+    const binding = this.harnessState.binding(bindingId);
+
+    if (!binding) throw new DaemonError("not_found", `no harness binding ${bindingId}`);
+    const session = this.sessionGet(binding.threadId);
+
+    return this.harnessState.pending(bindingId).map((delivery) => {
+      const historical = session.history?.entries.find(
+        (entry) => entry.type === "message" && entry.message.id === delivery.messageId,
+      );
+      const message =
+        session.message?.id === delivery.messageId
+          ? session.message
+          : historical?.type === "message"
+            ? historical.message
+            : null;
+
+      if (!message || message.id !== delivery.messageId) {
+        throw new DaemonError("not_found", `no message ${delivery.messageId}`);
+      }
+
+      return { delivery, message };
+    });
+  }
+
+  deliveryAcknowledge(deliveryId: string): Delivery {
+    if (!this.harnessState.delivery(deliveryId)) {
+      throw new DaemonError("not_found", `no delivery ${deliveryId}`);
+    }
+
+    return this.harnessState.acknowledge(deliveryId);
+  }
+
   onEvent(listener: EventListener): () => void {
     this.listeners.add(listener);
 
@@ -138,7 +229,7 @@ export class DaemonCore {
     for (const listener of this.listeners) listener(frame);
   }
 
-  /** True when nothing awaits a verdict - drives idle-exit. */
+  /** True when nothing awaits a message - drives idle-exit. */
   hasPendingSessions(): boolean {
     return this.store.list().some((session) => session.status === "pending");
   }
@@ -152,13 +243,14 @@ export class DaemonCore {
       artifact: params.artifact,
       revisions: [{ revision: 1, content: params.artifact.content, submittedAt: now }],
       annotations: [],
-      verdict: null,
+      message: null,
       status: "pending",
       createdAt: now,
     };
 
     session.history = historyFromLinear(session);
     this.store.upsert(session);
+    this.reconcileDeliveries(session);
     this.trackLiveDiffSession(session);
     this.emit("session.created", session.id);
     this.emit("inbox.changed", session.id);
@@ -166,6 +258,15 @@ export class DaemonCore {
     return session;
   }
 
+  private reconcileDeliveries(session: Thread): void {
+    if (!session.message) return;
+
+    const binding = this.harnessState.submittingBinding(session.id);
+
+    if (binding)
+      this.harnessState.enqueue({ bindingId: binding.id, messageId: session.message.id });
+  }
+
   private newSessionId(now: string): string {
     return `ses_${now.replace(/\D/g, "").slice(0, 14)}_${(++this.seq).toString(36)}${Math.random().toString(36).slice(2, 6)}`;
   }
@@ -194,9 +295,9 @@ export class DaemonCore {
   }
 
   /**
-   * Long-poll for the verdict. Resolves immediately when already resolved;
-   * otherwise parks until sessionResolve fires or timeoutMs elapses (null =
-   * still pending - the caller re-polls later; the verdict is never lost).
+   * Long-poll for the message. Resolves immediately when already resolved;
+   * otherwise parks until sessionSendMessage fires or timeoutMs elapses (null =
+   * still pending - the caller re-polls later; the message is never lost).
    */
   sessionWait(id: string, timeoutMs: number): Promise<Thread | null> {
     const current = this.sessionGet(id);
@@ -539,7 +640,7 @@ export class DaemonCore {
     if (session.artifact.type !== "diff") {
       throw new DaemonError("invalid_params", "only a diff review is curated by hunk");
     }
-    if (!session.artifact.files) {
+    if (!session.artifact.files?.length) {
       throw new DaemonError("invalid_params", "hunk curation needs full file contents");
     }
     if (rejections.length === 0) delete session.curation;
@@ -611,35 +712,38 @@ export class DaemonCore {
     return session;
   }
 
-  sessionResolve(
+  sessionSendMessage(
     id: string,
-    verdictKind: VerdictKind,
+    outcome: MessageOutcome,
     summary: string,
     actionBodies?: Record<string, string>,
   ): Thread {
     const session = this.mutable(id);
-    const verdict: Verdict = {
-      kind: verdictKind,
+    const sentAt = new Date().toISOString();
+    const message: Message = {
+      id: newMessageId(),
+      outcome,
       summary,
-      feedback: feedbackForSession(session, verdictKind, summary, actionBodies),
-      resolvedAt: new Date().toISOString(),
+      body: feedbackForSession(session, outcome, summary, actionBodies),
+      sentAt,
     };
 
-    session.verdict = verdict;
+    session.message = message;
     session.status = "resolved";
     const entryId = this.record(session, {
-      type: "verdict",
-      verdict,
-      createdAt: verdict.resolvedAt,
+      type: "message",
+      message,
+      createdAt: message.sentAt,
     });
     this.store.upsert(session);
+    this.reconcileDeliveries(session);
     // a resolved diff review is frozen; stop hot-reloading its working tree
     this.untrackLiveDiffSession(session);
     const parked = this.waiters.get(id) ?? [];
 
     this.waiters.delete(id);
     for (const parkedWaiter of parked) parkedWaiter(session);
-    this.emit("session.resolved", id, entryId);
+    this.emit("message.sent", id, entryId);
     this.emit("inbox.changed", id);
 
     return session;
@@ -659,13 +763,14 @@ export class DaemonCore {
     id: string,
     content: string,
     addressedAnnotationIds: string[] = [],
+    files?: DiffFileContents[],
   ): Thread {
     const session = this.sessionGet(id);
     const now = new Date().toISOString();
     const revisionNumber = session.revisions.length + 1;
 
     session.revisions.push({ revision: revisionNumber, content, submittedAt: now });
-    session.artifact = { ...session.artifact, content };
+    session.artifact = { ...session.artifact, content, files: files ?? session.artifact.files };
     // the agent's revision lands on main wherever its tip sits; the artifact
     // shows the head of the branch the reviewer is on
     const entryId = this.recordOnMain(session, {
@@ -675,7 +780,7 @@ export class DaemonCore {
       createdAt: now,
     });
     delete session.workingCopy;
-    session.verdict = null;
+    session.message = null;
     session.status = "pending";
 
     // a reported root comment addresses its whole discussion: replies are
@@ -776,7 +881,7 @@ export class DaemonCore {
 
   /**
    * Copy the current path into a new pending session: its revisions, open
-   * comments, labels, and participant names travel; verdicts, edits, and the
+   * comments, labels, and participant names travel; messages, edits, and the
    * share do not. A resolved session can be forked.
    */
   sessionFork(id: string): Thread {
@@ -799,7 +904,7 @@ export class DaemonCore {
         })),
       annotations: [],
       history,
-      verdict: null,
+      message: null,
       status: "pending",
       createdAt: now,
       parentSessionId: id,
@@ -1060,8 +1165,8 @@ function isPrReviewSession(session: Thread): boolean {
 }
 
 /** Convenience for adapters: map a resolved session to the agent contract. */
-export function verdictResponse(session: Thread) {
-  if (!session.verdict) throw new DaemonError("pending", "session has no verdict");
+export function messageResponse(session: Thread) {
+  if (!session.message) throw new DaemonError("pending", "session has no message");
 
-  return { allow: verdictAllows(session.verdict.kind), feedback: session.verdict.feedback };
+  return { allow: messageAllows(session.message.outcome), message: session.message };
 }

package/src/capabilities.test.ts

@@ -5,7 +5,7 @@ import type { MethodName } from "./validate";
 describe("roleAllowsMethod", () => {
   test("the owner may call every primitive", () => {
     // Assert
-    const owned: MethodName[] = ["session.resolve", "session.submitRevision", "session.delete"];
+    const owned: MethodName[] = ["session.sendMessage", "session.submitRevision", "session.delete"];
 
     for (const method of owned) expect(roleAllowsMethod("owner", method)).toBe(true);
   });
@@ -17,7 +17,7 @@ describe("roleAllowsMethod", () => {
     for (const method of open) expect(roleAllowsMethod("agent", method)).toBe(true);
     // Assert - denied
     const owned: MethodName[] = [
-      "session.resolve",
+      "session.sendMessage",
       "session.submitRevision",
       "session.setWorkingCopy",
       "session.delete",
@@ -32,7 +32,7 @@ describe("roleAllowsMethod", () => {
     ];
 
     for (const method of owned) expect(roleAllowsMethod("agent", method)).toBe(false);
-    expect(roleAllowsMethod("collaborator", "session.resolve")).toBe(false);
+    expect(roleAllowsMethod("collaborator", "session.sendMessage")).toBe(false);
     // removal and naming are open to every role; the primitive itself scopes a
     // non-owner to the author it acts as
     expect(roleAllowsMethod("agent", "session.removeAnnotation")).toBe(true);

package/src/capabilities.ts

@@ -58,7 +58,12 @@ const PRIMITIVE_ROLES = {
   "session.setShares": "owner",
   "session.delete": "owner",
   "session.mergeShared": "owner",
-  "session.resolve": "owner",
+  "session.sendMessage": "owner",
+  "harness.bind": "owner",
+  "harness.getBinding": "owner",
+  "harness.consumeApprovedRetry": "owner",
+  "delivery.pending": "owner",
+  "delivery.acknowledge": "owner",
   "session.submitRevision": "owner",
   "herdr.getTab": "owner",
   "herdr.setTab": "owner",