@cueloop/daemon 0.1.0-alpha.102 → 0.1.0-alpha.103

package/src/harness-handoff.ts

@@ -0,0 +1,27 @@
+import type { Thread, ThreadAgentState } from "@cueloop/schema";
+
+/** Handoff transfers continuation context, never provider credentials or private session files. */
+export function harnessHandoffPrompt(thread: Thread, state: ThreadAgentState): string {
+  return `Prepare a continuation document for another agent taking over this Thread.
+Do not execute tools or change files. Return only the handoff text.
+Include the current goal, decisions, completed work, outstanding work, constraints, and suggested skills.
+Reference existing artifacts by path or URL instead of duplicating them.
+Redact credentials, passwords, and personal information.
+Thread: ${thread.id}
+Workspace: ${thread.workspace.repoRoot}
+Reviewed artifact:
+${thread.artifact.content.slice(0, 32768)}
+Pending continuation context:
+${state.continuation ?? ""}
+Recent conversation:
+${state.messages
+  .filter((message) => message.complete)
+  .map((message) => `${message.role}: ${message.text}`)
+  .join("\n")
+  .slice(-65536)}`;
+}
+
+/** The receiving agent treats the handoff as context rather than a fresh user instruction. */
+export function harnessContinuationPrompt(handoff: string, prompt: string): string {
+  return `Continuation context from the previous harness:\n${handoff}\n\nCurrent request:\n${prompt}`;
+}

package/src/harness-state-store.ts

@@ -32,6 +32,7 @@ export class HarnessStateStore {
     );
 
     if (existing) return existing;
+
     const binding: HarnessBinding = {
       ...input,
       id: newRoutingId("bind"),
@@ -77,6 +78,7 @@ export class HarnessStateStore {
 
   private deleteBindingsAndDeliveries(bindingIds: ReadonlySet<string>): boolean {
     if (bindingIds.size === 0) return false;
+
     for (const bindingId of bindingIds) this.bindings.delete(bindingId);
     for (const delivery of this.deliveries.values()) {
       if (bindingIds.has(delivery.bindingId)) this.deliveries.delete(delivery.id);
@@ -111,6 +113,7 @@ export class HarnessStateStore {
     );
 
     if (existing) return existing;
+
     const delivery: Delivery = {
       ...input,
       id: newRoutingId("del"),
@@ -136,6 +139,7 @@ export class HarnessStateStore {
 
     for (const delivery of this.deliveries.values()) {
       if (delivery.status !== "pending") continue;
+
       const binding = this.bindings.get(delivery.bindingId);
 
       if (binding) ids.add(binding.threadId);
@@ -163,6 +167,7 @@ export class HarnessStateStore {
     if (!delivery) throw new Error(`no delivery ${deliveryId}`);
 
     if (delivery.status === "acknowledged") return delivery;
+
     const acknowledged: Delivery = {
       ...delivery,
       status: "acknowledged",

package/src/herdr-split.ts

@@ -34,6 +34,7 @@ export function launchHarnessInSplit(
   const herdr = detectHerdr(env);
 
   if (!herdr) return false;
+
   try {
     const split = Bun.spawnSync(
       [
@@ -52,14 +53,18 @@ export function launchHarnessInSplit(
     );
 
     if (split.exitCode !== 0) return false;
+
     const parsed = v.safeParse(SplitPaneSchema, JSON.parse(split.stdout.toString()));
 
     if (!parsed.success) return false;
+
     const paneId = parsed.output.result?.pane?.pane_id;
 
     if (!paneId) return false;
+
     sendText(herdr.binPath, paneId, options.command);
     sendKeys(herdr.binPath, paneId, "enter");
+
     if (options.seedText) sendText(herdr.binPath, paneId, options.seedText);
 
     return true;

package/src/herdr-thread-surface.ts

@@ -92,9 +92,11 @@ export function openHerdrThreadTab(
     );
 
     if (created.exitCode !== 0) return null;
+
     const parsed = v.safeParse(CreatedTabSchema, JSON.parse(created.stdout.toString()));
 
     if (!parsed.success) return null;
+
     const paneId = parsed.output.result?.root_pane?.pane_id;
     const tabId = parsed.output.result?.root_pane?.tab_id;
 
@@ -147,10 +149,12 @@ export function openHerdrThreadPane(
     );
 
     if (created.exitCode !== 0) return null;
+
     const parsed = v.safeParse(CreatedPaneSchema, JSON.parse(created.stdout.toString()));
     const paneId = parsed.success ? parsed.output.result?.pane?.pane_id : undefined;
 
     if (!paneId) return null;
+
     if (!sendCueloopThreadCommand(binPath, paneId, sessionId, layout)) {
       closeHerdrThreadSurface(binPath, "pane", paneId);
 
@@ -189,6 +193,7 @@ function sendCueloopThreadCommand(
   });
 
   if (typed.exitCode !== 0) return false;
+
   const entered = runHerdrCommand([binPath, "pane", "send-keys", paneId, "enter"], {
     stdout: "ignore",
     stderr: "ignore",
@@ -208,6 +213,7 @@ function herdrPaneAlive(binPath: string, paneId: string): boolean {
     });
 
     if (got.exitCode !== 0) return false;
+
     const parsed = v.safeParse(PaneResultSchema, JSON.parse(got.stdout.toString()));
 
     return parsed.success && parsed.output.result?.pane != null;
@@ -249,10 +255,13 @@ function focusHerdrThreadSurface(binPath: string, handle: HerdrThreadSurfaceHand
       const neighbor = herdrPaneNeighbor(binPath, handle.paneId, direction);
 
       if (neighbor === undefined) return false;
+
       if (neighbor === null) continue;
+
       hasNeighbor = true;
 
       if (herdrPaneNeighbor(binPath, neighbor, opposite) !== handle.paneId) continue;
+
       const focused = runHerdrCommand(
         [binPath, "pane", "focus", "--pane", neighbor, "--direction", opposite],
         { stdout: "pipe", stderr: "ignore", timeout: HERDR_SPAWN_TIMEOUT_MS },
@@ -286,6 +295,7 @@ function herdrPaneNeighbor(
     );
 
     if (neighbor.exitCode !== 0) return undefined;
+
     const parsed = v.safeParse(PaneNeighborSchema, JSON.parse(neighbor.stdout.toString()));
 
     return parsed.success ? (parsed.output.result.neighbor.neighbor_pane_id ?? null) : undefined;
@@ -307,6 +317,7 @@ export async function openHerdrThreadSurface(
   if (!herdr) return "unavailable";
 
   if (mode === "none") return "disabled";
+
   const recorded = await recallHerdrThreadSurface(persistence, session.id);
 
   if (
@@ -317,6 +328,7 @@ export async function openHerdrThreadSurface(
   ) {
     return focusHerdrThreadSurface(herdr.binPath, recorded) ? "focused" : "failed";
   }
+
   const cwd = session.artifact.meta.cwd ?? session.workspace.repoRoot;
   const opened =
     mode === "pane"
@@ -340,6 +352,7 @@ export async function openHerdrThreadSurface(
         });
 
   if (!opened) return "failed";
+
   if (recorded && recorded.paneId !== opened.paneId) {
     closeHerdrThreadSurface(
       herdr.binPath,
@@ -347,6 +360,7 @@ export async function openHerdrThreadSurface(
       recorded.mode === "pane" ? recorded.paneId : recorded.tabId,
     );
   }
+
   await rememberHerdrThreadSurface(persistence, session.id, opened);
 
   return "opened";

package/src/interruptible-wait.ts

@@ -9,6 +9,7 @@ const whenSignalAborts = (signal: AbortSignal): Effect.Effect<void> =>
 
       return;
     }
+
     const onAbort = () => resume(Effect.void);
 
     signal.addEventListener("abort", onAbort, { once: true });
@@ -37,6 +38,7 @@ export function raceAbort<T>(
   signal: AbortSignal | undefined,
 ): Promise<T | typeof ABORTED> {
   if (!signal) return promise;
+
   if (signal.aborted) {
     promise.catch(() => {});
 
@@ -56,6 +58,7 @@ export function pollUntilResolved<T>(
   signal: AbortSignal | undefined,
 ): Promise<T | null> {
   if (signal?.aborted) return Promise.resolve(null);
+
   const loop = Effect.repeat(fromSettledPromise(attempt), {
     until: (result): result is T => result !== null,
   });

package/src/jj-working-tree.ts

@@ -26,6 +26,7 @@ function jjSummary(text: string): { path: string; status: DiffFileStatus; curata
     const path = tokens[index + 1];
 
     if (!code || !path) continue;
+
     changes.push({
       path,
       status: code === "A" ? "added" : code === "D" ? "deleted" : "modified",
@@ -62,12 +63,15 @@ async function captureJjRevision(repoRoot: string, revset: string): Promise<VcsD
   );
 
   if (!identity) throw new Error(`Jujutsu diff capture failed: could not resolve ${revset}`);
+
   const lines = identity.trim().split("\n");
 
   if (lines.length !== 3) throw new Error(`Jujutsu change is ambiguous: ${revset}`);
+
   const [changeId, revisionId, parents] = lines;
 
   if (!changeId || !revisionId) throw new Error("Jujutsu diff capture failed: invalid identity");
+
   const [patch, summary] = await Promise.all([
     jj(["--ignore-working-copy", "diff", "--git", "-r", revisionId], repoRoot),
     jj(["--ignore-working-copy", "diff", "-T", JJ_DIFF_FILES_TEMPLATE, "-r", revisionId], repoRoot),
@@ -75,19 +79,23 @@ async function captureJjRevision(repoRoot: string, revset: string): Promise<VcsD
 
   if (patch === null || summary === null)
     throw new Error("Jujutsu diff capture failed: could not read pinned revision");
+
   const files: DiffFileContents[] = [];
   const parent = parents?.split(",")[0];
 
   if (parent && !parents?.includes(",")) {
     for (const change of jjSummary(summary)) {
       if (!change.curatable) continue;
+
       const oldContents =
         change.status === "added" ? "" : await jjFileContents(repoRoot, parent, change.path);
       const newContents =
         change.status === "deleted" ? "" : await jjFileContents(repoRoot, revisionId, change.path);
 
       if (oldContents === null || newContents === null) continue;
+
       if (isBinary(oldContents) || isBinary(newContents)) continue;
+
       files.push({ path: change.path, oldContents, newContents, status: change.status });
     }
   }
@@ -109,6 +117,7 @@ export const jjVcsAdapter: VcsAdapter = {
   },
   async captureChange(repoRoot, changeId) {
     if (!/^[a-z]{32}$/.test(changeId)) throw new Error(`Jujutsu change ID is invalid: ${changeId}`);
+
     if ((await jj(["status"], repoRoot)) === null)
       throw new Error("Jujutsu diff capture failed: could not snapshot the working copy");
 

package/src/main.ts

@@ -13,6 +13,7 @@ if (path === null) {
   console.log("cueloop daemon already running for this home");
   process.exit(0);
 }
+
 console.log(`cueloop daemon listening on ${path}`);
 
 process.on("SIGINT", () => {

package/src/operation-receipts.ts

@@ -16,6 +16,7 @@ export function findOperationReceipt<Result>(
   fingerprint: string,
 ): OperationReceipt<Result> | undefined {
   if (!operationId) return;
+
   const receipt = receipts?.find((entry) => entry.operationId === operationId);
 
   if (receipt && receipt.fingerprint !== fingerprint)
@@ -23,6 +24,7 @@ export function findOperationReceipt<Result>(
       "operation_conflict",
       "Operation payload conflict: use a new operation ID for changed input",
     );
+
   if (!receipt && (receipts?.length ?? 0) >= 128)
     throw new DaemonError(
       "operation_capacity",
@@ -39,12 +41,14 @@ export function recordPromptOperation(
   input: AgentPromptRequest,
 ): void {
   if (!input.operationId) return;
+
   const previous = new Set(before.submissions?.map((entry) => entry.id));
   const accepted = input.retry
     ? [input.retry]
     : (state.submissions ?? []).filter((entry) => !previous.has(entry.id)).map((entry) => entry.id);
 
   if (!accepted.length) throw new DaemonError("invalid_params", "Agent operation requires input");
+
   const fingerprint = promptOperationFingerprint(input);
 
   (state.promptOperations ??= []).push({
@@ -58,6 +62,7 @@ export function recordPromptOperation(
 export function settlePromptOperations(state: ThreadAgentState): void {
   for (const receipt of state.promptOperations ?? []) {
     if (receipt.outcome || !receipt.result.length) continue;
+
     const submissions = receipt.result.map((id) =>
       state.submissions?.find((entry) => entry.id === id),
     );
@@ -66,6 +71,7 @@ export function settlePromptOperations(state: ThreadAgentState): void {
       submissions.some((entry) => !entry || entry.status === "queued" || entry.status === "running")
     )
       continue;
+
     receipt.outcome = submissions.some((entry) => entry?.cancelled)
       ? "cancelled"
       : submissions.some((entry) => entry?.status === "failed")

package/src/pr-poller.ts

@@ -27,6 +27,7 @@ export class PrReviewPoller {
   /** Start polling a PR review. Idempotent per session; the persisted reviewed head is the baseline. */
   trackPr(sessionId: string, pr: string, reviewedRefs: PullRequestRefs | null = null): void {
     if (this.polls.has(sessionId)) return;
+
     const timer = setInterval(() => void this.refreshHead(sessionId), this.intervalMs);
 
     // the poll timer must not by itself keep the daemon alive against idle-exit
@@ -40,20 +41,25 @@ export class PrReviewPoller {
     const poll = this.polls.get(sessionId);
 
     if (!poll) return;
+
     const refs = await this.refs(poll.pr).catch(() => null);
 
     if (refs === null) return;
+
     // the await yields; re-read so an untrack during the call is honoured
     const current = this.polls.get(sessionId);
 
     if (!current) return;
+
     if (current.lastRefs === null) {
       current.lastRefs = refs;
 
       return;
     }
+
     if (refs.baseSha === current.lastRefs.baseSha && refs.headSha === current.lastRefs.headSha)
       return;
+
     current.lastRefs = refs;
     this.onPrAdvance(sessionId, refs);
   }
@@ -62,6 +68,7 @@ export class PrReviewPoller {
     const poll = this.polls.get(sessionId);
 
     if (!poll) return;
+
     clearInterval(poll.timer);
     this.polls.delete(sessionId);
   }

package/src/project-files.ts

@@ -21,6 +21,7 @@ async function gitFileList(repoRoot: string, args: string[]): Promise<string[] |
 /** Existing tracked paths, sorted ascending and capped; [] on failure or a non-repo. */
 export async function listProjectFiles(repoRoot: string | undefined): Promise<string[]> {
   if (repoRoot === undefined || repoRoot.length === 0) return [];
+
   try {
     const [tracked, deleted] = await Promise.all([
       gitFileList(repoRoot, ["--cached"]),
@@ -28,6 +29,7 @@ export async function listProjectFiles(repoRoot: string | undefined): Promise<st
     ]);
 
     if (tracked === null || deleted === null) return [];
+
     const missing = new Set(deleted);
 
     return tracked
@@ -52,10 +54,12 @@ export async function readProjectFile(
   path: string,
 ): Promise<string | null> {
   if (repoRoot === undefined || repoRoot.length === 0) return null;
+
   const root = resolve(repoRoot);
   const target = resolve(root, path);
 
   if (escapesRoot(root, target)) return null;
+
   try {
     const stats = await stat(target);
 

package/src/protocol.ts

@@ -60,9 +60,11 @@ export class LineBuffer {
       const newlineIndex = this.buffered.indexOf("\n");
 
       if (newlineIndex === -1) return;
+
       const line = this.buffered.slice(0, newlineIndex).trim();
 
       this.buffered = this.buffered.slice(newlineIndex + 1);
+
       if (line) onLine(line);
     }
   }
@@ -93,6 +95,7 @@ export class BackpressureWriter {
 
       return;
     }
+
     const written = Math.max(0, this.socket.write(bytes));
 
     if (written < bytes.length) this.pending = bytes.subarray(written);
@@ -101,6 +104,7 @@ export class BackpressureWriter {
   /** Call from the socket's drain handler. */
   drain(): void {
     if (!this.pending) return;
+
     const tail = this.pending;
 
     this.pending = null;

package/src/retention.ts

@@ -32,6 +32,7 @@ function userConfigPath(env: NodeJS.ProcessEnv): string {
   const explicit = env.CUELOOP_CONFIG;
 
   if (explicit && explicit.trim()) return explicit;
+
   const xdgConfigHome = env.XDG_CONFIG_HOME;
   const base = xdgConfigHome && xdgConfigHome.trim() ? xdgConfigHome : join(homedir(), ".config");
 
@@ -49,6 +50,7 @@ function readConfiguredPeriodDays(path: string): number | undefined {
   const parsed = v.safeParse(CleanupConfigSchema, raw);
 
   if (!parsed.success) return undefined;
+
   const value = parsed.output.cleanup?.period_days;
 
   return value !== undefined && Number.isFinite(value) && value >= 0 ? value : undefined;
@@ -60,6 +62,7 @@ export function resolveCleanupPeriodDays(env: NodeJS.ProcessEnv = process.env):
 
 export function isExpired(createdAt: string, periodDays: number, nowMs: number): boolean {
   if (periodDays <= 0) return false;
+
   const createdMs = Date.parse(createdAt);
 
   if (Number.isNaN(createdMs)) return false;
@@ -74,10 +77,12 @@ export function pruneExpiredSessions(
   protectedThreadIds: ReadonlySet<string> = new Set(),
 ): string[] {
   if (periodDays <= 0) return [];
+
   const pruned: string[] = [];
 
   for (const session of store.list()) {
     if (session.status !== "resolved" || protectedThreadIds.has(session.id)) continue;
+
     if (isExpired(session.createdAt, periodDays, nowMs) && store.delete(session.id)) {
       pruned.push(session.id);
     }
@@ -98,6 +103,7 @@ export function pruneExpiredReports(
   nowMs: number,
 ): string[] {
   if (periodDays <= 0) return [];
+
   let entries: string[];
 
   try {
@@ -110,7 +116,9 @@ export function pruneExpiredReports(
 
   for (const entry of entries) {
     if (entry === LATEST_REPORT_FILENAME) continue;
+
     if (!entry.startsWith(TIMESTAMPED_REPORT_PREFIX)) continue;
+
     const path = join(reportsDirectory, entry);
 
     if (statSync(path).mtimeMs < cutoffMs) {

package/src/server.ts

@@ -45,7 +45,11 @@ interface Connection {
 type MethodHandler = (connection: Connection, request: Request) => Response["result"];
 
 export interface DaemonOptions {
-  threadAgent?: Pick<ThreadAgentOptions, "enabled" | "enabledForThread" | "adapter" | "adapters">;
+  agentHarnessDefault?: () => string;
+  threadAgent?: Pick<
+    ThreadAgentOptions,
+    "enabled" | "enabledForThread" | "adapter" | "adapters" | "defaultHarnessForThread"
+  >;
   home?: string;
   onEvent?: (event: import("./client").EventFrame) => void;
   idleExitMs?: number;
@@ -76,7 +80,7 @@ export class DaemonServer {
   private readonly version: string;
   private readonly onEvent?: (event: import("./client").EventFrame) => void;
 
-  constructor(options: DaemonOptions = {}) {
+  constructor(private readonly options: DaemonOptions = {}) {
     this.onEvent = options.onEvent;
     this.home = options.home ?? cueloopHome();
     this.idleExitMs = options.idleExitMs ?? 15 * 60 * 1000;
@@ -154,6 +158,7 @@ export class DaemonServer {
    */
   private acquireLock(): boolean {
     if (HELD_HOMES.has(this.home)) return false; // another instance here owns it
+
     const path = lockPath(this.home);
 
     for (let attempt = 0; attempt < 3; attempt++) {
@@ -171,6 +176,7 @@ export class DaemonServer {
         return true;
       } catch (error) {
         closeSync(fd);
+
         if (!(error instanceof Error && "code" in error && error.code === "EEXIST")) throw error;
 
         let ownerPid = 0;
@@ -184,12 +190,15 @@ export class DaemonServer {
             Atomics.wait(LOCK_WAIT, 0, 0, 20);
             ownerText = readFileSync(path, "utf8").trim();
           }
+
           if (!ownerText && Date.now() - statSync(path).mtimeMs < 5_000) return false;
+
           ownerPid = Number(ownerText);
         } catch {
           // the owner vanished between open and read; retry
           continue;
         }
+
         if (ownerPid && ownerPid !== process.pid) {
           try {
             process.kill(ownerPid, 0); // throws when the pid is gone
@@ -199,6 +208,7 @@ export class DaemonServer {
             // stale lock from a crashed daemon
           }
         }
+
         // ownerPid === our pid but HELD_HOMES says we do not own it: a stale
         // file from an earlier instance in this process - reclaim it.
         try {
@@ -216,6 +226,7 @@ export class DaemonServer {
 
   private releaseLock(): void {
     HELD_HOMES.delete(this.home);
+
     if (this.lockFd !== null) {
       try {
         if (statSync(lockPath(this.home)).ino === fstatSync(this.lockFd).ino)
@@ -238,11 +249,13 @@ export class DaemonServer {
    */
   start(): string | null {
     if (!this.acquireLock()) return null;
+
     const path = socketPath(this.home);
 
     // safe now: holding the lock means no live daemon owns this home, so any
     // socket file left behind is stale
     if (existsSync(path)) rmSync(path, { force: true });
+
     // the token exists before the socket does: the first client to connect
     // must be able to prove ownership
     this.ownerToken = randomBytes(32).toString("hex");
@@ -294,12 +307,10 @@ export class DaemonServer {
   resumeAgents(): void {
     for (const thread of this.core.sessionList({ status: "pending" })) {
       if (!this.threadAgent.isEnabled(thread.id)) continue;
+
       const state = this.threadAgent.get(thread.id);
 
-      if (
-        state.harness?.id === "pi" &&
-        state.submissions?.some((submission) => submission.status === "queued")
-      )
+      if (state.handoff || state.submissions?.some((submission) => submission.status === "queued"))
         void this.threadAgent
           .configure({ id: thread.id })
           .catch((error) => console.error("[agent recovery]", error));
@@ -314,13 +325,17 @@ export class DaemonServer {
   stop(): void {
     void this.threadAgent.dispose().catch((error) => console.error("[agent shutdown]", error));
     this.core.dispose();
+
     if (this.lockFd === null) return;
+
     this.server?.stop(true);
     this.server = null;
     rmSync(socketPath(this.home), { force: true });
     rmSync(pidPath(this.home), { force: true });
     rmSync(ownerTokenPath(this.home), { force: true });
+
     if (this.idleTimer) clearTimeout(this.idleTimer);
+
     this.releaseLock();
   }
 
@@ -335,7 +350,9 @@ export class DaemonServer {
   /** Idle = no pending session and no attached client. */
   private scheduleIdleCheck(): void {
     if (this.idleExitMs <= 0) return;
+
     if (this.idleTimer) clearTimeout(this.idleTimer);
+
     this.idleTimer = setTimeout(() => {
       if (this.connections.size === 0 && !this.core.hasPendingSessions()) {
         this.stop();
@@ -376,16 +393,19 @@ export class DaemonServer {
     const origin = this.core.sessionGet(threadId);
 
     assertAgentToolScope(origin, args);
+
     if (args.kind === "api" && args.method === "session.list") {
       const { filter } = parseParams("session.list", args.params);
 
       return JSON.stringify(!filter?.status || origin.status === filter.status ? [origin] : []);
     }
+
     if (args.kind === "reply") {
       const thread = origin;
       const comment = thread.annotations.find((entry) => entry.id === args.commentId);
 
       if (!comment) return JSON.stringify(this.replyAgentComment(args));
+
       const root =
         thread.annotations.find((entry) => entry.id === (comment.replyTo ?? comment.id)) ?? comment;
 
@@ -405,6 +425,7 @@ export class DaemonServer {
         ),
       );
     }
+
     const method = args.method;
 
     if (!isKnownMethod(method)) throw new Error("Thread agent tool API method is unavailable");
@@ -475,7 +496,11 @@ export class DaemonServer {
 
       return this.threadAgent.permission(params);
     },
-    "daemon.ping": () => ({ pid: process.pid, version: this.version }),
+    "daemon.ping": () => ({
+      pid: process.pid,
+      version: this.version,
+      agentHarness: this.options.agentHarnessDefault?.() ?? this.options.threadAgent?.adapter?.id,
+    }),
     "daemon.hello": (connection, request) => {
       const params = parseParams("daemon.hello", request.params);
 
@@ -484,6 +509,7 @@ export class DaemonServer {
       if (params.role === "owner" && params.token !== this.ownerToken) {
         throw new DaemonError("forbidden", "owner token required");
       }
+
       if (params.clientVersion !== this.version) {
         throw new DaemonError(
           "version_mismatch",
@@ -492,6 +518,7 @@ export class DaemonServer {
       }
 
       connection.role = params.role;
+
       // identity is bound once, here; a non-owner never names it per call
       if (params.role !== "owner" && params.author !== undefined) connection.author = params.author;
 
@@ -779,11 +806,13 @@ export class DaemonServer {
     if (!isKnownMethod(request.method)) {
       throw new DaemonError("unknown_method", `unknown method ${request.method}`);
     }
+
     // Capability gate: a capped role (a review-side agent) cannot escalate past
     // read + annotate, whatever primitive it sends.
     if (!roleAllowsMethod(connection.role, request.method)) {
       throw new DaemonError("forbidden", `role ${connection.role} cannot call ${request.method}`);
     }
+
     if (!Object.hasOwn(this.handlers, request.method)) {
       throw new DaemonError("unknown_method", `unknown method ${request.method}`);
     }

package/src/share-blob.test.ts

@@ -71,8 +71,10 @@ describe("the payload cap against a long review", () => {
         body: "Fail fast with a readable error; the review never opens on a store that cannot write.",
         replyTo: `a_${round}`,
       });
+
       if (round % 10 === 0)
         core.sessionSetWorkingCopy(session.id, `${content}\n\nEdit ${round}.\n`);
+
       if (round % 20 === 0) core.sessionRemoveAnnotation(session.id, `r_${round}`);
     }
     const shared = viewFollowing(core.sessionGet(session.id));