@zooid/context-mcp 0.12.0 → 0.14.0

package/dist/index.js

@@ -1,16 +1,23 @@
 import {
+  SUN_PATH_MAX,
+  agentSocketPath,
   buildContextMcpServer,
   callDaemon,
+  startAgentSocketServers,
   startDaemonSocketServer
-} from "./chunk-ZY2GPHFX.js";
+} from "./chunk-IZ2JCKE4.js";
 
 // src/spawn-registry.ts
 import { randomUUID } from "crypto";
 var SpawnRegistry = class {
   bindings = /* @__PURE__ */ new Map();
+  spawnByAgentSession = /* @__PURE__ */ new Map();
+  spawnByAcpSession = /* @__PURE__ */ new Map();
+  tasks;
   register(input) {
     const spawnId = randomUUID();
     this.bindings.set(spawnId, { spawnId, ...input });
+    this.spawnByAgentSession.set(this.key(input.agentName, input.sessionKey ?? input.threadRef.threadId), spawnId);
     return spawnId;
   }
   get(spawnId) {
@@ -18,6 +25,29 @@ var SpawnRegistry = class {
   }
   release(spawnId) {
     this.bindings.delete(spawnId);
+    for (const [key, value] of this.spawnByAgentSession) {
+      if (value === spawnId) this.spawnByAgentSession.delete(key);
+    }
+    for (const [key, value] of this.spawnByAcpSession) {
+      if (value === spawnId) this.spawnByAcpSession.delete(key);
+    }
+  }
+  linkSession(agentName, sessionKey, acpSessionId) {
+    const spawnId = this.spawnByAgentSession.get(this.key(agentName, sessionKey));
+    if (spawnId) this.spawnByAcpSession.set(acpSessionId, spawnId);
+  }
+  getByAcpSession(acpSessionId) {
+    const spawnId = this.spawnByAcpSession.get(acpSessionId);
+    return spawnId ? this.bindings.get(spawnId) : void 0;
+  }
+  setTaskActions(actions) {
+    this.tasks = actions;
+  }
+  get taskActions() {
+    return this.tasks;
+  }
+  key(agentName, sessionKey) {
+    return `${agentName}::${sessionKey}`;
   }
 };
 
@@ -63,11 +93,14 @@ export {
   CONTEXT_CONTAINER_BIN,
   CONTEXT_CONTAINER_BIN_DIR,
   CONTEXT_CONTAINER_SOCK,
+  SUN_PATH_MAX,
   SpawnRegistry,
+  agentSocketPath,
   buildContextMcpServer,
   buildContextServerSpec,
   callDaemon,
   contextContainerMounts,
+  startAgentSocketServers,
   startDaemonSocketServer
 };
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/spawn-registry.ts","../src/factory.ts"],"sourcesContent":["import { randomUUID } from 'node:crypto'\nimport type { SpawnBinding } from './types.js'\nimport type { TransportContextProvider, ThreadRef } from '@zooid/core'\n\nexport class SpawnRegistry {\n  private readonly bindings = new Map<string, SpawnBinding>()\n\n  register(input: {\n    agentName: string\n    threadRef: ThreadRef\n    provider: TransportContextProvider\n  }): string {\n    const spawnId = randomUUID()\n    this.bindings.set(spawnId, { spawnId, ...input })\n    return spawnId\n  }\n\n  get(spawnId: string): SpawnBinding | undefined {\n    return this.bindings.get(spawnId)\n  }\n\n  release(spawnId: string): void {\n    this.bindings.delete(spawnId)\n  }\n}\n","import { createRequire } from 'node:module'\nimport { dirname } from 'node:path'\nimport type { AcpMount } from '@zooid/core'\nimport type { ZooidContextServerSpec } from './types.js'\n\n/**\n * Resolve `dist/bin.js` via Node's runtime module resolver rather than\n * `import.meta.url`. tsup bundles this file into the CLI's own chunk, so\n * `import.meta.url` at runtime points to the CLI bundle — not this\n * package's dist. `createRequire` walks the runtime `node_modules` tree\n * instead and finds the package wherever it actually lives.\n */\nfunction resolveDefaultBin(): string {\n  const req = createRequire(import.meta.url)\n  // Resolve via the dedicated `./bin` export → `./dist/bin.js`. Avoids the\n  // exports-restriction surprise of importing `./package.json`.\n  return req.resolve('@zooid/context-mcp/bin')\n}\n\nlet cachedDefaultBin: string | null = null\nfunction getDefaultBin(): string {\n  if (!cachedDefaultBin) cachedDefaultBin = resolveDefaultBin()\n  return cachedDefaultBin\n}\n\n/**\n * Fixed container-side paths for the containerized MCP spec. The daemon\n * bind-mounts the host `dist/` here (ro) and the daemon socket here (rw) so\n * opencode can spawn the zooid-context MCP subprocess inside its own container.\n */\nexport const CONTEXT_CONTAINER_BIN_DIR = '/zooid/context-mcp'\nexport const CONTEXT_CONTAINER_BIN = `${CONTEXT_CONTAINER_BIN_DIR}/bin.js`\nexport const CONTEXT_CONTAINER_SOCK = '/zooid/context.sock'\n\n/**\n * The two bind-mounts a containerized, context-enabled agent needs. The bin dir\n * is read-only (self-contained bundle); the socket is read-write (the MCP\n * subprocess connect()s to it). Host sources default to the resolved package\n * dist and the passed daemon socket path.\n */\nexport function contextContainerMounts(opts: {\n  sockPath: string\n  binPath?: string\n}): AcpMount[] {\n  const binFile = opts.binPath ?? getDefaultBin()\n  return [\n    { path: dirname(binFile), target: CONTEXT_CONTAINER_BIN_DIR, mode: 'ro' },\n    { path: opts.sockPath, target: CONTEXT_CONTAINER_SOCK, mode: 'rw' },\n  ]\n}\n\nexport function buildContextServerSpec(opts: {\n  spawnId: string\n  sockPath: string\n  binPath?: string\n  /**\n   * When set, emit a spec that resolves INSIDE the agent container: bare `node`\n   * (image PATH), the bind-mounted bin path, and the bind-mounted socket path.\n   * The host `sockPath`/`binPath` still feed `contextContainerMounts`, but do\n   * not appear in the emitted command. Absent → host-runtime spec (unchanged).\n   */\n  containerize?: boolean\n}): ZooidContextServerSpec {\n  if (opts.containerize) {\n    return {\n      name: 'zooid-context',\n      command: 'node',\n      args: [CONTEXT_CONTAINER_BIN, '--spawn-id', opts.spawnId],\n      env: [{ name: 'ZOOID_DAEMON_SOCK', value: CONTEXT_CONTAINER_SOCK }],\n    }\n  }\n  return {\n    name: 'zooid-context',\n    command: process.execPath,\n    args: [opts.binPath ?? getDefaultBin(), '--spawn-id', opts.spawnId],\n    env: [{ name: 'ZOOID_DAEMON_SOCK', value: opts.sockPath }],\n  }\n}\n"],"mappings":";;;;;;;AAAA,SAAS,kBAAkB;AAIpB,IAAM,gBAAN,MAAoB;AAAA,EACR,WAAW,oBAAI,IAA0B;AAAA,EAE1D,SAAS,OAIE;AACT,UAAM,UAAU,WAAW;AAC3B,SAAK,SAAS,IAAI,SAAS,EAAE,SAAS,GAAG,MAAM,CAAC;AAChD,WAAO;AAAA,EACT;AAAA,EAEA,IAAI,SAA2C;AAC7C,WAAO,KAAK,SAAS,IAAI,OAAO;AAAA,EAClC;AAAA,EAEA,QAAQ,SAAuB;AAC7B,SAAK,SAAS,OAAO,OAAO;AAAA,EAC9B;AACF;;;ACxBA,SAAS,qBAAqB;AAC9B,SAAS,eAAe;AAWxB,SAAS,oBAA4B;AACnC,QAAM,MAAM,cAAc,YAAY,GAAG;AAGzC,SAAO,IAAI,QAAQ,wBAAwB;AAC7C;AAEA,IAAI,mBAAkC;AACtC,SAAS,gBAAwB;AAC/B,MAAI,CAAC,iBAAkB,oBAAmB,kBAAkB;AAC5D,SAAO;AACT;AAOO,IAAM,4BAA4B;AAClC,IAAM,wBAAwB,GAAG,yBAAyB;AAC1D,IAAM,yBAAyB;AAQ/B,SAAS,uBAAuB,MAGxB;AACb,QAAM,UAAU,KAAK,WAAW,cAAc;AAC9C,SAAO;AAAA,IACL,EAAE,MAAM,QAAQ,OAAO,GAAG,QAAQ,2BAA2B,MAAM,KAAK;AAAA,IACxE,EAAE,MAAM,KAAK,UAAU,QAAQ,wBAAwB,MAAM,KAAK;AAAA,EACpE;AACF;AAEO,SAAS,uBAAuB,MAWZ;AACzB,MAAI,KAAK,cAAc;AACrB,WAAO;AAAA,MACL,MAAM;AAAA,MACN,SAAS;AAAA,MACT,MAAM,CAAC,uBAAuB,cAAc,KAAK,OAAO;AAAA,MACxD,KAAK,CAAC,EAAE,MAAM,qBAAqB,OAAO,uBAAuB,CAAC;AAAA,IACpE;AAAA,EACF;AACA,SAAO;AAAA,IACL,MAAM;AAAA,IACN,SAAS,QAAQ;AAAA,IACjB,MAAM,CAAC,KAAK,WAAW,cAAc,GAAG,cAAc,KAAK,OAAO;AAAA,IAClE,KAAK,CAAC,EAAE,MAAM,qBAAqB,OAAO,KAAK,SAAS,CAAC;AAAA,EAC3D;AACF;","names":[]}
+{"version":3,"sources":["../src/spawn-registry.ts","../src/factory.ts"],"sourcesContent":["import { randomUUID } from 'node:crypto'\nimport type { SpawnBinding } from './types.js'\nimport type { TaskActions, TransportContextProvider, ThreadRef } from '@zooid/core'\n\nexport class SpawnRegistry {\n  private readonly bindings = new Map<string, SpawnBinding>()\n  private readonly spawnByAgentSession = new Map<string, string>()\n  private readonly spawnByAcpSession = new Map<string, string>()\n  private tasks: TaskActions | undefined\n\n  register(input: {\n    agentName: string\n    threadRef: ThreadRef\n    provider: TransportContextProvider\n    sessionKey?: string\n  }): string {\n    const spawnId = randomUUID()\n    this.bindings.set(spawnId, { spawnId, ...input })\n    this.spawnByAgentSession.set(this.key(input.agentName, input.sessionKey ?? input.threadRef.threadId), spawnId)\n    return spawnId\n  }\n\n  get(spawnId: string): SpawnBinding | undefined {\n    return this.bindings.get(spawnId)\n  }\n\n  release(spawnId: string): void {\n    this.bindings.delete(spawnId)\n    for (const [key, value] of this.spawnByAgentSession) {\n      if (value === spawnId) this.spawnByAgentSession.delete(key)\n    }\n    for (const [key, value] of this.spawnByAcpSession) {\n      if (value === spawnId) this.spawnByAcpSession.delete(key)\n    }\n  }\n  linkSession(agentName: string, sessionKey: string, acpSessionId: string): void {\n    const spawnId = this.spawnByAgentSession.get(this.key(agentName, sessionKey))\n    if (spawnId) this.spawnByAcpSession.set(acpSessionId, spawnId)\n  }\n  getByAcpSession(acpSessionId: string): SpawnBinding | undefined {\n    const spawnId = this.spawnByAcpSession.get(acpSessionId)\n    return spawnId ? this.bindings.get(spawnId) : undefined\n  }\n  setTaskActions(actions: TaskActions | undefined): void {\n    this.tasks = actions\n  }\n  get taskActions(): TaskActions | undefined {\n    return this.tasks\n  }\n  private key(agentName: string, sessionKey: string): string {\n    return `${agentName}::${sessionKey}`\n  }\n}\n","import { createRequire } from 'node:module'\nimport { dirname } from 'node:path'\nimport type { AcpMount } from '@zooid/core'\nimport type { ZooidContextServerSpec } from './types.js'\n\n/**\n * Resolve `dist/bin.js` via Node's runtime module resolver rather than\n * `import.meta.url`. tsup bundles this file into the CLI's own chunk, so\n * `import.meta.url` at runtime points to the CLI bundle — not this\n * package's dist. `createRequire` walks the runtime `node_modules` tree\n * instead and finds the package wherever it actually lives.\n */\nfunction resolveDefaultBin(): string {\n  const req = createRequire(import.meta.url)\n  // Resolve via the dedicated `./bin` export → `./dist/bin.js`. Avoids the\n  // exports-restriction surprise of importing `./package.json`.\n  return req.resolve('@zooid/context-mcp/bin')\n}\n\nlet cachedDefaultBin: string | null = null\nfunction getDefaultBin(): string {\n  if (!cachedDefaultBin) cachedDefaultBin = resolveDefaultBin()\n  return cachedDefaultBin\n}\n\n/**\n * Fixed container-side paths for the containerized MCP spec. The daemon\n * bind-mounts the host `dist/` here (ro) and the daemon socket here (rw) so\n * opencode can spawn the zooid-context MCP subprocess inside its own container.\n */\nexport const CONTEXT_CONTAINER_BIN_DIR = '/zooid/context-mcp'\nexport const CONTEXT_CONTAINER_BIN = `${CONTEXT_CONTAINER_BIN_DIR}/bin.js`\nexport const CONTEXT_CONTAINER_SOCK = '/zooid/context.sock'\n\n/**\n * The two bind-mounts a containerized, context-enabled agent needs. The bin dir\n * is read-only (self-contained bundle); the socket is read-write (the MCP\n * subprocess connect()s to it). Host sources default to the resolved package\n * dist and the passed daemon socket path.\n */\nexport function contextContainerMounts(opts: {\n  sockPath: string\n  binPath?: string\n}): AcpMount[] {\n  const binFile = opts.binPath ?? getDefaultBin()\n  return [\n    { path: dirname(binFile), target: CONTEXT_CONTAINER_BIN_DIR, mode: 'ro' },\n    { path: opts.sockPath, target: CONTEXT_CONTAINER_SOCK, mode: 'rw' },\n  ]\n}\n\nexport function buildContextServerSpec(opts: {\n  spawnId: string\n  sockPath: string\n  binPath?: string\n  /**\n   * When set, emit a spec that resolves INSIDE the agent container: bare `node`\n   * (image PATH), the bind-mounted bin path, and the bind-mounted socket path.\n   * The host `sockPath`/`binPath` still feed `contextContainerMounts`, but do\n   * not appear in the emitted command. Absent → host-runtime spec (unchanged).\n   */\n  containerize?: boolean\n}): ZooidContextServerSpec {\n  if (opts.containerize) {\n    return {\n      name: 'zooid-context',\n      command: 'node',\n      args: [CONTEXT_CONTAINER_BIN, '--spawn-id', opts.spawnId],\n      env: [{ name: 'ZOOID_DAEMON_SOCK', value: CONTEXT_CONTAINER_SOCK }],\n    }\n  }\n  return {\n    name: 'zooid-context',\n    command: process.execPath,\n    args: [opts.binPath ?? getDefaultBin(), '--spawn-id', opts.spawnId],\n    env: [{ name: 'ZOOID_DAEMON_SOCK', value: opts.sockPath }],\n  }\n}\n"],"mappings":";;;;;;;;;;AAAA,SAAS,kBAAkB;AAIpB,IAAM,gBAAN,MAAoB;AAAA,EACR,WAAW,oBAAI,IAA0B;AAAA,EACzC,sBAAsB,oBAAI,IAAoB;AAAA,EAC9C,oBAAoB,oBAAI,IAAoB;AAAA,EACrD;AAAA,EAER,SAAS,OAKE;AACT,UAAM,UAAU,WAAW;AAC3B,SAAK,SAAS,IAAI,SAAS,EAAE,SAAS,GAAG,MAAM,CAAC;AAChD,SAAK,oBAAoB,IAAI,KAAK,IAAI,MAAM,WAAW,MAAM,cAAc,MAAM,UAAU,QAAQ,GAAG,OAAO;AAC7G,WAAO;AAAA,EACT;AAAA,EAEA,IAAI,SAA2C;AAC7C,WAAO,KAAK,SAAS,IAAI,OAAO;AAAA,EAClC;AAAA,EAEA,QAAQ,SAAuB;AAC7B,SAAK,SAAS,OAAO,OAAO;AAC5B,eAAW,CAAC,KAAK,KAAK,KAAK,KAAK,qBAAqB;AACnD,UAAI,UAAU,QAAS,MAAK,oBAAoB,OAAO,GAAG;AAAA,IAC5D;AACA,eAAW,CAAC,KAAK,KAAK,KAAK,KAAK,mBAAmB;AACjD,UAAI,UAAU,QAAS,MAAK,kBAAkB,OAAO,GAAG;AAAA,IAC1D;AAAA,EACF;AAAA,EACA,YAAY,WAAmB,YAAoB,cAA4B;AAC7E,UAAM,UAAU,KAAK,oBAAoB,IAAI,KAAK,IAAI,WAAW,UAAU,CAAC;AAC5E,QAAI,QAAS,MAAK,kBAAkB,IAAI,cAAc,OAAO;AAAA,EAC/D;AAAA,EACA,gBAAgB,cAAgD;AAC9D,UAAM,UAAU,KAAK,kBAAkB,IAAI,YAAY;AACvD,WAAO,UAAU,KAAK,SAAS,IAAI,OAAO,IAAI;AAAA,EAChD;AAAA,EACA,eAAe,SAAwC;AACrD,SAAK,QAAQ;AAAA,EACf;AAAA,EACA,IAAI,cAAuC;AACzC,WAAO,KAAK;AAAA,EACd;AAAA,EACQ,IAAI,WAAmB,YAA4B;AACzD,WAAO,GAAG,SAAS,KAAK,UAAU;AAAA,EACpC;AACF;;;ACpDA,SAAS,qBAAqB;AAC9B,SAAS,eAAe;AAWxB,SAAS,oBAA4B;AACnC,QAAM,MAAM,cAAc,YAAY,GAAG;AAGzC,SAAO,IAAI,QAAQ,wBAAwB;AAC7C;AAEA,IAAI,mBAAkC;AACtC,SAAS,gBAAwB;AAC/B,MAAI,CAAC,iBAAkB,oBAAmB,kBAAkB;AAC5D,SAAO;AACT;AAOO,IAAM,4BAA4B;AAClC,IAAM,wBAAwB,GAAG,yBAAyB;AAC1D,IAAM,yBAAyB;AAQ/B,SAAS,uBAAuB,MAGxB;AACb,QAAM,UAAU,KAAK,WAAW,cAAc;AAC9C,SAAO;AAAA,IACL,EAAE,MAAM,QAAQ,OAAO,GAAG,QAAQ,2BAA2B,MAAM,KAAK;AAAA,IACxE,EAAE,MAAM,KAAK,UAAU,QAAQ,wBAAwB,MAAM,KAAK;AAAA,EACpE;AACF;AAEO,SAAS,uBAAuB,MAWZ;AACzB,MAAI,KAAK,cAAc;AACrB,WAAO;AAAA,MACL,MAAM;AAAA,MACN,SAAS;AAAA,MACT,MAAM,CAAC,uBAAuB,cAAc,KAAK,OAAO;AAAA,MACxD,KAAK,CAAC,EAAE,MAAM,qBAAqB,OAAO,uBAAuB,CAAC;AAAA,IACpE;AAAA,EACF;AACA,SAAO;AAAA,IACL,MAAM;AAAA,IACN,SAAS,QAAQ;AAAA,IACjB,MAAM,CAAC,KAAK,WAAW,cAAc,GAAG,cAAc,KAAK,OAAO;AAAA,IAClE,KAAK,CAAC,EAAE,MAAM,qBAAqB,OAAO,KAAK,SAAS,CAAC;AAAA,EAC3D;AACF;","names":[]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zooid/context-mcp",
-  "version": "0.12.0",
+  "version": "0.14.0",
   "description": "Daemon-side stdio MCP server + per-spawn registry that exposes zooid_get_history / zooid_get_members / zooid_get_channel_info to ACP shims, backed by each transport's TransportContextProvider.",
   "type": "module",
   "license": "MIT",
@@ -31,7 +31,7 @@
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.0.4",
     "zod": "^3.23.0",
-    "@zooid/core": "^0.12.0"
+    "@zooid/core": "^0.14.0"
   },
   "devDependencies": {
     "@types/node": "^22.0.0",

package/src/bin.ts

@@ -2,7 +2,13 @@
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js'
 import { buildContextMcpServer } from './mcp-server.js'
 import { callDaemon } from './daemon-socket.js'
-import type { TransportContextProvider } from '@zooid/core'
+import type {
+  StartTasksOutput,
+  CompleteTaskOutput,
+  TaskActions,
+  TaskRole,
+  TransportContextProvider,
+} from '@zooid/core'
 
 const spawnIdIdx = process.argv.indexOf('--spawn-id')
 const spawnId = spawnIdIdx >= 0 ? process.argv[spawnIdIdx + 1] : undefined
@@ -35,15 +41,63 @@ const remoteProvider: TransportContextProvider = {
       params: { ...(opts ?? {}), threadId } as Record<string, unknown>,
     }) as Promise<Awaited<ReturnType<TransportContextProvider['getThreadHistory']>>>,
   getChannelMembers: () =>
-    callDaemon(sockPath, { spawnId, method: 'getChannelMembers', params: {} }) as Promise<
-      Awaited<ReturnType<TransportContextProvider['getChannelMembers']>>
-    >,
-  getChannelInfo: () =>
-    callDaemon(sockPath, { spawnId, method: 'getChannelInfo', params: {} }) as Promise<
-      Awaited<ReturnType<TransportContextProvider['getChannelInfo']>>
-    >,
+    callDaemon(sockPath, {
+      spawnId,
+      method: 'getChannelMembers',
+      params: {},
+    }) as Promise<Awaited<ReturnType<TransportContextProvider['getChannelMembers']>>>,
+  getRoomInfo: () =>
+    callDaemon(sockPath, {
+      spawnId,
+      method: 'getRoomInfo',
+      params: {},
+    }) as Promise<Awaited<ReturnType<TransportContextProvider['getRoomInfo']>>>,
+  getRooms: () =>
+    callDaemon(sockPath, {
+      spawnId,
+      method: 'getRooms',
+      params: {},
+    }) as Promise<Awaited<ReturnType<TransportContextProvider['getRooms']>>>,
+  sendMessage: (input) =>
+    callDaemon(sockPath, {
+      spawnId,
+      method: 'sendMessage',
+      params: input as unknown as Record<string, unknown>,
+    }) as Promise<Awaited<ReturnType<TransportContextProvider['sendMessage']>>>,
 }
 
-const server = buildContextMcpServer({ resolve: async () => remoteProvider })
+const remoteTasks: TaskActions = {
+  startTasks: (_caller, input) =>
+    callDaemon(sockPath, {
+      spawnId,
+      method: 'startTasks',
+      params: input as unknown as Record<string, unknown>,
+    }) as Promise<StartTasksOutput>,
+  completeTask: (_caller, input) =>
+    callDaemon(sockPath, {
+      spawnId,
+      method: 'completeTask',
+      params: input as unknown as Record<string, unknown>,
+    }) as Promise<CompleteTaskOutput>,
+  describeRole: () =>
+    callDaemon(sockPath, {
+      spawnId,
+      method: 'describeRole',
+      params: {},
+    }) as Promise<TaskRole>,
+}
+
+// A failed role query yields undefined, which registers neither task tool —
+// the safe direction for MCP: the tools are additive, and a spawn that
+// cannot reach the daemon cannot usefully call them anyway ([[ZOD084]]).
+const role = await callDaemon(sockPath, { spawnId, method: 'describeRole', params: {} })
+  .then((r) => r as TaskRole)
+  .catch(() => undefined)
+
+const server = buildContextMcpServer({
+  resolve: async () => remoteProvider,
+  resolveTasks: async () => remoteTasks,
+  role,
+})
 await server.connect(new StdioServerTransport())
 process.stderr.write(`zooid-context-mcp: ready (spawnId=${spawnId})\n`)

package/src/daemon-socket.test.ts

@@ -2,9 +2,10 @@ import { describe, it, expect, afterEach } from 'vitest'
 import { tmpdir } from 'node:os'
 import { join } from 'node:path'
 import { randomUUID } from 'node:crypto'
+import { createConnection } from 'node:net'
 import { SpawnRegistry } from './spawn-registry.js'
 import { startDaemonSocketServer, callDaemon } from './daemon-socket.js'
-import type { TransportContextProvider } from '@zooid/core'
+import type { TaskActions, TransportContextProvider } from '@zooid/core'
 
 function fakeProvider(over: Partial<TransportContextProvider> = {}): TransportContextProvider {
   return {
@@ -12,7 +13,18 @@ function fakeProvider(over: Partial<TransportContextProvider> = {}): TransportCo
     getRecentThreads: async () => ({ threads: [], has_more: false }),
     getThreadHistory: async () => ({ messages: [], has_more: false }),
     getChannelMembers: async () => [],
-    getChannelInfo: async () => ({ id: 'r', name: 'r', transport: 'matrix' }),
+    getRoomInfo: async () => ({ id: 'r', name: 'r', transport: 'matrix' }),
+    getRooms: async () => [],
+    sendMessage: async () => ({ event_id: '$sent' }),
+    ...over,
+  }
+}
+
+function fakeTasks(over: Partial<TaskActions> = {}): TaskActions {
+  return {
+    startTasks: async () => ({ results: [], notify: 'caller', delivery: 'd' }),
+    completeTask: async () => ({ status: 'recorded' }),
+    describeRole: async () => ({ is_task_assignee: false, can_start_task_threads: true }),
     ...over,
   }
 }
@@ -25,7 +37,7 @@ const defaultProvider = fakeProvider({
     has_more: false,
   }),
   getChannelMembers: async () => [{ id: '@alice:hs', name: 'alice', is_agent: false }],
-  getChannelInfo: async () => ({ id: '!r:hs', name: 'general', transport: 'matrix' }),
+  getRoomInfo: async () => ({ id: '!r:hs', name: 'general', transport: 'matrix' }),
 })
 
 const cleanup: Array<() => Promise<void>> = []
@@ -43,7 +55,7 @@ describe('daemon-socket', () => {
       provider: defaultProvider,
     })
     const sockPath = join(tmpdir(), `zooid-test-${randomUUID()}.sock`)
-    const server = await startDaemonSocketServer({ sockPath, registry })
+    const server = await startDaemonSocketServer({ sockPath, registry, agentName: 'a' })
     cleanup.push(() => server.close())
 
     const res = await callDaemon(sockPath, {
@@ -90,7 +102,7 @@ describe('daemon-socket', () => {
       provider,
     })
     const sockPath = join(tmpdir(), `zooid-test-${randomUUID()}.sock`)
-    const server = await startDaemonSocketServer({ sockPath, registry })
+    const server = await startDaemonSocketServer({ sockPath, registry, agentName: 'a' })
     cleanup.push(() => server.close())
 
     const overview = (await callDaemon(sockPath, {
@@ -111,15 +123,15 @@ describe('daemon-socket', () => {
   it('returns an error envelope for unknown spawn-ids', async () => {
     const registry = new SpawnRegistry()
     const sockPath = join(tmpdir(), `zooid-test-${randomUUID()}.sock`)
-    const server = await startDaemonSocketServer({ sockPath, registry })
+    const server = await startDaemonSocketServer({ sockPath, registry, agentName: 'a' })
     cleanup.push(() => server.close())
 
     await expect(
       callDaemon(sockPath, { spawnId: 'unknown', method: 'getRoomHistory', params: {} }),
-    ).rejects.toThrow(/unknown spawn/i)
+    ).rejects.toThrow(/binding not owned by caller/)
   })
 
-  it('routes getChannelMembers and getChannelInfo', async () => {
+  it('routes getChannelMembers and getRoomInfo', async () => {
     const registry = new SpawnRegistry()
     const spawnId = registry.register({
       agentName: 'a',
@@ -127,13 +139,13 @@ describe('daemon-socket', () => {
       provider: defaultProvider,
     })
     const sockPath = join(tmpdir(), `zooid-test-${randomUUID()}.sock`)
-    const server = await startDaemonSocketServer({ sockPath, registry })
+    const server = await startDaemonSocketServer({ sockPath, registry, agentName: 'a' })
     cleanup.push(() => server.close())
 
     const members = await callDaemon(sockPath, { spawnId, method: 'getChannelMembers', params: {} })
     expect(members).toEqual([{ id: '@alice:hs', name: 'alice', is_agent: false }])
 
-    const info = await callDaemon(sockPath, { spawnId, method: 'getChannelInfo', params: {} })
+    const info = await callDaemon(sockPath, { spawnId, method: 'getRoomInfo', params: {} })
     expect(info).toEqual({ id: '!r:hs', name: 'general', transport: 'matrix' })
   })
 
@@ -143,28 +155,28 @@ describe('daemon-socket', () => {
         messages: [{ id: 'A1', sender: 'alice', text: 'from A', timestamp: 'T', is_agent: false }],
         has_more: false,
       }),
-      getChannelInfo: async () => ({ id: '!a:hs', name: 'room-A', transport: 'matrix' }),
+      getRoomInfo: async () => ({ id: '!a:hs', name: 'room-A', transport: 'matrix' }),
     })
     const providerB = fakeProvider({
       getRoomHistory: async () => ({
         messages: [{ id: 'B1', sender: 'bob', text: 'from B', timestamp: 'T', is_agent: false }],
         has_more: false,
       }),
-      getChannelInfo: async () => ({ id: '!b:hs', name: 'room-B', transport: 'matrix' }),
+      getRoomInfo: async () => ({ id: '!b:hs', name: 'room-B', transport: 'matrix' }),
     })
     const registry = new SpawnRegistry()
     const spawnA = registry.register({
-      agentName: 'architect',
+      agentName: 'a',
       threadRef: { channelId: '!a:hs', threadId: '!a:hs' },
       provider: providerA,
     })
     const spawnB = registry.register({
-      agentName: 'product-owner',
+      agentName: 'a',
       threadRef: { channelId: '!b:hs', threadId: '!b:hs' },
       provider: providerB,
     })
     const sockPath = join(tmpdir(), `zooid-test-${randomUUID()}.sock`)
-    const server = await startDaemonSocketServer({ sockPath, registry })
+    const server = await startDaemonSocketServer({ sockPath, registry, agentName: 'a' })
     cleanup.push(() => server.close())
 
     const [resA, resB] = await Promise.all([
@@ -175,7 +187,7 @@ describe('daemon-socket', () => {
     expect((resA as { messages: Array<{ id: string }> }).messages[0].id).toBe('A1')
     expect((resB as { messages: Array<{ id: string }> }).messages[0].id).toBe('B1')
 
-    const infoB = await callDaemon(sockPath, { spawnId: spawnB, method: 'getChannelInfo', params: {} })
+    const infoB = await callDaemon(sockPath, { spawnId: spawnB, method: 'getRoomInfo', params: {} })
     expect((infoB as { id: string }).id).toBe('!b:hs')
   })
 
@@ -199,12 +211,12 @@ describe('daemon-socket', () => {
       provider: providerA,
     })
     const spawnB = registry.register({
-      agentName: 'b',
+      agentName: 'a',
       threadRef: { channelId: 'b', threadId: 'b' },
       provider: providerB,
     })
     const sockPath = join(tmpdir(), `zooid-test-${randomUUID()}.sock`)
-    const server = await startDaemonSocketServer({ sockPath, registry })
+    const server = await startDaemonSocketServer({ sockPath, registry, agentName: 'a' })
     cleanup.push(() => server.close())
 
     for (let i = 0; i < 20; i++) {
@@ -218,4 +230,152 @@ describe('daemon-socket', () => {
       expect(res.messages[0].id).toBe(expected)
     }
   })
+
+  it('routes describeRole to task actions with the bound caller', async () => {
+    const seen: unknown[] = []
+    const registry = new SpawnRegistry()
+    registry.setTaskActions(
+      fakeTasks({
+        describeRole: async (caller) => {
+          seen.push(caller)
+          return { is_task_assignee: false, can_start_task_threads: true }
+        },
+      }),
+    )
+    const spawnId = registry.register({
+      agentName: 'agent-a',
+      threadRef: { channelId: 'c', threadId: '$root' },
+      provider: defaultProvider,
+    })
+    const sockPath = join(tmpdir(), `zooid-test-${randomUUID()}.sock`)
+    const server = await startDaemonSocketServer({ sockPath, registry, agentName: 'agent-a' })
+    cleanup.push(() => server.close())
+
+    const res = await callDaemon(sockPath, { spawnId, method: 'describeRole', params: {} })
+    expect(res).toEqual({ is_task_assignee: false, can_start_task_threads: true })
+    expect(seen[0]).toMatchObject({ agentName: 'agent-a', threadRoot: '$root' })
+  })
+
+  it('routes sendMessage and getRooms to the provider', async () => {
+    const providerCalls: unknown[] = []
+    const provider = fakeProvider({
+      sendMessage: async (input) => {
+        providerCalls.push({ method: 'sendMessage', input })
+        return { event_id: '$e' }
+      },
+      getRooms: async () => {
+        providerCalls.push({ method: 'getRooms' })
+        return [{ id: '!a:localhost', name: 'general', transport: 'matrix' as const }]
+      },
+    })
+    const registry = new SpawnRegistry()
+    const spawnId = registry.register({
+      agentName: 'a',
+      threadRef: { channelId: 'c', threadId: 't' },
+      provider,
+    })
+    const sockPath = join(tmpdir(), `zooid-test-${randomUUID()}.sock`)
+    const server = await startDaemonSocketServer({ sockPath, registry, agentName: 'a' })
+    cleanup.push(() => server.close())
+
+    await callDaemon(sockPath, {
+      spawnId,
+      method: 'sendMessage',
+      params: { room: '!a:localhost', text: 'noted' },
+    })
+    await callDaemon(sockPath, { spawnId, method: 'getRooms', params: {} })
+    expect(providerCalls).toEqual([
+      { method: 'sendMessage', input: { room: '!a:localhost', text: 'noted' } },
+      { method: 'getRooms' },
+    ])
+  })
+
+  it('refuses sendMessage into a room the caller is not bound to', async () => {
+    const provider = fakeProvider({
+      sendMessage: async () => {
+        throw new Error('not_in_room: this agent is not a member of !elsewhere:localhost')
+      },
+    })
+    const registry = new SpawnRegistry()
+    const spawnId = registry.register({
+      agentName: 'a',
+      threadRef: { channelId: 'c', threadId: 't' },
+      provider,
+    })
+    const sockPath = join(tmpdir(), `zooid-test-${randomUUID()}.sock`)
+    const server = await startDaemonSocketServer({ sockPath, registry, agentName: 'a' })
+    cleanup.push(() => server.close())
+
+    await expect(
+      callDaemon(sockPath, {
+        spawnId,
+        method: 'sendMessage',
+        params: { room: '!elsewhere:localhost', text: 'hi' },
+      }),
+    ).rejects.toThrow(/not_in_room/)
+  })
 })
+
+describe('close()', () => {
+  it('does not hang on a connected client that never disconnects', async () => {
+    // The context-mcp servers spawned beside each agent outlive
+    // AcpClient.stop() (it SIGTERMs the agent and doesn't wait; these are its
+    // grandchildren). net.Server.close() waits for every open connection and,
+    // unlike http.Server, never drops idle ones — so before this was fixed,
+    // `zooid dev` hung on shutdown for as long as those processes lived.
+    const sockPath = join(tmpdir(), `zooid-close-${randomUUID()}.sock`)
+    const registry = new SpawnRegistry()
+    const handle = await startDaemonSocketServer({ sockPath, registry, agentName: 'a' })
+
+    const client = createConnection(sockPath)
+    await new Promise<void>((resolve, reject) => {
+      client.once('connect', () => resolve())
+      client.once('error', reject)
+    })
+
+    const closed = await Promise.race([
+      handle.close().then(() => 'closed' as const),
+      new Promise<'hung'>((resolve) => setTimeout(() => resolve('hung'), 2000)),
+    ])
+    client.destroy()
+    expect(closed).toBe('closed')
+  })
+})
+
+describe('daemon-socket caller identity', () => {
+  it('refuses bindings belonging to another agent through either addressing key', async () => {
+    const registry = new SpawnRegistry()
+    const spawnId = registry.register({
+      agentName: 'alice', threadRef: { channelId: 'c', threadId: 't' }, provider: defaultProvider, sessionKey: 't',
+    })
+    registry.linkSession('alice', 't', 'acp-session-1')
+    const sockPath = join(tmpdir(), `zooid-test-${randomUUID()}.sock`)
+    const server = await startDaemonSocketServer({ sockPath, registry, agentName: 'bob' })
+    cleanup.push(() => server.close())
+
+    await expect(callDaemon(sockPath, { spawnId, method: 'getRoomHistory', params: {} })).rejects.toThrow(NOT_OWNED)
+    await expect(callDaemon(sockPath, { acpSessionId: 'acp-session-1', method: 'getChannelMembers', params: {} })).rejects.toThrow(NOT_OWNED)
+  })
+
+  it('serves its owner and makes unknown and unowned ids indistinguishable', async () => {
+    const registry = new SpawnRegistry()
+    const spawnId = registry.register({
+      agentName: 'alice', threadRef: { channelId: 'c', threadId: 't' }, provider: defaultProvider,
+    })
+    const alicePath = join(tmpdir(), `zooid-test-${randomUUID()}.sock`)
+    const bobPath = join(tmpdir(), `zooid-test-${randomUUID()}.sock`)
+    const alice = await startDaemonSocketServer({ sockPath: alicePath, registry, agentName: 'alice' })
+    const bob = await startDaemonSocketServer({ sockPath: bobPath, registry, agentName: 'bob' })
+    cleanup.push(() => alice.close())
+    cleanup.push(() => bob.close())
+
+    await expect(callDaemon(alicePath, { spawnId, method: 'getChannelMembers', params: {} })).resolves.toEqual([
+      { id: '@alice:hs', name: 'alice', is_agent: false },
+    ])
+    const unowned = await callDaemon(bobPath, { spawnId, method: 'getRoomInfo', params: {} }).catch((e: Error) => e.message)
+    const unknown = await callDaemon(bobPath, { acpSessionId: 'no-such-session', method: 'getRoomInfo', params: {} }).catch((e: Error) => e.message)
+    expect(unowned).toBe(unknown)
+  })
+})
+
+const NOT_OWNED = 'binding not owned by caller'