@openvole/volenet-mcp 0.1.0 → 0.2.0

package/dist/index.js

@@ -1,25 +1,44 @@
 #!/usr/bin/env node
-
-// src/index.ts
-import { Server } from "@modelcontextprotocol/sdk/server/index.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
-
-// src/cli.ts
-import * as path4 from "path";
-import { loadKeyPair } from "@openvole/volenet";
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res, err) => function __init() {
+  if (err) throw err[0];
+  try {
+    return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+  } catch (e) {
+    throw err = [e], e;
+  }
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
 
 // src/config.ts
+var config_exports = {};
+__export(config_exports, {
+  defaultDir: () => defaultDir,
+  defaultName: () => defaultName,
+  loadStored: () => loadStored,
+  resolveSettings: () => resolveSettings,
+  saveStored: () => saveStored,
+  sessionKey: () => sessionKey
+});
+import * as crypto from "crypto";
 import * as fs from "fs/promises";
 import * as os from "os";
 import * as path from "path";
+function sessionKey(cwd = process.cwd()) {
+  const hash = crypto.createHash("sha256").update(cwd).digest("hex").slice(0, 8);
+  const base = (cwd.split("/").filter(Boolean).pop() ?? "session").toLowerCase().replace(/[^a-z0-9._-]+/g, "-").slice(0, 40);
+  return `${base}-${hash}`;
+}
 function defaultDir() {
   return process.env.VOLENET_MCP_DIR?.trim() || path.join(os.homedir(), ".openvole", "volenet-mcp");
 }
 function defaultName() {
   return `claude-${os.hostname().split(".")[0].toLowerCase()}`;
 }
-var file = (dir) => path.join(dir, "config.json");
 async function loadStored(dir) {
   try {
     const raw = JSON.parse(await fs.readFile(file(dir), "utf-8"));
@@ -46,92 +65,645 @@ async function resolveSettings() {
     name: process.env.VOLENET_MCP_NAME?.trim() || stored.name || defaultName(),
     hub: process.env.VOLENET_MCP_HUB?.trim() || stored.hub || void 0,
     dir,
-    port: (Number.isFinite(envPort) && envPort > 0 ? envPort : stored.port) || 9750
+    port: (Number.isFinite(envPort) && envPort > 0 ? envPort : stored.port) || 9750,
+    session: process.env.VOLENET_MCP_SESSION?.trim() || sessionKey()
   };
 }
+var file;
+var init_config = __esm({
+  "src/config.ts"() {
+    "use strict";
+    file = (dir) => path.join(dir, "config.json");
+  }
+});
 
 // src/inbox.ts
 import * as fs2 from "fs/promises";
 import * as path2 from "path";
-var MAX_MESSAGES = 2e3;
-var Inbox = class {
-  constructor(file2) {
-    this.file = file2;
-  }
-  file;
-  messages = [];
-  /** Per peer, the timestamp up to which the session has been shown its messages. */
-  readAt = /* @__PURE__ */ new Map();
-  writing = Promise.resolve();
-  async load() {
+async function readLog(file2) {
+  let body;
+  try {
+    body = await fs2.readFile(file2, "utf-8");
+  } catch {
+    return [];
+  }
+  const out = [];
+  for (const line of body.split("\n")) {
+    if (!line.trim()) continue;
     try {
-      const raw = JSON.parse(await fs2.readFile(this.file, "utf-8"));
-      this.messages = (raw.messages ?? []).filter(
-        (m) => m && typeof m.peerId === "string" && typeof m.text === "string"
+      const m = JSON.parse(line);
+      if (m && typeof m.peerId === "string" && typeof m.text === "string") out.push(m);
+    } catch {
+    }
+  }
+  return out;
+}
+var MAX_MESSAGES, Inbox;
+var init_inbox = __esm({
+  "src/inbox.ts"() {
+    "use strict";
+    MAX_MESSAGES = 2e3;
+    Inbox = class {
+      /**
+       * @param dir   where the shared log and the cursors live
+       * @param session  which read state is ours. Sessions in different projects are different
+       *                 readers; the same project reopened is the same reader, so restarting does
+       *                 not replay everything already seen.
+       */
+      constructor(dir, session = "default") {
+        this.dir = dir;
+        this.session = session;
+      }
+      dir;
+      session;
+      messages = [];
+      /** Per peer, the timestamp up to which *this* session has been shown its messages. */
+      readAt = /* @__PURE__ */ new Map();
+      writing = Promise.resolve();
+      get log() {
+        return path2.join(this.dir, "messages.jsonl");
+      }
+      get cursor() {
+        return path2.join(this.dir, "cursors", `${this.session}.json`);
+      }
+      async load() {
+        await this.adoptLegacy();
+        this.messages = await readLog(this.log);
+        try {
+          const raw = JSON.parse(await fs2.readFile(this.cursor, "utf-8"));
+          this.readAt = new Map(Object.entries(raw ?? {}));
+        } catch {
+          this.readAt = /* @__PURE__ */ new Map();
+        }
+      }
+      /** Re-read what other sessions have appended since we loaded. */
+      async refresh() {
+        this.messages = await readLog(this.log);
+      }
+      /** Record a message. Returns false when this id was already recorded. */
+      async add(m) {
+        await this.refresh();
+        if (this.messages.some((x) => x.id === m.id)) return false;
+        this.messages.push(m);
+        await this.append(m);
+        return true;
+      }
+      /** Everything with one peer, oldest first. */
+      history(peerId, limit = 50) {
+        return this.messages.filter((m) => m.peerId === peerId).slice(-limit);
+      }
+      /** Inbound messages this session has not been shown yet, oldest first. */
+      unread() {
+        return this.messages.filter((m) => m.dir === "in" && m.ts > (this.readAt.get(m.peerId) ?? 0));
+      }
+      /** Mark everything currently unread as seen — for this session, and nobody else. */
+      async markRead() {
+        for (const m of this.unread()) {
+          const at = this.readAt.get(m.peerId) ?? 0;
+          if (m.ts > at) this.readAt.set(m.peerId, m.ts);
+        }
+        await this.persistCursor();
+      }
+      /** Every peer we have said anything to or heard anything from, most recent first. */
+      peers() {
+        const by = /* @__PURE__ */ new Map();
+        for (const m of this.messages) {
+          const e = by.get(m.peerId) ?? { peerId: m.peerId, peerName: m.peerName, last: 0, unread: 0 };
+          if (m.peerName) e.peerName = m.peerName;
+          e.last = Math.max(e.last, m.ts);
+          if (m.dir === "in" && m.ts > (this.readAt.get(m.peerId) ?? 0)) e.unread++;
+          by.set(m.peerId, e);
+        }
+        return [...by.values()].sort((a, b) => b.last - a.last);
+      }
+      get size() {
+        return this.messages.length;
+      }
+      /** One line, one write — an append no other session can lose. */
+      append(m) {
+        this.writing = this.writing.then(async () => {
+          await fs2.mkdir(this.dir, { recursive: true });
+          await fs2.appendFile(this.log, `${JSON.stringify(m)}
+`, "utf-8");
+          if (this.messages.length > MAX_MESSAGES) await this.compact();
+        });
+        return this.writing;
+      }
+      /** Rewrite the log with the newest MAX_MESSAGES. Rare, and atomic via rename. */
+      async compact() {
+        const keep = this.messages.slice(-MAX_MESSAGES);
+        const tmp = `${this.log}.${process.pid}.tmp`;
+        await fs2.writeFile(tmp, keep.map((m) => `${JSON.stringify(m)}
+`).join(""), "utf-8");
+        await fs2.rename(tmp, this.log);
+        this.messages = keep;
+      }
+      async persistCursor() {
+        await fs2.mkdir(path2.dirname(this.cursor), { recursive: true });
+        const tmp = `${this.cursor}.tmp`;
+        await fs2.writeFile(tmp, JSON.stringify(Object.fromEntries(this.readAt), null, 2), "utf-8");
+        await fs2.rename(tmp, this.cursor);
+      }
+      /**
+       * Carry over messages written before the log existed.
+       *
+       * Earlier versions kept one `inbox.json` holding both the messages and a single read state. The
+       * messages are still someone's; dropping them on upgrade would lose real conversations. The old
+       * read state is deliberately *not* carried over — it was one cursor for every session, so honouring
+       * it would mark messages seen for sessions that never saw them. Unread is the safe direction.
+       */
+      async adoptLegacy() {
+        const legacy = path2.join(this.dir, "inbox.json");
+        try {
+          await fs2.access(this.log);
+          return;
+        } catch {
+        }
+        let raw;
+        try {
+          raw = JSON.parse(await fs2.readFile(legacy, "utf-8"));
+        } catch {
+          return;
+        }
+        const messages = (raw.messages ?? []).filter(
+          (m) => m && typeof m.peerId === "string" && typeof m.text === "string"
+        );
+        if (messages.length === 0) return;
+        await fs2.mkdir(this.dir, { recursive: true });
+        await fs2.writeFile(this.log, messages.map((m) => `${JSON.stringify(m)}
+`).join(""), "utf-8");
+        await fs2.rename(legacy, `${legacy}.migrated`);
+      }
+    };
+  }
+});
+
+// src/net-api.ts
+function localNet(m) {
+  return {
+    async identity() {
+      const k = m.getKeyPair();
+      return k ? { instanceId: k.instanceId, publicKeyString: k.publicKeyString } : null;
+    },
+    async instances() {
+      const live = new Set(
+        (m.getTransport()?.getPeers() ?? []).filter((p) => p.connected).map((p) => p.peerId)
       );
-      this.readAt = new Map(Object.entries(raw.readAt ?? {}));
+      return m.getInstances().map((i) => ({ id: i.id, name: i.name, connected: live.has(i.id) }));
+    },
+    async relayMembers() {
+      return m.getRelayMembers().map((r) => ({
+        id: r.id,
+        name: r.name,
+        viaHubName: r.viaHubName,
+        connected: r.connected,
+        accepted: r.accepted,
+        incoming: r.incoming,
+        awaiting: r.awaiting
+      }));
+    },
+    sendChat: (to, text) => m.sendChat(to, text),
+    async askBrain(to, input, fromName, timeoutMs) {
+      const mgr = m.getRemoteTaskManager();
+      if (!mgr) return { status: "failed", error: "remote task manager not available" };
+      const r = await mgr.delegateTask(to, { taskId: "", input, fromName }, timeoutMs);
+      return { status: r.status, result: r.result, error: r.error };
+    },
+    joinHub: (url) => m.initiateJoin(url),
+    addPeer: (url) => m.addPeer(url),
+    async forgetPeer(url) {
+      return m.forgetPeer(url);
+    },
+    probePair: (url) => m.probePair(url),
+    initiatePair: (url, publicKey, note, wants) => m.initiatePair(url, publicKey, note, wants),
+    requestRelayConnect: (ref, note) => m.requestRelayConnect(ref, note),
+    approveRelayConnect: (ref) => m.approveRelayConnect(ref),
+    denyRelayConnect: (ref) => m.denyRelayConnect(ref),
+    async listPairRequests() {
+      return m.listPairRequests().map((r) => ({
+        id: r.id,
+        name: r.name,
+        note: r.note,
+        wants: r.wants
+      }));
+    },
+    async rooms() {
+      return m.getRooms().map((r) => ({
+        room: r.room,
+        name: r.name,
+        topic: r.topic,
+        members: r.members.map((x) => ({ instanceId: x.instanceId, name: x.name }))
+      }));
+    },
+    roomCommand: (hub, type, payload) => m.roomCommand(hub, type, payload),
+    postToRoom: (room, text) => m.postToRoom(room, text),
+    acceptPair: (ref, grant) => m.acceptPair(ref, grant),
+    denyPair: (ref) => m.denyPair(ref)
+  };
+}
+var NET_METHODS;
+var init_net_api = __esm({
+  "src/net-api.ts"() {
+    "use strict";
+    NET_METHODS = [
+      "identity",
+      "instances",
+      "relayMembers",
+      "sendChat",
+      "askBrain",
+      "joinHub",
+      "addPeer",
+      "forgetPeer",
+      "probePair",
+      "initiatePair",
+      "requestRelayConnect",
+      "approveRelayConnect",
+      "denyRelayConnect",
+      "rooms",
+      "roomCommand",
+      "postToRoom",
+      "listPairRequests",
+      "acceptPair",
+      "denyPair"
+    ];
+  }
+});
+
+// src/daemon.ts
+import { spawn } from "child_process";
+import * as fs3 from "fs/promises";
+import * as net from "net";
+import * as path4 from "path";
+async function serve(dir, node) {
+  const sock = socketPath(dir);
+  await fs3.mkdir(dir, { recursive: true });
+  await fs3.rm(sock, { force: true });
+  const server = net.createServer((conn) => {
+    let buffer = "";
+    conn.setEncoding("utf-8");
+    conn.on("data", (chunk) => {
+      buffer += chunk;
+      for (let nl = buffer.indexOf("\n"); nl >= 0; nl = buffer.indexOf("\n")) {
+        const line = buffer.slice(0, nl);
+        buffer = buffer.slice(nl + 1);
+        if (line.trim()) void handle(line, conn, node);
+      }
+    });
+    conn.on("error", () => void 0);
+  });
+  server.on("error", () => void 0);
+  await new Promise((done) => server.listen(sock, done));
+  return server;
+}
+async function handle(line, conn, node) {
+  let req;
+  try {
+    req = JSON.parse(line);
+  } catch {
+    return;
+  }
+  const reply = (r) => {
+    try {
+      conn.write(`${JSON.stringify({ id: req.id, ...r })}
+`);
     } catch {
-      this.messages = [];
-      this.readAt = /* @__PURE__ */ new Map();
     }
+  };
+  if (!NET_METHODS.includes(req.method)) {
+    reply({ ok: false, error: `unknown method: ${req.method}` });
+    return;
+  }
+  try {
+    const fn = node[req.method];
+    reply({ ok: true, result: await fn(...req.args ?? []) });
+  } catch (err) {
+    reply({ ok: false, error: err instanceof Error ? err.message : String(err) });
   }
-  /** Record a message. Returns false when this id was already recorded. */
-  async add(m) {
-    if (this.messages.some((x) => x.id === m.id)) return false;
-    this.messages.push(m);
-    if (this.messages.length > MAX_MESSAGES) {
-      this.messages.splice(0, this.messages.length - MAX_MESSAGES);
+}
+function remoteNet(conn) {
+  let next = 1;
+  const pending = /* @__PURE__ */ new Map();
+  let buffer = "";
+  conn.setEncoding("utf-8");
+  conn.on("data", (chunk) => {
+    buffer += chunk;
+    for (let nl = buffer.indexOf("\n"); nl >= 0; nl = buffer.indexOf("\n")) {
+      const line = buffer.slice(0, nl);
+      buffer = buffer.slice(nl + 1);
+      if (!line.trim()) continue;
+      try {
+        const res = JSON.parse(line);
+        const waiter = pending.get(res.id);
+        if (!waiter) continue;
+        pending.delete(res.id);
+        if (res.ok) waiter.resolve(res.result);
+        else waiter.reject(new Error(res.error ?? "daemon error"));
+      } catch {
+      }
     }
-    await this.persist();
-    return true;
-  }
-  /** Everything with one peer, oldest first. */
-  history(peerId, limit = 50) {
-    return this.messages.filter((m) => m.peerId === peerId).slice(-limit);
-  }
-  /** Inbound messages the session has not been shown yet, oldest first. */
-  unread() {
-    return this.messages.filter((m) => m.dir === "in" && m.ts > (this.readAt.get(m.peerId) ?? 0));
-  }
-  /** Mark everything currently unread as seen. */
-  async markRead() {
-    for (const m of this.unread()) {
-      const at = this.readAt.get(m.peerId) ?? 0;
-      if (m.ts > at) this.readAt.set(m.peerId, m.ts);
+  });
+  const fail = (why) => {
+    for (const [, w] of pending) w.reject(new Error(why));
+    pending.clear();
+  };
+  conn.on("close", () => fail("the volenet daemon closed the connection"));
+  conn.on("error", (e) => fail(e.message));
+  const call = (method, ...args) => new Promise((resolve2, reject) => {
+    const id = next++;
+    pending.set(id, { resolve: resolve2, reject });
+    conn.write(`${JSON.stringify({ id, method, args })}
+`);
+  });
+  return Object.fromEntries(
+    NET_METHODS.map((m) => [m, (...args) => call(m, ...args)])
+  );
+}
+async function connect(dir) {
+  return new Promise((resolve2) => {
+    const conn = net.createConnection(socketPath(dir));
+    const give = (ok) => {
+      conn.removeAllListeners("connect");
+      conn.removeAllListeners("error");
+      if (ok) resolve2(conn);
+      else {
+        conn.destroy();
+        resolve2(null);
+      }
+    };
+    conn.once("connect", () => give(true));
+    conn.once("error", () => give(false));
+  });
+}
+async function spawnDaemon(dir, env = {}) {
+  const entry = process.argv[1];
+  if (!entry) return null;
+  const child = spawn(process.execPath, [entry, "daemon"], {
+    detached: true,
+    stdio: "ignore",
+    env: { ...process.env, ...env, VOLENET_MCP_DIR: dir }
+  });
+  child.unref();
+  for (let i = 0; i < 40; i++) {
+    const conn = await connect(dir);
+    if (conn) return conn;
+    await new Promise((r) => setTimeout(r, 100));
+  }
+  return null;
+}
+var socketPath;
+var init_daemon = __esm({
+  "src/daemon.ts"() {
+    "use strict";
+    init_net_api();
+    socketPath = (dir) => path4.join(dir, "daemon.sock");
+  }
+});
+
+// src/notify.ts
+import { spawn as spawn2 } from "child_process";
+function run(command, args) {
+  try {
+    const child = spawn2(command, args, { stdio: "ignore", detached: true });
+    child.on("error", () => void 0);
+    child.unref();
+  } catch {
+  }
+}
+function notifier(platform = process.platform) {
+  const setting = process.env.VOLENET_MCP_NOTIFY?.trim();
+  if (setting === "off") return () => void 0;
+  if (setting) return (title, body) => run(setting, [title, body]);
+  if (platform === "darwin") {
+    return (title, body) => run("osascript", [
+      "-e",
+      `display notification "${applescript(body)}" with title "${applescript(title)}"`
+    ]);
+  }
+  if (platform === "linux") return (title, body) => run("notify-send", [title, body]);
+  if (platform === "win32") {
+    return (title, body) => run("powershell", [
+      "-NoProfile",
+      "-Command",
+      `[System.Reflection.Assembly]::LoadWithPartialName('System.Windows.Forms');$n=New-Object System.Windows.Forms.NotifyIcon;$n.Icon=[System.Drawing.SystemIcons]::Information;$n.Visible=$true;$n.ShowBalloonTip(5000,'${title.replace(/'/g, "''")}','${body.replace(/'/g, "''")}',0)`
+    ]);
+  }
+  return () => void 0;
+}
+function preview(text, limit = 140) {
+  const flat = text.replace(/\s+/g, " ").trim();
+  return flat.length > limit ? `${flat.slice(0, limit - 1)}\u2026` : flat;
+}
+var applescript;
+var init_notify = __esm({
+  "src/notify.ts"() {
+    "use strict";
+    applescript = (s) => s.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+  }
+});
+
+// src/node.ts
+var node_exports = {};
+__export(node_exports, {
+  alreadyTrusts: () => alreadyTrusts,
+  resolveSettings: () => resolveSettings,
+  runDaemon: () => runDaemon,
+  startLocal: () => startLocal,
+  startNode: () => startNode
+});
+import * as fsSync from "fs";
+import * as path5 from "path";
+import {
+  VoleNetManager,
+  createEventBus,
+  loadAuthorizedVoles,
+  parsePublicKey
+} from "@openvole/volenet";
+async function startNode(options) {
+  const inbox = new Inbox(options.dir, options.session);
+  await inbox.load();
+  if (process.env.VOLENET_MCP_NO_DAEMON !== "1") {
+    const conn = await connect(options.dir) ?? await spawnDaemon(options.dir);
+    if (conn) {
+      return {
+        net: remoteNet(conn),
+        inbox,
+        requests: [],
+        notices: [],
+        options,
+        hubStatus: options.hub ? `joined ${options.hub}` : "no hub configured",
+        canSample: false,
+        where: "daemon",
+        onMessage: watchLog(options.dir, inbox),
+        stop: async () => {
+          conn.destroy();
+        }
+      };
     }
-    await this.persist();
-  }
-  /** Every peer we have said anything to or heard anything from, most recent first. */
-  peers() {
-    const by = /* @__PURE__ */ new Map();
-    for (const m of this.messages) {
-      const e = by.get(m.peerId) ?? { peerId: m.peerId, peerName: m.peerName, last: 0, unread: 0 };
-      if (m.peerName) e.peerName = m.peerName;
-      e.last = Math.max(e.last, m.ts);
-      if (m.dir === "in" && m.ts > (this.readAt.get(m.peerId) ?? 0)) e.unread++;
-      by.set(m.peerId, e);
+  }
+  const local = await startLocal(options, inbox);
+  return { ...local, where: "in-process" };
+}
+async function startLocal(options, inbox, notify) {
+  const bus = createEventBus();
+  const requests = [];
+  const notices = [];
+  const listeners = /* @__PURE__ */ new Set();
+  const port = await isFree(options.port) ? options.port : 0;
+  const manager = new VoleNetManager(
+    {
+      enabled: true,
+      instanceName: options.name,
+      role: "peer",
+      port,
+      keyPath: path5.join(options.dir, "net", "vole_key"),
+      // A hub is a peer we dial. 'read' rather than 'full': a hub carries our sealed traffic,
+      // it has no business acting on this node.
+      peers: options.hub ? [{ url: options.hub, trust: "read" }] : []
+    },
+    options.dir
+  );
+  bus.on("volenet:chat", (d) => {
+    const m = d;
+    const message = {
+      peerId: m.from,
+      peerName: m.fromName,
+      dir: "in",
+      text: m.text,
+      ts: m.timestamp,
+      id: m.messageId
+    };
+    void inbox.add(message).then((added) => {
+      if (!added) return;
+      for (const fn of listeners) fn(message);
+      notify?.(`${message.peerName} on VoleNet`, preview(message.text));
+    });
+  });
+  bus.on("volenet:chat:pending", (d) => {
+    const p = d;
+    for (const n of p.from ?? []) {
+      const at = notices.findIndex((x) => x.from === n.from);
+      if (at >= 0) notices[at] = n;
+      else notices.push(n);
     }
-    return [...by.values()].sort((a, b) => b.last - a.last);
-  }
-  get size() {
-    return this.messages.length;
-  }
-  /** Serialised: two messages arriving together must not race each other's rewrite. */
-  persist() {
-    this.writing = this.writing.then(async () => {
-      const body = JSON.stringify(
-        { messages: this.messages, readAt: Object.fromEntries(this.readAt) },
-        null,
-        2
-      );
-      await fs2.mkdir(path2.dirname(this.file), { recursive: true });
-      const tmp = `${this.file}.tmp`;
-      await fs2.writeFile(tmp, body, "utf-8");
-      await fs2.rename(tmp, this.file);
+  });
+  const remember = (kind) => (d) => {
+    const r = d;
+    if (requests.some((x) => x.from === r.from && x.kind === kind)) return;
+    requests.push({ kind, from: r.from, fromName: r.fromName, note: r.note, at: Date.now() });
+  };
+  bus.on("volenet:pair:request", remember("pair"));
+  bus.on("volenet:relay:request", remember("relay"));
+  await manager.start(void 0, bus);
+  const bound = manager.getTransport()?.getPort?.() ?? port;
+  const settings = { ...options, port: bound || options.port };
+  let hubStatus = "no hub configured";
+  if (options.hub) {
+    hubStatus = await alreadyTrusts(options.dir, options.hub) ? `joined ${options.hub}` : await join5(manager, options.hub);
+  }
+  return {
+    net: localNet(manager),
+    inbox,
+    requests,
+    notices,
+    options: settings,
+    hubStatus,
+    canSample: false,
+    onMessage: (fn) => {
+      listeners.add(fn);
+      return () => listeners.delete(fn);
+    },
+    stop: () => manager.stop()
+  };
+}
+async function runDaemon(options) {
+  const inbox = new Inbox(options.dir, "daemon");
+  await inbox.load();
+  const node = await startLocal(options, inbox, notifier());
+  await serve(options.dir, node.net);
+  await new Promise(() => void 0);
+}
+function watchLog(dir, inbox) {
+  return (fn) => {
+    const file2 = path5.join(dir, "messages.jsonl");
+    const seen = new Set(inbox.history("", 0).map((m) => m.id));
+    let closed = false;
+    const check = async () => {
+      if (closed) return;
+      const before = new Set(inbox.unread().map((m) => m.id));
+      await inbox.refresh();
+      for (const m of inbox.unread()) {
+        if (!before.has(m.id) && !seen.has(m.id)) {
+          seen.add(m.id);
+          fn(m);
+        }
+      }
+    };
+    let watcher;
+    try {
+      watcher = fsSync.watch(path5.dirname(file2), (_e, name) => {
+        if (name === "messages.jsonl") void check();
+      });
+    } catch {
+    }
+    const timer = setInterval(() => void check(), 1e3);
+    return () => {
+      closed = true;
+      clearInterval(timer);
+      watcher?.close();
+    };
+  };
+}
+async function join5(node, hub) {
+  const res = await node.initiateJoin(hub);
+  if (!res.ok) return `could not join ${hub}: ${res.error}`;
+  if (res.pending) return `waiting for approval at ${hub}`;
+  return `joined ${res.hubName ?? hub}`;
+}
+async function alreadyTrusts(dir, hub) {
+  try {
+    const r = await fetch(`${hub.replace(/\/$/, "")}/volenet/info`, {
+      signal: AbortSignal.timeout(8e3)
     });
-    return this.writing;
+    const info = await r.json();
+    const parsed = info.publicKey ? parsePublicKey(info.publicKey) : null;
+    if (!parsed) return false;
+    return (await loadAuthorizedVoles(path5.join(dir, "net"))).has(parsed.instanceId);
+  } catch {
+    return false;
   }
-};
+}
+async function isFree(port) {
+  const netmod = await import("net");
+  return new Promise((resolve2) => {
+    const probe = netmod.createServer().once("error", () => resolve2(false)).once("listening", () => probe.close(() => resolve2(true))).listen(port, "0.0.0.0");
+  });
+}
+var init_node = __esm({
+  "src/node.ts"() {
+    "use strict";
+    init_config();
+    init_daemon();
+    init_inbox();
+    init_net_api();
+    init_notify();
+  }
+});
+
+// src/index.ts
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import {
+  CallToolRequestSchema,
+  GetPromptRequestSchema,
+  ListPromptsRequestSchema,
+  ListToolsRequestSchema
+} from "@modelcontextprotocol/sdk/types.js";
+
+// src/cli.ts
+init_config();
+init_inbox();
+import * as path6 from "path";
+import { loadKeyPair } from "@openvole/volenet";
 
 // src/install.ts
 import { spawnSync } from "child_process";
@@ -147,15 +719,15 @@ function addArgs(scope, command) {
 }
 var NEXT_STEPS = '\nRestart Claude Code \u2014 MCP servers load at startup \u2014 then:\n\n  volenet_whoami             who you are on the mesh (an identity is made on first run)\n  volenet_hub url:"..."      join a hub, to be reachable from anywhere\n  volenet_connect url:"..."  or pair directly with an agent you can dial\n\nNothing else needs configuring.\n';
 function install(argv, out = process.stdout) {
-  const scope = argv.includes("--user") ? "user" : "local";
+  const scope = argv.includes("--local") ? "local" : "user";
   const command = launchCommand();
   const paste = `claude mcp add ${SERVER_NAME} -s ${scope} -- ${command.join(" ")}`;
-  const run2 = (args) => spawnSync("claude", args, {
+  const run3 = (args) => spawnSync("claude", args, {
     stdio: ["ignore", "pipe", "pipe"],
     encoding: "utf-8",
     timeout: 3e4
   });
-  const listed = run2(["mcp", "list"]);
+  const listed = run3(["mcp", "list"]);
   if (listed.error) {
     out.write(
       `The \`claude\` CLI is not on PATH. Run this once, in the project you want it in:
@@ -171,7 +743,7 @@ function install(argv, out = process.stdout) {
 ${NEXT_STEPS}`);
     return 0;
   }
-  const added = run2(addArgs(scope, command));
+  const added = run3(addArgs(scope, command));
   if (added.status !== 0) {
     out.write(
       `Could not register it automatically${added.stderr ? `: ${added.stderr.trim()}` : ""}
@@ -184,25 +756,30 @@ Run this once instead:
     );
     return added.status ?? 1;
   }
-  out.write(`Registered ${SERVER_NAME} (${scope} scope).
-${NEXT_STEPS}`);
+  out.write(
+    `Registered ${SERVER_NAME} (${scope} scope${scope === "user" ? " \u2014 available in every project" : ", this project only"}).
+${NEXT_STEPS}`
+  );
   return 0;
 }
 
 // src/cli.ts
 var USAGE = `volenet-mcp \u2014 VoleNet as an MCP server
 
-  volenet-mcp install [--user]     register with Claude Code (default: this project)
+  volenet-mcp install [--local]    register with Claude Code (default: every project)
   volenet-mcp whoami               this machine's identity on the mesh
+  volenet-mcp daemon               run the node in the foreground (normally started for you)
   volenet-mcp hub [url|--leave]    which hub to use; takes effect on the next session
-  volenet-mcp inbox [--read]       messages waiting, for catching up or a SessionStart hook
+  volenet-mcp inbox [--read] [--quiet]
+                                   messages waiting. --read marks them seen, --quiet says
+                                   nothing when there are none (for hooks)
 
 With no command it runs as the MCP server itself, over stdio, which is how Claude Code starts it.
 Anything needing a live node \u2014 peers, pairing, asking an agent's brain \u2014 is a tool you ask for in
 a session, not a command here.
 `;
 var when = (ts) => new Date(ts).toISOString().replace("T", " ").slice(0, 16);
-async function run(argv, out = process.stdout) {
+async function run2(argv, out = process.stdout) {
   const [command, ...rest] = argv;
   const dir = defaultDir();
   if (!command || command === "help" || command === "--help" || command === "-h") {
@@ -210,9 +787,15 @@ async function run(argv, out = process.stdout) {
     return 0;
   }
   if (command === "install") return install(rest, out);
+  if (command === "daemon") {
+    const { runDaemon: runDaemon2 } = await Promise.resolve().then(() => (init_node(), node_exports));
+    const { resolveSettings: resolveSettings2 } = await Promise.resolve().then(() => (init_config(), config_exports));
+    await runDaemon2(await resolveSettings2());
+    return 0;
+  }
   if (command === "whoami") {
     const stored = await loadStored(dir);
-    const keys = await loadKeyPair(path4.join(dir, "net")).catch(() => null);
+    const keys = await loadKeyPair(path6.join(dir, "net")).catch(() => null);
     if (!keys) {
       out.write(
         `No identity yet at ${dir}.
@@ -261,11 +844,11 @@ It is joined the next time the server starts \u2014 restart Claude Code, or ask
     return 0;
   }
   if (command === "inbox") {
-    const inbox = new Inbox(path4.join(dir, "inbox.json"));
+    const inbox = new Inbox(dir, process.env.VOLENET_MCP_SESSION?.trim() || sessionKey());
     await inbox.load();
     const unread = inbox.unread();
     if (unread.length === 0) {
-      out.write("No new messages.\n");
+      if (!rest.includes("--quiet")) out.write("No new messages.\n");
       return 0;
     }
     out.write(`${unread.length} new VoleNet message${unread.length === 1 ? "" : "s"}:
@@ -285,103 +868,149 @@ ${USAGE}`);
   return 1;
 }
 
-// src/node.ts
-import * as path5 from "path";
-import {
-  VoleNetManager,
-  createEventBus,
-  loadAuthorizedVoles,
-  parsePublicKey
-} from "@openvole/volenet";
-async function startNode(options) {
-  const bus = createEventBus();
-  const inbox = new Inbox(path5.join(options.dir, "inbox.json"));
-  await inbox.load();
-  const requests = [];
-  const notices = [];
-  const net = new VoleNetManager(
-    {
-      enabled: true,
-      instanceName: options.name,
-      role: "peer",
-      port: options.port,
-      keyPath: path5.join(options.dir, "net", "vole_key"),
-      // A hub is a peer we dial. 'read' rather than 'full': a hub carries our sealed traffic,
-      // it has no business acting on this node.
-      peers: options.hub ? [{ url: options.hub, trust: "read" }] : []
-    },
-    options.dir
-  );
-  const listeners = /* @__PURE__ */ new Set();
-  bus.on("volenet:chat", (d) => {
-    const m = d;
-    const message = {
-      peerId: m.from,
-      peerName: m.fromName,
-      dir: "in",
-      text: m.text,
-      ts: m.timestamp,
-      id: m.messageId
-    };
-    void inbox.add(message).then((added) => {
-      if (added) for (const fn of listeners) fn(message);
-    });
-  });
-  bus.on("volenet:chat:pending", (d) => {
-    const p = d;
-    for (const n of p.from ?? []) {
-      const at = notices.findIndex((x) => x.from === n.from);
-      if (at >= 0) notices[at] = n;
-      else notices.push(n);
-    }
-  });
-  const remember = (kind) => (d) => {
-    const r = d;
-    if (requests.some((x) => x.from === r.from && x.kind === kind)) return;
-    requests.push({ kind, from: r.from, fromName: r.fromName, note: r.note, at: Date.now() });
-  };
-  bus.on("volenet:pair:request", remember("pair"));
-  bus.on("volenet:relay:request", remember("relay"));
-  await net.start(void 0, bus);
-  let hubStatus = "no hub configured";
-  if (options.hub) {
-    hubStatus = await alreadyTrusts(options.dir, options.hub) ? `joined ${options.hub}` : await join4(net, options.hub);
-  }
-  return {
-    net,
-    inbox,
-    requests,
-    notices,
-    options,
-    hubStatus,
-    onMessage: (fn) => {
-      listeners.add(fn);
-      return () => listeners.delete(fn);
-    },
-    stop: () => net.stop()
-  };
-}
-async function join4(net, hub) {
-  const res = await net.initiateJoin(hub);
-  if (!res.ok) return `could not join ${hub}: ${res.error}`;
-  if (res.pending) return `waiting for approval at ${hub}`;
-  return `joined ${res.hubName ?? hub}`;
-}
-async function alreadyTrusts(dir, hub) {
-  try {
-    const r = await fetch(`${hub.replace(/\/$/, "")}/volenet/info`, {
-      signal: AbortSignal.timeout(8e3)
-    });
-    const info = await r.json();
-    const parsed = info.publicKey ? parsePublicKey(info.publicKey) : null;
-    if (!parsed) return false;
-    return (await loadAuthorizedVoles(path5.join(dir, "net"))).has(parsed.instanceId);
-  } catch {
-    return false;
+// src/index.ts
+init_node();
+
+// src/prompts.ts
+var PROMPTS = [
+  {
+    name: "whoami",
+    description: "This session\u2019s identity on the VoleNet mesh, and whether it can reach anything.",
+    render: () => `Report this session's VoleNet identity.
+
+Call \`volenet_whoami\`. Give back the name, the instance id and where it is listening, and say in
+one line whether it is actually reachable \u2014 a hub joined, or peers paired \u2014 rather than leaving an
+empty roster to be read as a failure.
+
+The instance id is what someone else needs to grant this session anything: an agent's operator names
+it in \`net.peers\`. Offer it if they look like they need it. The public key is several kilobytes of
+post-quantum key material, so ask for it with \`key: true\` only when a peer actually wants it.
+
+If nothing is connected, say so and offer \`setup\`.`
+  },
+  {
+    name: "peers",
+    description: "Who this session can reach right now, and by which route.",
+    render: () => `List who this session can reach on VoleNet.
+
+Call \`volenet_peers\`. For each one say whether it is online, and whether the link is direct or
+through a hub \u2014 the difference matters: a hub carries chat and consent, a direct link is the only
+route that can ask an agent's brain.
+
+Flag anything that needs an action rather than only listing state: a hub member with no consent yet
+cannot be messaged until one side asks (\`volenet_connect\`), and someone offline will receive what
+is sent whenever they return. If the list is empty, say why \u2014 no hub, no pairings \u2014 and offer
+\`setup\`.`
+  },
+  {
+    name: "rooms",
+    description: "Rooms this session is in, and how to say something to one.",
+    render: () => `Show the VoleNet rooms this session is in.
+
+Call \`volenet_room\` with no arguments. For each, say who is in it \u2014 a room is several people and
+agents in one conversation, so who else is there is the useful part.
+
+To say something, \`volenet_room\` with \`post\` and \`room\`. Every member gets their own sealed copy;
+there is no shared key, which is why removing somebody stops them reading immediately. Report what
+came back honestly: some copies may be waiting for members who are away, and some may not have been
+sent at all because that member has not accepted this session \u2014 **a room does not create consent**,
+so say that rather than let it read as a failure.
+
+If there are no rooms, offer to make one (\`create\`) or to join one by id (\`join\`). A room lives on
+a hub, so one has to be joined first.`
+  },
+  {
+    name: "setup",
+    description: "Get this session onto the VoleNet mesh \u2014 join a hub, or pair with an agent.",
+    render: () => `Get this session onto the VoleNet mesh.
+
+1. Call \`volenet_whoami\` first. It reports the identity, whether a hub is set, and how many peers
+   are reachable. An identity is generated on first run; there is nothing to create.
+2. If nothing is connected, explain the two routes and ask which is wanted \u2014 do not pick silently:
+   - **A hub** (\`volenet_hub\`) makes this session reachable from anywhere, including from a phone,
+     and works when neither side can dial the other. A hub carries sealed traffic it cannot read and
+     stores no message. It will **not** relay a question to an agent's brain.
+   - **A direct pair** (\`volenet_connect\`) with an agent whose address is reachable from here. This
+     is the only route that can ask an agent's brain.
+   Both can be used at once, and either can be added later.
+3. Carry out whichever they choose. For a hub, the URL is enough. For a pair, follow the two-step
+   fingerprint check \u2014 the \`pair\` command covers it.
+4. Finish by calling \`volenet_peers\` and saying plainly who is now reachable, and by which route.
+
+Reaching someone also needs consent, which is separate from being connected: on a hub, either side
+asks and the other accepts. Say so, rather than letting an empty roster look like a failure.`
+  },
+  {
+    name: "catch-up",
+    description: "Read what arrived while this session was away, and say what needs answering.",
+    render: () => `Catch up on VoleNet.
+
+1. Call \`volenet_inbox\`. It returns messages that arrived \u2014 including while no session was running,
+   since senders hold what they could not deliver and flush on reconnect \u2014 and who tried to reach
+   this session while it was away. Reading marks them seen.
+2. Call \`volenet_peers\` if anything needs context about who a sender is.
+3. Summarise for the person: who wrote, what they want, and what is worth answering. Do not reply on
+   their behalf without asking.
+4. If a reply is wanted, \`volenet_send\` says it and \`volenet_wait\` waits for what comes back, so
+   an exchange happens in one turn rather than by checking again later.
+
+If nothing arrived, say so in one line. This is worth running at the start of a session.`
+  },
+  {
+    name: "pair",
+    description: "Pair with an agent at a URL, checking the fingerprint before trusting it.",
+    arguments: [
+      {
+        name: "url",
+        description: "The agent to pair with, e.g. http://10.0.0.5:9700",
+        required: true
+      }
+    ],
+    render: (a) => `Pair this session with the VoleNet node at ${a.url ?? "<url>"}.
+
+Pairing is deliberately two calls, because trusting a URL blind is trusting whoever holds it.
+
+1. Call \`volenet_connect\` with \`url: "${a.url ?? "<url>"}"\`. It reaches the node and reports the
+   fingerprint of whoever answered. It trusts nothing yet.
+2. Show that fingerprint to the person and ask them to check it against what the other side reports
+   \u2014 \`vole net show-key\` on an OpenVole agent. **Wait for them.** Do not confirm on their behalf:
+   this step exists precisely so a human compares two values.
+3. Ask whether this session should also be able to use that agent's **brain** \u2014 running its model
+   to answer questions \u2014 or only chat with whoever runs it.
+4. Once they confirm the fingerprint, call \`volenet_connect\` again with the same \`url\`,
+   \`confirm:\` set to that fingerprint, and \`brain: true\` if they said yes. This trusts the node
+   and sends a pair request carrying the ask.
+5. Tell them the request now waits for the operator of that node to accept it, and that nothing
+   arrives until they do.
+
+Being trusted is not the same as being allowed to do anything: the keystore says who may connect,
+\`net.peers\` says what they may then do. Sending the ask with the request is what lets the operator
+settle both while accepting, instead of editing a config file afterwards.`
+  },
+  {
+    name: "reach",
+    description: "Message a peer and wait for the reply, rather than checking back later.",
+    arguments: [
+      { name: "peer", description: "Who to reach \u2014 a name or instance id", required: true },
+      { name: "message", description: "What to say", required: false }
+    ],
+    render: (a) => `Reach ${a.peer ?? "a peer"} over VoleNet${a.message ? ` and say: ${a.message}` : ""}.
+
+1. \`volenet_peers\` first if unsure the name resolves, or by which route they are reachable.
+2. \`volenet_send\` to say it. This is chat: it reaches whoever is there and does **not** run their
+   brain. To ask an agent's model instead, use \`volenet_ask\` \u2014 direct links only, and its operator
+   must have granted brain access.
+3. \`volenet_wait\` for the answer, so the exchange completes in this turn. If nothing comes back in
+   time, say so plainly: the message is not lost, and a reply lands in the inbox whenever it comes.
+
+If the peer is offline the message waits here and goes out when they return \u2014 report that rather
+than treating it as a failure.`
   }
-}
+];
 
 // src/tools.ts
+init_config();
+init_node();
 var obj = (properties, required = []) => ({
   type: "object",
   properties,
@@ -390,18 +1019,15 @@ var obj = (properties, required = []) => ({
 var str = (description) => ({ type: "string", description });
 var num = (description) => ({ type: "number", description });
 var when2 = (ts) => ts ? new Date(ts).toISOString().replace("T", " ").slice(0, 19) : "-";
-function peers(node) {
-  const live = new Set(
-    (node.net.getTransport()?.getPeers() ?? []).filter((p) => p.connected).map((p) => p.peerId)
-  );
-  const out = node.net.getInstances().map((i) => ({
+async function peers(node) {
+  const out = (await node.net.instances()).map((i) => ({
     id: i.id,
     name: i.name,
     route: "direct",
-    connected: live.has(i.id)
+    connected: i.connected
   }));
   const direct = new Set(out.map((p) => p.id));
-  for (const m of node.net.getRelayMembers()) {
+  for (const m of await node.net.relayMembers()) {
     if (direct.has(m.id)) continue;
     out.push({
       id: m.id,
@@ -414,8 +1040,8 @@ function peers(node) {
   }
   return out;
 }
-function resolve(node, ref) {
-  const all = peers(node);
+async function resolve(node, ref) {
+  const all = await peers(node);
   return all.find((p) => p.id === ref) ?? all.find((p) => p.name === ref) ?? all.find((p) => p.id.startsWith(ref)) ?? all.find((p) => p.name.toLowerCase() === ref.toLowerCase());
 }
 var TOOLS = [
@@ -426,16 +1052,20 @@ var TOOLS = [
       key: { type: "boolean", description: "Include the full public key string" }
     }),
     async run(node, args) {
-      const key = node.net.getKeyPair();
-      const online = peers(node).filter((p) => p.connected).length;
+      const key = await node.net.identity();
+      const online = (await peers(node)).filter((p) => p.connected).length;
       const lines = [
         `name        ${node.options.name}`,
         `instanceId  ${key?.instanceId ?? "(not started)"}`,
         `hub         ${node.hubStatus}`,
         `connected   ${online} peer(s) online`,
         `listening   port ${node.options.port} (reachable only from networks that can dial it)`,
-        `store       ${node.options.dir}`
+        `store       ${node.options.dir}`,
+        `node        ${node.where === "daemon" ? "a daemon, so this identity stays reachable when no session is open" : "in this session, so it is only reachable while this session is"}`
       ];
+      lines.push(
+        `replies     ${node.canSample ? "this client can be asked to answer on its own" : "only when you ask \u2014 this client cannot be woken by a message"}`
+      );
       if (args.key) lines.push("", `publicKey   ${key?.publicKeyString ?? "-"}`);
       else
         lines.push(
@@ -455,7 +1085,7 @@ var TOOLS = [
     description: "Everyone this session can reach: agents and people, whether the link is direct or through a hub, and whether they are online right now.",
     inputSchema: obj({}),
     async run(node) {
-      const all = peers(node);
+      const all = await peers(node);
       if (all.length === 0) {
         return "No peers. Join a hub (VOLENET_MCP_HUB) or pair with a node directly (volenet_pair).";
       }
@@ -512,7 +1142,7 @@ var TOOLS = [
       const to = String(args.to ?? "");
       const text = String(args.text ?? "");
       if (!text.trim()) return "Nothing to send.";
-      const peer = resolve(node, to);
+      const peer = await resolve(node, to);
       const res = await node.net.sendChat(peer?.id ?? to, text);
       if (!res.ok) return `Not sent: ${res.error ?? "unknown error"}`;
       await node.inbox.add({
@@ -537,7 +1167,7 @@ var TOOLS = [
       limit: num("Messages (default 50)")
     }),
     async run(node, args) {
-      const peer = resolve(node, String(args.peer ?? ""));
+      const peer = await resolve(node, String(args.peer ?? ""));
       const id = peer?.id ?? String(args.peer ?? "");
       const msgs = node.inbox.history(id, Number(args.limit ?? 50));
       if (msgs.length === 0) return `Nothing recorded with ${peer?.name ?? id}.`;
@@ -556,16 +1186,15 @@ var TOOLS = [
       ["to", "question"]
     ),
     async run(node, args) {
-      const peer = resolve(node, String(args.to ?? ""));
+      const peer = await resolve(node, String(args.to ?? ""));
       if (!peer) return `No peer found: "${args.to}". Use volenet_peers.`;
       if (peer.route !== "direct") {
         return `${peer.name} is only reachable through a hub, and a hub will not relay a question to an agent's brain \u2014 it carries chat and consent only. Use volenet_send, or pair directly with volenet_pair.`;
       }
-      const mgr = node.net.getRemoteTaskManager();
-      if (!mgr) return "Remote task manager not available.";
-      const res = await mgr.delegateTask(
+      const res = await node.net.askBrain(
         peer.id,
-        { taskId: "", input: String(args.question ?? ""), fromName: node.options.name },
+        String(args.question ?? ""),
+        node.options.name,
         Number(args.timeout_ms ?? 12e4)
       );
       if (res.status === "completed") return `${peer.name} says:
@@ -575,7 +1204,7 @@ ${res.result}`;
       if (typeof why === "string" && why.includes("allowBrain")) {
         return `${peer.name} refused: ${why}
 
-Its operator can allow this session by adding { "id": "${node.net.getKeyPair()?.instanceId}", "trust": "read", "allowBrain": true } to net.peers and restarting.`;
+Its operator can allow this session by adding { "id": "${(await node.net.identity())?.instanceId}", "trust": "read", "allowBrain": true } to net.peers and restarting.`;
       }
       return `${peer.name} did not answer: ${why}`;
     }
@@ -598,7 +1227,7 @@ Its operator can allow this session by adding { "id": "${node.net.getKeyPair()?.
         node.requests.splice(node.requests.indexOf(req), 1);
         return ok.ok ? `${accept ? "Accepted" : "Denied"} ${req.fromName}.` : `Failed: ${"error" in ok ? ok.error : "unknown"}`;
       }
-      const pairs = node.net.listPairRequests();
+      const pairs = await node.net.listPairRequests();
       for (const p of pairs) {
         if (!node.requests.some((r) => r.from === p.id)) {
           node.requests.push({ kind: "pair", from: p.id, fromName: p.name, at: Date.now() });
@@ -619,7 +1248,7 @@ Its operator can allow this session by adding { "id": "${node.net.getKeyPair()?.
     }),
     async run(node, args) {
       const limit = Math.min(Math.max(Number(args.timeout_ms ?? 6e4), 1e3), 3e5);
-      const want = args.from ? resolve(node, String(args.from)) : void 0;
+      const want = args.from ? await resolve(node, String(args.from)) : void 0;
       const wanted = (m) => !args.from || m.peerId === (want?.id ?? args.from);
       const already = node.inbox.unread().filter(wanted);
       if (already.length === 0) {
@@ -655,7 +1284,7 @@ Its operator can allow this session by adding { "id": "${node.net.getKeyPair()?.
       if (args.leave) {
         const hub = node.options.hub;
         if (!hub) return "Not on a hub.";
-        node.net.forgetPeer(hub);
+        await node.net.forgetPeer(hub);
         node.options.hub = void 0;
         node.hubStatus = "no hub configured";
         await saveStored(node.options.dir, { hub: void 0 });
@@ -674,7 +1303,7 @@ Call with leave:true to come off it, or url to move to another.` : "Not on a hub
         await saveStored(node.options.dir, { hub: url });
         return `Joined ${url} again \u2014 it was already trusted, so no introduction was needed.`;
       }
-      const res = await node.net.initiateJoin(url);
+      const res = await node.net.joinHub(url);
       if (!res.ok) return `Could not join ${url}: ${res.error}`;
       node.options.hub = url;
       node.hubStatus = res.pending ? `waiting for approval at ${url}` : `joined ${res.hubName ?? url}`;
@@ -682,12 +1311,84 @@ Call with leave:true to come off it, or url to move to another.` : "Not on a hub
       return res.pending ? `Asked to join ${url}. Its operator has to approve before you appear in the roster.` : `Joined ${res.hubName ?? url}. Remembered, so the next session starts here. Call volenet_peers to see who is around.`;
     }
   },
+  {
+    name: "volenet_room",
+    description: "Rooms: several people and agents in one conversation. With no arguments it lists the rooms this session is in. Give `post` to say something to a room \u2014 every member gets their own sealed copy, so there is no shared key and removing someone stops them reading immediately. Give `create`, `join`, `leave` or `invite` to change membership, which the hub keeps. A room does not create consent: a member who has not accepted you will not receive your posts.",
+    inputSchema: obj({
+      room: str("Which room, by id or name (see the list)"),
+      post: str("Say this to the room"),
+      create: str("Make a room with this name"),
+      join: str("Join a room by id"),
+      leave: { type: "boolean", description: "Leave the room named in `room`" },
+      invite: str("Bring this peer (name or id) into the room named in `room`"),
+      hub: str("Which hub holds the room. Only needed with more than one.")
+    }),
+    async run(node, args) {
+      const hubOf = async () => {
+        if (args.hub) return String(args.hub);
+        const hubs = (await node.net.instances()).filter((i) => i.connected);
+        if (hubs.length === 0) return null;
+        return hubs[0].id;
+      };
+      const find = async (ref) => {
+        const all2 = await node.net.rooms();
+        return all2.find((r) => r.room === ref) ?? all2.find((r) => r.name === ref);
+      };
+      if (args.create || args.join || args.leave || args.invite) {
+        const hub = await hubOf();
+        if (!hub)
+          return "No hub connected. A room lives on a hub \u2014 join one first with volenet_hub.";
+        if (args.create) {
+          const res2 = await node.net.roomCommand(hub, "room:create", { name: String(args.create) });
+          return res2.ok ? `Asked for a room called "${args.create}". Call this again in a moment to see it.` : `Could not: ${res2.error}`;
+        }
+        if (args.join) {
+          const res2 = await node.net.roomCommand(hub, "room:join", { room: String(args.join) });
+          return res2.ok ? `Asked to join ${args.join}.` : `Could not: ${res2.error}`;
+        }
+        const room = args.room ? await find(String(args.room)) : void 0;
+        if (!room) return "Name the room with `room` \u2014 see the list.";
+        if (args.leave) {
+          const res2 = await node.net.roomCommand(hub, "room:leave", { room: room.room });
+          return res2.ok ? `Left ${room.name}.` : `Could not: ${res2.error}`;
+        }
+        const peer = await resolve(node, String(args.invite));
+        const res = await node.net.roomCommand(hub, "room:invite", {
+          room: room.room,
+          member: peer?.id ?? String(args.invite)
+        });
+        return res.ok ? `Invited ${peer?.name ?? args.invite} to ${room.name}.` : `Could not: ${res.error}`;
+      }
+      if (args.post) {
+        const room = args.room ? await find(String(args.room)) : (await node.net.rooms())[0];
+        if (!room) return "No room to post to. Create or join one first.";
+        const res = await node.net.postToRoom(room.room, String(args.post));
+        if (!res.ok) return `Not posted: ${res.error}`;
+        const bits = [`Posted to ${room.name}: ${res.sent} delivered`];
+        if (res.held) bits.push(`${res.held} waiting for members who are away`);
+        if (res.skipped)
+          bits.push(`${res.skipped} could not be reached \u2014 they may not have accepted you`);
+        return `${bits.join(", ")}.`;
+      }
+      const all = await node.net.rooms();
+      if (all.length === 0) {
+        return 'Not in any room. Create one with create:"name", or join one you have been given the id for.';
+      }
+      return all.map(
+        (r) => `  ${r.name}  ${r.room.substring(0, 8)}  ${r.members.length} member(s): ${r.members.map((m) => m.name).join(", ")}`
+      ).join("\n");
+    }
+  },
   {
     name: "volenet_connect",
     description: "Reach out to someone new: pair directly with a node at a URL, or ask a hub member for consent to chat. Pairing is two calls \u2014 the first reports the fingerprint of whoever answers, the second confirms it \u2014 because trusting a URL blind is trusting whoever holds it. Neither side trusts you until they accept.",
     inputSchema: obj({
       url: str("Node URL to pair with directly, e.g. http://10.0.0.5:9700"),
       confirm: str("The fingerprint returned by a first call with url, confirming who answers"),
+      brain: {
+        type: "boolean",
+        description: "Also ask for permission to use that agent's brain. The operator sees it as part of the same decision and can grant it while accepting; without it, being trusted allows chat only."
+      },
       member: str("Hub member name or id to ask for chat consent"),
       note: str("A line saying who you are")
     }),
@@ -711,8 +1412,18 @@ Call with leave:true to come off it, or url to move to another.` : "Not on a hub
         if (!probe.fingerprint?.startsWith(confirm)) {
           return `That fingerprint does not match: it answers with ${probe.fingerprint}. Nothing was trusted.`;
         }
-        const res = await node.net.initiatePair(url, probe.publicKey, note);
-        return res.ok ? `Trusted ${probe.name ?? url} and asked it to trust this session. Nothing arrives until their operator accepts.` : `Could not ask: ${res.error}`;
+        const res = await node.net.initiatePair(
+          url,
+          probe.publicKey,
+          note,
+          args.brain ? ["brain"] : void 0
+        );
+        if (!res.ok) return `Could not ask: ${res.error}`;
+        return [
+          `Trusted ${probe.name ?? url} and asked it to trust this session.`,
+          args.brain ? "The request also asks to use its brain, so its operator can grant that while accepting \u2014 no config editing, no restart." : "It asks for trust only. Pass brain:true to also ask for brain access.",
+          "Nothing arrives until their operator accepts."
+        ].join(" ");
       }
       if (args.member) {
         const res = await node.net.requestRelayConnect(String(args.member), note);
@@ -725,6 +1436,9 @@ Call with leave:true to come off it, or url to move to another.` : "Not on a hub
 ];
 
 // src/index.ts
+init_inbox();
+init_config();
+init_node();
 function unreadFooter(node, toolName) {
   if (toolName === "volenet_inbox" || toolName === "volenet_wait") return "";
   const unread = node.inbox.unread();
@@ -734,8 +1448,34 @@ function unreadFooter(node, toolName) {
 
 \u2014 ${unread.length} unread message${unread.length === 1 ? "" : "s"} from ${who}. Read them with volenet_inbox.`;
 }
-function createServer(node) {
-  const server = new Server({ name: "volenet", version: "0.1.0" }, { capabilities: { tools: {} } });
+function createServer2(node) {
+  const server = new Server(
+    { name: "volenet", version: "0.1.0" },
+    { capabilities: { tools: {}, prompts: {} } }
+  );
+  server.setRequestHandler(ListPromptsRequestSchema, async () => ({
+    prompts: PROMPTS.map((p) => ({
+      name: p.name,
+      description: p.description,
+      ...p.arguments ? { arguments: p.arguments } : {}
+    }))
+  }));
+  server.setRequestHandler(GetPromptRequestSchema, async (request) => {
+    const prompt = PROMPTS.find((p) => p.name === request.params.name);
+    if (!prompt) throw new Error(`No such prompt: ${request.params.name}`);
+    return {
+      description: prompt.description,
+      messages: [
+        {
+          role: "user",
+          content: {
+            type: "text",
+            text: prompt.render(request.params.arguments ?? {})
+          }
+        }
+      ]
+    };
+  });
   server.setRequestHandler(ListToolsRequestSchema, async () => ({
     tools: TOOLS.map((t) => ({
       name: t.name,
@@ -765,13 +1505,31 @@ function createServer(node) {
   });
   return server;
 }
+async function recordClientCapabilities(dir, caps) {
+  try {
+    const fs4 = await import("fs/promises");
+    const path7 = await import("path");
+    await fs4.mkdir(dir, { recursive: true });
+    await fs4.writeFile(
+      path7.join(dir, "client.json"),
+      `${JSON.stringify(caps ?? {}, null, 2)}
+`,
+      "utf-8"
+    );
+  } catch {
+  }
+}
 async function main() {
   const options = await resolveSettings();
   const node = await startNode(options);
-  const server = createServer(node);
+  const server = createServer2(node);
   await server.connect(new StdioServerTransport());
+  const caps = server.getClientCapabilities();
+  node.canSample = Boolean(caps && typeof caps === "object" && "sampling" in caps);
+  await recordClientCapabilities(options.dir, caps);
+  const me = await node.net.identity().catch(() => null);
   process.stderr.write(
-    `volenet-mcp: ${options.name} (${node.net.getKeyPair()?.instanceId.substring(0, 8)}) ready${options.hub ? ` \u2014 hub ${options.hub}` : " \u2014 no hub configured"}
+    `volenet-mcp: ${options.name} (${me?.instanceId.substring(0, 8) ?? "?"}) ready \u2014 node ${node.where}${options.hub ? `, hub ${options.hub}` : ", no hub configured"}
 `
   );
   let stopping = false;
@@ -787,7 +1545,7 @@ async function main() {
 }
 if (process.argv[1]?.includes("volenet-mcp") || process.env.VOLENET_MCP_RUN === "1") {
   if (process.argv[2] || process.stdin.isTTY) {
-    run(process.argv.slice(2)).then((code) => process.exit(code)).catch((err) => {
+    run2(process.argv.slice(2)).then((code) => process.exit(code)).catch((err) => {
       process.stderr.write(`volenet-mcp: ${err instanceof Error ? err.message : String(err)}
 `);
       process.exit(1);
@@ -802,13 +1560,15 @@ if (process.argv[1]?.includes("volenet-mcp") || process.env.VOLENET_MCP_RUN ===
 }
 export {
   Inbox,
+  PROMPTS,
   TOOLS,
-  createServer,
+  createServer2 as createServer,
   defaultDir,
   defaultName,
   loadStored,
+  recordClientCapabilities,
   resolveSettings,
-  run as runCli,
+  run2 as runCli,
   saveStored,
   startNode,
   unreadFooter