@cueloop/daemon 0.1.0-alpha.10 → 0.1.0-alpha.101

package/src/server.ts

@@ -1,26 +1,56 @@
 /**
  * The socket server: binds DaemonCore's methods to the unix socket, owns the
- * pidfile, stale-socket cleanup, and the idle-exit timer (#14). File
+ * pidfile, stale-socket cleanup, and the idle-exit timer. File
  * permissions are the local auth: the socket and state dir are 0700/0600.
  */
 
-import { chmodSync, closeSync, existsSync, mkdirSync, openSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import {
+  chmodSync,
+  closeSync,
+  existsSync,
+  fstatSync,
+  linkSync,
+  mkdirSync,
+  openSync,
+  readFileSync,
+  rmSync,
+  statSync,
+  writeFileSync,
+} from "node:fs";
+import type { AgentHarnessTools } from "@cueloop/schema";
 import { DaemonCore, type DaemonEvent } from "./api";
 import { DaemonError } from "./errors";
-import { isKnownMethod, parseParams } from "./validate";
-import { LineBuffer, type Request } from "./protocol";
-import { cueloopHome, lockPath, pidPath, socketPath } from "./paths";
+import { DEFAULT_ROLE, roleAllowsMethod, type DaemonRole } from "./capabilities";
+import { isKnownMethod, parseParams, type MethodName } from "./validate";
+import {
+  BackpressureWriter,
+  LineBuffer,
+  parseRequestFrame,
+  type Request,
+  type Response,
+} from "./protocol";
+import { cueloopHome, lockPath, ownerTokenPath, pidPath, socketPath } from "./paths";
+import { DAEMON_VERSION } from "./version";
+import { randomUUID, randomBytes } from "node:crypto";
+import { parseAgentToolInput, assertAgentToolScope } from "./agent-tools";
+import { ThreadAgentManager, type ThreadAgentOptions } from "./thread-agent";
 
-interface Conn {
+interface Connection {
+  author?: string;
   write(data: string): void;
   subscribed: boolean;
+  role: DaemonRole;
 }
 
+type MethodHandler = (connection: Connection, request: Request) => Response["result"];
+
 export interface DaemonOptions {
+  threadAgent?: Pick<ThreadAgentOptions, "enabled" | "enabledForThread" | "adapter" | "adapters">;
   home?: string;
-  /** Idle-exit delay; 0 disables (tests, foreground runs). */
+  onEvent?: (event: import("./client").EventFrame) => void;
   idleExitMs?: number;
   onIdleExit?: () => void;
+  version?: string;
 }
 
 /**
@@ -29,24 +59,90 @@ export interface DaemonOptions {
  * so in-process ownership is tracked separately.
  */
 const HELD_HOMES = new Set<string>();
+const LOCK_WAIT = new Int32Array(new SharedArrayBuffer(4));
 
 export class DaemonServer {
+  private readonly threadAgent: ThreadAgentManager;
   readonly core: DaemonCore;
   readonly home: string;
-  private conns = new Set<Conn>();
+  private connections = new Set<Connection>();
   private server: ReturnType<typeof Bun.listen> | null = null;
   private idleTimer: ReturnType<typeof setTimeout> | null = null;
   private lockFd: number | null = null;
+  /** The secret that proves ownership; minted per daemon run, readable by the home's user only. */
+  private ownerToken = "";
   private readonly idleExitMs: number;
   private readonly onIdleExit: () => void;
+  private readonly version: string;
+  private readonly onEvent?: (event: import("./client").EventFrame) => void;
 
-  constructor(opts: DaemonOptions = {}) {
-    this.home = opts.home ?? cueloopHome();
-    this.idleExitMs = opts.idleExitMs ?? 15 * 60 * 1000;
-    this.onIdleExit = opts.onIdleExit ?? (() => process.exit(0));
+  constructor(options: DaemonOptions = {}) {
+    this.onEvent = options.onEvent;
+    this.home = options.home ?? cueloopHome();
+    this.idleExitMs = options.idleExitMs ?? 15 * 60 * 1000;
+    this.onIdleExit = options.onIdleExit ?? (() => process.exit(0));
+    this.version = options.version ?? DAEMON_VERSION;
     mkdirSync(this.home, { recursive: true, mode: 0o700 });
     this.core = new DaemonCore(this.home);
-    this.core.onEvent((e) => this.broadcast(e));
+    this.threadAgent = new ThreadAgentManager({
+      home: this.home,
+      enabled: options.threadAgent?.enabled ?? false,
+      enabledForThread: options.threadAgent?.enabledForThread,
+      adapter: options.threadAgent?.adapter,
+      adapters: options.threadAgent?.adapters,
+      getThread: (id) => this.core.sessionGet(id),
+      tools: (thread): AgentHarnessTools => ({
+        definitions: [
+          {
+            name: "send_message",
+            description:
+              "Return the Thread and its comments to the main session using the existing Send message action.",
+            inputSchema: {
+              type: "object",
+              properties: {
+                id: { type: "string" },
+                outcome: { type: "string", enum: ["comment", "approved", "changes_requested"] },
+                summary: { type: "string" },
+              },
+              required: ["id", "outcome"],
+            },
+          },
+          {
+            name: "reply_to_comment",
+            description:
+              "Append a reply to an existing comment discussion, preserving its quote and Changes origin.",
+            inputSchema: {
+              type: "object",
+              properties: {
+                id: { type: "string" },
+                commentId: { type: "string" },
+                body: { type: "string" },
+              },
+              required: ["id", "commentId", "body"],
+            },
+          },
+          {
+            name: "cueloop_api",
+            description:
+              "Call a cueloop API operation on this Thread or its repository. Use session.get to inspect this Thread. Global harness, sharing, deletion and Thread creation operations are unavailable. Parameters follow the cueloop socket API.",
+            inputSchema: {
+              type: "object",
+              properties: { method: { type: "string" }, params: { type: "object" } },
+              required: ["method", "params"],
+            },
+          },
+        ],
+        call: async (name, input) => this.callAgentTool(thread.id, name, input),
+      }),
+      onChange: (id) => {
+        this.onEvent?.({ event: "agent.updated", sessionId: id });
+        for (const connection of this.connections) {
+          if (connection.subscribed && connection.role === "owner")
+            connection.write(JSON.stringify({ event: "agent.updated", sessionId: id }) + "\n");
+        }
+      },
+    });
+    this.core.onEvent((event) => this.broadcast(event));
   }
 
   /**
@@ -59,18 +155,37 @@ 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++) {
+      const preparedPath = `${path}.${process.pid}.${randomBytes(8).toString("hex")}.tmp`;
+      const fd = openSync(preparedPath, "wx", 0o600);
+
       try {
-        // "wx" fails when the file exists - the atomic part of the handshake
-        const fd = openSync(path, "wx");
+        // Publish the complete pid atomically. A competing daemon must never
+        // mistake a newly created, still-empty lock for a crashed owner.
         writeFileSync(fd, String(process.pid));
+        linkSync(preparedPath, path);
         this.lockFd = fd;
         HELD_HOMES.add(this.home);
+
         return true;
-      } catch {
+      } catch (error) {
+        closeSync(fd);
+        if (!(error instanceof Error && "code" in error && error.code === "EEXIST")) throw error;
+
         let ownerPid = 0;
+
         try {
-          ownerPid = Number(readFileSync(path, "utf8").trim());
+          let ownerText = readFileSync(path, "utf8").trim();
+
+          // Older daemon builds published the lock before writing their pid.
+          // Give that live owner time to finish instead of stealing its socket.
+          for (let probe = 0; !ownerText && probe < 25; probe++) {
+            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;
@@ -78,6 +193,7 @@ export class DaemonServer {
         if (ownerPid && ownerPid !== process.pid) {
           try {
             process.kill(ownerPid, 0); // throws when the pid is gone
+
             return false; // a live daemon owns this home
           } catch {
             // stale lock from a crashed daemon
@@ -90,14 +206,23 @@ export class DaemonServer {
         } catch {
           return false;
         }
+      } finally {
+        rmSync(preparedPath, { force: true });
       }
     }
+
     return false;
   }
 
   private releaseLock(): void {
     HELD_HOMES.delete(this.home);
     if (this.lockFd !== null) {
+      try {
+        if (statSync(lockPath(this.home)).ino === fstatSync(this.lockFd).ino)
+          rmSync(lockPath(this.home), { force: true });
+      } catch {
+        // the lock was already removed or replaced
+      }
       try {
         closeSync(this.lockFd);
       } catch {
@@ -105,7 +230,6 @@ export class DaemonServer {
       }
       this.lockFd = null;
     }
-    rmSync(lockPath(this.home), { force: true });
   }
 
   /**
@@ -115,27 +239,47 @@ 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 });
-    const self = this;
-    this.server = Bun.listen<{ buffer: LineBuffer; conn: Conn }>({
+    // the token exists before the socket does: the first client to connect
+    // must be able to prove ownership
+    this.ownerToken = randomBytes(32).toString("hex");
+    writeFileSync(ownerTokenPath(this.home), this.ownerToken, { mode: 0o600 });
+    chmodSync(ownerTokenPath(this.home), 0o600);
+    this.server = Bun.listen<{
+      buffer: LineBuffer;
+      connection: Connection;
+      writer: BackpressureWriter;
+    }>({
       unix: path,
       socket: {
-        open(socket) {
-          const conn: Conn = { write: (d) => socket.write(d), subscribed: false };
-          socket.data = { buffer: new LineBuffer(), conn };
-          self.conns.add(conn);
-          self.scheduleIdleCheck();
+        open: (socket) => {
+          const writer = new BackpressureWriter(socket);
+          const connection: Connection = {
+            write: (data) => writer.write(data),
+            subscribed: false,
+            role: DEFAULT_ROLE,
+          };
+
+          socket.data = { buffer: new LineBuffer(), connection, writer };
+          this.connections.add(connection);
+          this.scheduleIdleCheck();
         },
-        data(socket, data) {
+        data: (socket, data) => {
           socket.data.buffer.push(data.toString(), (line) => {
-            void self.handleLine(socket.data.conn, line);
+            void this.respondToRequestLine(socket.data.connection, line);
           });
         },
-        close(socket) {
-          self.conns.delete(socket.data.conn);
-          self.scheduleIdleCheck();
+        drain(socket) {
+          // drain can fire before open has attached data on some platforms;
+          // a throw here would take the whole daemon down with the socket
+          socket.data?.writer.drain();
+        },
+        close: (socket) => {
+          this.connections.delete(socket.data.connection);
+          this.scheduleIdleCheck();
         },
         error() {},
       },
@@ -143,21 +287,48 @@ export class DaemonServer {
     chmodSync(path, 0o600);
     writeFileSync(pidPath(this.home), String(process.pid));
     this.scheduleIdleCheck();
+
     return path;
   }
 
+  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")
+      )
+        void this.threadAgent
+          .configure({ id: thread.id })
+          .catch((error) => console.error("[agent recovery]", error));
+    }
+  }
+
+  async shutdown(): Promise<void> {
+    await this.threadAgent.dispose();
+    this.stop();
+  }
+
   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();
   }
 
-  private broadcast(e: DaemonEvent): void {
-    const frame = JSON.stringify(e) + "\n";
-    for (const c of this.conns) if (c.subscribed) c.write(frame);
+  private broadcast(event: DaemonEvent): void {
+    this.onEvent?.(event);
+    const frame = JSON.stringify(event) + "\n";
+
+    for (const connection of this.connections) if (connection.subscribed) connection.write(frame);
     this.scheduleIdleCheck();
   }
 
@@ -166,7 +337,7 @@ export class DaemonServer {
     if (this.idleExitMs <= 0) return;
     if (this.idleTimer) clearTimeout(this.idleTimer);
     this.idleTimer = setTimeout(() => {
-      if (this.conns.size === 0 && !this.core.hasPendingSessions()) {
+      if (this.connections.size === 0 && !this.core.hasPendingSessions()) {
         this.stop();
         this.onIdleExit();
       } else {
@@ -175,76 +346,448 @@ export class DaemonServer {
     }, this.idleExitMs);
   }
 
-  private async handleLine(conn: Conn, line: string): Promise<void> {
-    let req: Request;
+  private async respondToRequestLine(connection: Connection, line: string): Promise<void> {
+    let request: Request;
+
     try {
-      req = JSON.parse(line) as Request;
+      request = parseRequestFrame(line);
     } catch {
-      conn.write(JSON.stringify({ id: -1, error: { code: "bad_json", message: "unparseable request" } }) + "\n");
+      connection.write(
+        JSON.stringify({ id: -1, error: { code: "bad_json", message: "unparseable request" } }) +
+          "\n",
+      );
+
       return;
     }
     try {
-      const result = await this.dispatch(conn, req);
-      conn.write(JSON.stringify({ id: req.id, result }) + "\n");
+      const result = await this.dispatch(connection, request);
+
+      connection.write(JSON.stringify({ id: request.id, result }) + "\n");
     } catch (err) {
       const code = err instanceof DaemonError ? err.code : "internal";
       const message = err instanceof Error ? err.message : String(err);
-      conn.write(JSON.stringify({ id: req.id, error: { code, message } }) + "\n");
+
+      connection.write(JSON.stringify({ id: request.id, error: { code, message } }) + "\n");
     }
   }
 
-  private async dispatch(conn: Conn, req: Request): Promise<unknown> {
-    // The wire is untrusted JSON: validate before DaemonCore sees anything.
-    if (typeof req.method !== "string" || !isKnownMethod(req.method)) {
-      throw new DaemonError("unknown_method", `unknown method ${String(req.method)}`);
+  private async callAgentTool(threadId: string, name: string, input: string): Promise<string> {
+    const args = parseAgentToolInput(name, input);
+    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] : []);
     }
-    const core = this.core;
-    switch (req.method) {
-      case "daemon.ping":
-        return { pid: process.pid };
-      case "daemon.shutdown":
-        setTimeout(() => {
-          this.stop();
-          this.onIdleExit();
-        }, 10);
-        return {};
-      case "events.subscribe":
-        conn.subscribed = true;
-        return {};
-      case "session.create": {
-        const p = parseParams("session.create", req.params);
-        return core.sessionCreate({ workspace: p.workspace, artifact: p.artifact });
-      }
-      case "session.get":
-        return core.sessionGet(parseParams("session.get", req.params).id);
-      case "session.list":
-        return core.sessionList(parseParams("session.list", req.params).filter);
-      case "session.wait": {
-        const p = parseParams("session.wait", req.params);
-        return core.sessionWait(p.id, p.timeoutMs);
-      }
-      case "session.annotate": {
-        const p = parseParams("session.annotate", req.params);
-        return core.sessionAnnotate(p.id, p.annotation);
-      }
-      case "session.removeAnnotation": {
-        const p = parseParams("session.removeAnnotation", req.params);
-        return core.sessionRemoveAnnotation(p.id, p.annotationId);
+    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;
+
+      return JSON.stringify(
+        this.core.sessionAnnotate(
+          args.id,
+          {
+            id: randomUUID(),
+            kind: "comment",
+            anchor: root.anchor,
+            target: root.target,
+            replyTo: root.id,
+            body: args.body,
+            author: "embedded-agent",
+          },
+          "Agent",
+        ),
+      );
+    }
+    const method = args.method;
+
+    if (!isKnownMethod(method)) throw new Error("Thread agent tool API method is unavailable");
+
+    return JSON.stringify(
+      await this.handlers[method](
+        { role: "owner", subscribed: false, write: () => {} },
+        { id: 0, method, params: args.params },
+      ),
+    );
+  }
+
+  private replyAgentComment(params: {
+    id: string;
+    commentId: string;
+    body: string;
+  }): ReturnType<ThreadAgentManager["reply"]> {
+    this.threadAgent.assertEnabled(params.id);
+
+    return this.threadAgent.reply(params.id, params.commentId, params.body);
+  }
+
+  private readonly handlers: Record<MethodName, MethodHandler> = {
+    "agent.configure": (_connection, request) => {
+      const params = parseParams("agent.configure", request.params);
+
+      this.threadAgent.assertEnabled(params.id);
+
+      return this.threadAgent.configure(params);
+    },
+    "agent.get": (_connection, request) => {
+      const { id } = parseParams("agent.get", request.params);
+
+      this.threadAgent.assertEnabled(id);
+
+      return this.threadAgent.get(id);
+    },
+    "agent.prompt": (_connection, request) => {
+      const params = parseParams("agent.prompt", request.params);
+
+      this.threadAgent.assertEnabled(params.id);
+
+      return this.threadAgent.prompt(params);
+    },
+    "agent.cancel": (_connection, request) => {
+      const { id } = parseParams("agent.cancel", request.params);
+
+      this.threadAgent.assertEnabled(id);
+
+      return this.threadAgent.cancel(id);
+    },
+    "agent.reply": (_connection, request) => {
+      const params = parseParams("agent.reply", request.params);
+
+      return this.replyAgentComment(params);
+    },
+    "agent.comment": (_connection, request) => {
+      const params = parseParams("agent.comment", request.params);
+
+      this.threadAgent.assertEnabled(params.id);
+
+      return this.threadAgent.comment(params);
+    },
+    "agent.permission": (_connection, request) => {
+      const params = parseParams("agent.permission", request.params);
+
+      this.threadAgent.assertEnabled(params.id);
+
+      return this.threadAgent.permission(params);
+    },
+    "daemon.ping": () => ({ pid: process.pid, version: this.version }),
+    "daemon.hello": (connection, request) => {
+      const params = parseParams("daemon.hello", request.params);
+
+      // ownership is proven, never declared: the token lives in the home
+      // directory the daemon serves, readable by its user alone
+      if (params.role === "owner" && params.token !== this.ownerToken) {
+        throw new DaemonError("forbidden", "owner token required");
       }
-      case "session.setWorkingCopy": {
-        const p = parseParams("session.setWorkingCopy", req.params);
-        return core.sessionSetWorkingCopy(p.id, p.workingCopy);
+      if (params.clientVersion !== this.version) {
+        throw new DaemonError(
+          "version_mismatch",
+          `daemon is version ${this.version}, but this client is ${params.clientVersion ?? "unknown"}; align cueloop versions before restarting the daemon`,
+        );
       }
-      case "session.resolve": {
-        const p = parseParams("session.resolve", req.params);
-        return core.sessionResolve(p.id, p.verdictKind, p.summary);
+
+      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;
+
+      return {};
+    },
+    "daemon.shutdown": () => {
+      setTimeout(() => {
+        void this.shutdown()
+          .then(() => this.onIdleExit())
+          .catch((error) => console.error("[agent shutdown]", error));
+      }, 10);
+
+      return {};
+    },
+    "events.subscribe": (connection) => {
+      connection.subscribed = true;
+
+      return {};
+    },
+    "session.create": (_connection, request) => {
+      const params = parseParams("session.create", request.params);
+
+      return this.core.sessionCreate({ workspace: params.workspace, artifact: params.artifact });
+    },
+    "session.get": (_connection, request) =>
+      this.core.sessionGet(parseParams("session.get", request.params).id),
+    "session.list": (_connection, request) =>
+      this.core.sessionList(parseParams("session.list", request.params).filter),
+    "session.wait": (_connection, request) => {
+      const params = parseParams("session.wait", request.params);
+
+      return this.core.sessionWait(params.id, params.timeoutMs);
+    },
+    "session.annotate": (_connection, request) => {
+      const params = parseParams("session.annotate", request.params);
+
+      if (this.threadAgent.isReadOnly(params.id, params.annotation.id))
+        throw new Error("Thread agent submitted comments are read-only");
+
+      return this.core.sessionAnnotate(params.id, params.annotation, params.authorName);
+    },
+    "session.comment": (_connection, request) => {
+      const params = parseParams("session.comment", request.params);
+
+      if (this.threadAgent.isReadOnly(params.id, params.annotation.id))
+        throw new Error("Thread agent submitted comments are read-only");
+
+      return this.core.sessionAnnotate(params.id, params.annotation, params.authorName);
+    },
+    "session.removeAnnotation": (connection, request) => {
+      const params = parseParams("session.removeAnnotation", request.params);
+
+      // the owner removes any comment; a non-owner only the ones of the author it is bound to
+      if (connection.role !== "owner" && connection.author === undefined) {
+        throw new DaemonError(
+          "forbidden",
+          "a non-owner connection removes comments as its bound author",
+        );
       }
-      case "session.submitRevision": {
-        const p = parseParams("session.submitRevision", req.params);
-        return core.sessionSubmitRevision(p.id, p.content);
+
+      if (this.threadAgent.isReadOnly(params.id, params.annotationId))
+        throw new Error("Thread agent submitted comments are read-only");
+
+      return this.core.sessionRemoveAnnotation(
+        params.id,
+        params.annotationId,
+        connection.role === "owner" ? undefined : connection.author,
+      );
+    },
+    "session.setParticipantName": (connection, request) => {
+      const params = parseParams("session.setParticipantName", request.params);
+
+      // the owner names anyone; a non-owner names only the author it is bound to
+      if (connection.role !== "owner" && params.author !== connection.author) {
+        throw new DaemonError("forbidden", "a non-owner connection names only its bound author");
       }
-      default:
-        throw new DaemonError("unknown_method", `unknown method ${req.method}`);
+
+      return this.core.sessionSetParticipantName(params.id, params.author, params.name);
+    },
+    "session.setWorkingCopy": (_connection, request) => {
+      const params = parseParams("session.setWorkingCopy", request.params);
+
+      return this.core.sessionSetWorkingCopy(params.id, params.workingCopy, params.textCuts);
+    },
+    "session.cutBlock": (_connection, request) => {
+      const params = parseParams("session.cutBlock", request.params);
+
+      return this.core.sessionCutBlock(params.id, params.blockIndex);
+    },
+    "session.navigate": (_connection, request) => {
+      const params = parseParams("session.navigate", request.params);
+
+      return this.core.sessionNavigate(params.id, params.entryId, params.summary, params.branch);
+    },
+    "session.branch": (_connection, request) => {
+      const params = parseParams("session.branch", request.params);
+
+      return this.core.sessionBranch(params.id, params.name);
+    },
+    "session.switch": (_connection, request) => {
+      const params = parseParams("session.switch", request.params);
+
+      return this.core.sessionSwitch(params.id, params.branch);
+    },
+    "session.label": (_connection, request) => {
+      const params = parseParams("session.label", request.params);
+
+      return this.core.sessionLabel(params.id, params.label);
+    },
+    "session.fork": (_connection, request) => {
+      const params = parseParams("session.fork", request.params);
+
+      return this.core.sessionFork(params.id);
+    },
+    "session.restoreBlock": (_connection, request) => {
+      const params = parseParams("session.restoreBlock", request.params);
+
+      return this.core.sessionRestoreBlock(params.id, params.baseBlockIndex, params.line);
+    },
+    "session.curate": (_connection, request) => {
+      const params = parseParams("session.curate", request.params);
+
+      return this.core.sessionCurate(params.id, params.rejections);
+    },
+    "session.setViewed": (_connection, request) => {
+      const params = parseParams("session.setViewed", request.params);
+
+      return this.core.sessionSetViewed(params.id, params.viewedPaths);
+    },
+    "session.setTitle": (_connection, request) => {
+      const params = parseParams("session.setTitle", request.params);
+
+      return this.core.sessionSetTitle(params.id, params.title);
+    },
+    "session.projectFiles": (_connection, request) =>
+      this.core.projectFiles(parseParams("session.projectFiles", request.params).id),
+    "session.fileContents": (_connection, request) => {
+      const params = parseParams("session.fileContents", request.params);
+
+      return this.core.fileContents(params.id, params.path);
+    },
+    "repo.files": (_connection, request) =>
+      this.core.repoFiles(parseParams("repo.files", request.params).cwd),
+    "repo.fileContents": (_connection, request) => {
+      const params = parseParams("repo.fileContents", request.params);
+
+      return this.core.repoFileContents(params.cwd, params.path);
+    },
+    "repo.changes": (_connection, request) =>
+      this.core.repoChanges(parseParams("repo.changes", request.params).cwd),
+    "repo.diff": (_connection, request) => {
+      const params = parseParams("repo.diff", request.params);
+
+      return this.core.repoDiff(params.cwd, params.vcs);
+    },
+    "session.workbench": (_connection, request) =>
+      this.core.workbenchSession(parseParams("session.workbench", request.params).cwd),
+    "session.workbenchReview": (_connection, request) =>
+      this.core.workbenchReview(parseParams("session.workbenchReview", request.params).cwd),
+    "session.refreshDiff": (_connection, request) => {
+      const params = parseParams("session.refreshDiff", request.params);
+
+      return this.core.sessionRefreshDiff(params.id);
+    },
+    "session.setShares": (_connection, request) => {
+      const params = parseParams("session.setShares", request.params);
+
+      if (params.shares.some((link) => link.agentEnabled))
+        this.threadAgent.assertEnabled(params.id);
+
+      return this.core.sessionSetShares(params.id, params.shares);
+    },
+    "session.delete": async (_connection, request) => {
+      const { id } = parseParams("session.delete", request.params);
+
+      await this.threadAgent.remove(id);
+      this.core.sessionDelete(id);
+
+      return {};
+    },
+    "session.mergeShared": (_connection, request) => {
+      const params = parseParams("session.mergeShared", request.params);
+
+      return this.core.sessionMergeShared(params.id, {
+        shareId: params.shareId,
+        annotations: params.annotations,
+        participants: params.participants,
+        removals: params.removals,
+      });
+    },
+    "session.sendMessage": (_connection, request) => {
+      const params = parseParams("session.sendMessage", request.params);
+
+      return this.core.sessionSendMessage(
+        params.id,
+        params.outcome,
+        params.summary,
+        params.actionBodies,
+        params.operationId,
+      );
+    },
+    "harness.bind": (_connection, request) => {
+      const params = parseParams("harness.bind", request.params);
+
+      return this.core.harnessBind(params);
+    },
+    "harness.getBinding": (_connection, request) => {
+      const params = parseParams("harness.getBinding", request.params);
+
+      return this.core.harnessGetBinding(params.bindingId);
+    },
+    "harness.bindingsForSession": (_connection, request) => {
+      const params = parseParams("harness.bindingsForSession", request.params);
+
+      return this.core.harnessBindingsForSession(params.harness, params.harnessSessionId);
+    },
+    "harness.consumeApprovedRetry": (_connection, request) => {
+      const params = parseParams("harness.consumeApprovedRetry", request.params);
+
+      return this.core.harnessConsumeApprovedRetry(
+        params.bindingId,
+        params.messageId,
+        params.content,
+      );
+    },
+    "delivery.pending": (_connection, request) => {
+      const params = parseParams("delivery.pending", request.params);
+
+      return this.core.deliveryPending(params.bindingId);
+    },
+    "delivery.acknowledge": (_connection, request) => {
+      const params = parseParams("delivery.acknowledge", request.params);
+
+      return this.core.deliveryAcknowledge(params.deliveryId);
+    },
+    "session.submitRevision": (_connection, request) => {
+      const params = parseParams("session.submitRevision", request.params);
+
+      return this.core.sessionSubmitRevision(
+        params.id,
+        params.content,
+        params.addressedAnnotationIds,
+        params.files,
+        params.source,
+      );
+    },
+    "herdr.getThreadSurface": (_connection, request) =>
+      this.core.herdrGetThreadSurface(parseParams("herdr.getThreadSurface", request.params).id),
+    "herdr.setThreadSurface": (_connection, request) => {
+      const params = parseParams("herdr.setThreadSurface", request.params);
+
+      this.core.herdrSetThreadSurface(params.id, {
+        tabId: params.tabId,
+        paneId: params.paneId,
+        mode: params.mode,
+        layout: params.layout,
+      });
+
+      return {};
+    },
+    "ghostty.getThreadSurface": (_connection, request) =>
+      this.core.ghosttyGetThreadSurface(parseParams("ghostty.getThreadSurface", request.params).id),
+    "ghostty.setThreadSurface": (_connection, request) => {
+      const params = parseParams("ghostty.setThreadSurface", request.params);
+
+      this.core.ghosttySetThreadSurface(params.id, { terminalId: params.terminalId });
+
+      return {};
+    },
+    "ghostty.claimThreadSurface": (_connection, request) =>
+      this.core.ghosttyClaimThreadSurface(
+        parseParams("ghostty.claimThreadSurface", request.params).id,
+      ),
+    "ghostty.releaseThreadSurface": (_connection, request) => {
+      this.core.ghosttyReleaseThreadSurface(
+        parseParams("ghostty.releaseThreadSurface", request.params).id,
+      );
+
+      return {};
+    },
+  };
+
+  private async dispatch(connection: Connection, request: Request): Promise<Response["result"]> {
+    // The wire is untrusted JSON: validate before DaemonCore sees anything.
+    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}`);
+    }
+
+    return this.handlers[request.method](connection, request);
   }
 }