claudemesh-cli 1.23.0 → 1.25.0

package/dist/entrypoints/cli.js

@@ -4,6 +4,7 @@ var __create = Object.create;
 var __getProtoOf = Object.getPrototypeOf;
 var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __toESM = (mod, isNodeMode, target) => {
   target = mod != null ? __create(__getProtoOf(mod)) : {};
@@ -16,6 +17,20 @@ var __toESM = (mod, isNodeMode, target) => {
       });
   return to;
 };
+var __moduleCache = /* @__PURE__ */ new WeakMap;
+var __toCommonJS = (from) => {
+  var entry = __moduleCache.get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function")
+    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    }));
+  __moduleCache.set(from, entry);
+  return entry;
+};
 var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
 var __export = (target, all) => {
   for (var name in all)
@@ -88,7 +103,7 @@ __export(exports_urls, {
   VERSION: () => VERSION,
   URLS: () => URLS
 });
-var URLS, VERSION = "1.23.0", env;
+var URLS, VERSION = "1.25.0", env;
 var init_urls = __esm(() => {
   URLS = {
     BROKER: process.env.CLAUDEMESH_BROKER_URL ?? "wss://ic.claudemesh.com/ws",
@@ -1011,6 +1026,12 @@ var init_file_crypto = __esm(() => {
 });
 
 // src/services/crypto/box.ts
+var exports_box = {};
+__export(exports_box, {
+  isDirectTarget: () => isDirectTarget,
+  encryptDirect: () => encryptDirect,
+  decryptDirect: () => decryptDirect
+});
 function isDirectTarget(targetSpec) {
   return HEX_PUBKEY.test(targetSpec);
 }
@@ -3308,44 +3329,10 @@ var init_ws_client = __esm(() => {
 });
 
 // src/services/broker/manager.ts
-async function ensureClient(mesh) {
-  const existing = clients.get(mesh.meshId);
-  if (existing)
-    return existing;
-  const isDebug2 = process.env.CLAUDEMESH_DEBUG === "1" || process.env.CLAUDEMESH_DEBUG === "true";
-  const client = new BrokerClient(mesh, { debug: isDebug2, displayName: configDisplayName });
-  clients.set(mesh.meshId, client);
-  try {
-    await client.connect();
-    for (const g of configGroups ?? []) {
-      try {
-        await client.joinGroup(g.name, g.role);
-      } catch {}
-    }
-  } catch (err) {
-    process.stderr.write(`[claudemesh] broker connect failed for ${mesh.slug}: ${err instanceof Error ? err.message : err} (will retry)
-`);
-  }
-  return client;
-}
-async function startClients(config) {
-  configDisplayName = config.displayName;
-  configGroups = config.groups ?? [];
-  await Promise.allSettled(config.meshes.map(ensureClient));
-}
-function allClients() {
-  return [...clients.values()];
-}
-function stopAll() {
-  for (const c of clients.values())
-    c.close();
-  clients.clear();
-}
-var clients, configDisplayName, configGroups;
+var clients;
 var init_manager = __esm(() => {
   init_ws_client();
   clients = new Map;
-  configGroups = [];
 });
 
 // src/services/broker/envelope.ts
@@ -3600,6 +3587,42 @@ var init_spinner = __esm(() => {
   FRAME_HEIGHT = H;
 });
 
+// src/daemon/paths.ts
+var exports_paths = {};
+__export(exports_paths, {
+  DAEMON_TCP_HOST: () => DAEMON_TCP_HOST,
+  DAEMON_TCP_DEFAULT_PORT: () => DAEMON_TCP_DEFAULT_PORT,
+  DAEMON_PATHS: () => DAEMON_PATHS
+});
+import { join as join3 } from "node:path";
+var DAEMON_PATHS, DAEMON_TCP_HOST = "127.0.0.1", DAEMON_TCP_DEFAULT_PORT = 47823;
+var init_paths2 = __esm(() => {
+  init_paths();
+  DAEMON_PATHS = {
+    get DAEMON_DIR() {
+      return join3(PATHS.CONFIG_DIR, "daemon");
+    },
+    get PID_FILE() {
+      return join3(this.DAEMON_DIR, "daemon.pid");
+    },
+    get SOCK_FILE() {
+      return join3(this.DAEMON_DIR, "daemon.sock");
+    },
+    get TOKEN_FILE() {
+      return join3(this.DAEMON_DIR, "local-token");
+    },
+    get OUTBOX_DB() {
+      return join3(this.DAEMON_DIR, "outbox.db");
+    },
+    get INBOX_DB() {
+      return join3(this.DAEMON_DIR, "inbox.db");
+    },
+    get LOG_FILE() {
+      return join3(this.DAEMON_DIR, "daemon.log");
+    }
+  };
+});
+
 // src/commands/launch.ts
 var exports_launch = {};
 __export(exports_launch, {
@@ -3609,8 +3632,41 @@ import { spawnSync as spawnSync2 } from "node:child_process";
 import { randomUUID } from "node:crypto";
 import { mkdtempSync, writeFileSync as writeFileSync4, rmSync, readdirSync, statSync, existsSync as existsSync5, readFileSync as readFileSync4 } from "node:fs";
 import { tmpdir, hostname as hostname2, homedir as homedir3 } from "node:os";
-import { join as join3 } from "node:path";
+import { join as join4 } from "node:path";
 import { createInterface as createInterface4 } from "node:readline";
+async function ensureDaemonRunning(meshSlug, quiet) {
+  const { DAEMON_PATHS: DAEMON_PATHS2 } = await Promise.resolve().then(() => (init_paths2(), exports_paths));
+  if (existsSync5(DAEMON_PATHS2.SOCK_FILE))
+    return;
+  if (!quiet)
+    render.info("starting claudemesh daemon…");
+  const { spawn } = await import("node:child_process");
+  const argv0 = process.argv[1] ?? "claudemesh";
+  let binary = argv0;
+  if (/\.ts$/.test(binary) || /node_modules|src\/entrypoints/.test(binary)) {
+    try {
+      const { execSync } = await import("node:child_process");
+      binary = execSync("which claudemesh", { encoding: "utf8" }).trim();
+    } catch {
+      binary = "claudemesh";
+    }
+  }
+  const child = spawn(binary, ["daemon", "up", "--mesh", meshSlug], {
+    detached: true,
+    stdio: "ignore"
+  });
+  child.unref();
+  const start = Date.now();
+  while (Date.now() - start < 1e4) {
+    if (existsSync5(DAEMON_PATHS2.SOCK_FILE)) {
+      if (!quiet)
+        render.ok("daemon ready");
+      return;
+    }
+    await new Promise((r) => setTimeout(r, 200));
+  }
+  render.warn("daemon failed to start within 10s", "Run `claudemesh daemon up --mesh " + meshSlug + "` manually, then re-launch.");
+}
 function parseGroupsString(raw) {
   return raw.split(",").map((s) => s.trim()).filter(Boolean).map((token) => {
     const idx = token.indexOf(":");
@@ -3930,14 +3986,15 @@ async function runLaunch(flags, rawArgs) {
     for (const entry of readdirSync(tmpBase)) {
       if (!entry.startsWith("claudemesh-"))
         continue;
-      const full = join3(tmpBase, entry);
+      const full = join4(tmpBase, entry);
       const age = Date.now() - statSync(full).mtimeMs;
       if (age > 3600000)
         rmSync(full, { recursive: true, force: true });
     }
   } catch {}
+  await ensureDaemonRunning(mesh.slug, args.quiet);
   try {
-    const claudeConfigPath = join3(homedir3(), ".claude.json");
+    const claudeConfigPath = join4(homedir3(), ".claude.json");
     if (existsSync5(claudeConfigPath)) {
       const claudeConfig = JSON.parse(readFileSync4(claudeConfigPath, "utf-8"));
       const mcpServers = claudeConfig.mcpServers ?? {};
@@ -3974,7 +4031,7 @@ async function runLaunch(flags, rawArgs) {
       console.log("  (Could not fetch service catalog — mesh services won't be natively available)");
     }
   }
-  const tmpDir = mkdtempSync(join3(tmpdir(), "claudemesh-"));
+  const tmpDir = mkdtempSync(join4(tmpdir(), "claudemesh-"));
   const sessionConfig = {
     version: 1,
     meshes: [mesh],
@@ -3983,14 +4040,14 @@ async function runLaunch(flags, rawArgs) {
     ...parsedGroups.length > 0 ? { groups: parsedGroups } : {},
     messageMode
   };
-  writeFileSync4(join3(tmpDir, "config.json"), JSON.stringify(sessionConfig, null, 2) + `
+  writeFileSync4(join4(tmpDir, "config.json"), JSON.stringify(sessionConfig, null, 2) + `
 `, "utf-8");
   if (!args.quiet) {
     printBanner(displayName, mesh.slug, role, parsedGroups, messageMode);
   }
   const meshMcpEntries = [];
   if (serviceCatalog.length > 0) {
-    const claudeConfigPath = join3(homedir3(), ".claude.json");
+    const claudeConfigPath = join4(homedir3(), ".claude.json");
     let claudeConfig = {};
     try {
       claudeConfig = JSON.parse(readFileSync4(claudeConfigPath, "utf-8"));
@@ -4057,9 +4114,9 @@ async function runLaunch(flags, rawArgs) {
   let claudeBin = "claude";
   if (!isWindows2) {
     const candidates = [
-      join3(homedir3(), ".local", "bin", "claude"),
+      join4(homedir3(), ".local", "bin", "claude"),
       "/usr/local/bin/claude",
-      join3(homedir3(), ".claude", "bin", "claude")
+      join4(homedir3(), ".claude", "bin", "claude")
     ];
     for (const c of candidates) {
       if (existsSync5(c)) {
@@ -4071,7 +4128,7 @@ async function runLaunch(flags, rawArgs) {
   const cleanup = () => {
     if (meshMcpEntries.length > 0) {
       try {
-        const claudeConfigPath = join3(homedir3(), ".claude.json");
+        const claudeConfigPath = join4(homedir3(), ".claude.json");
         const claudeConfig = JSON.parse(readFileSync4(claudeConfigPath, "utf-8"));
         const mcpServers = claudeConfig.mcpServers ?? {};
         for (const { key } of meshMcpEntries) {
@@ -4776,7 +4833,7 @@ __export(exports_join, {
 });
 import sodium3 from "libsodium-wrappers";
 import { writeFileSync as writeFileSync5, mkdirSync as mkdirSync3 } from "node:fs";
-import { join as join4, dirname as dirname2 } from "node:path";
+import { join as join5, dirname as dirname2 } from "node:path";
 import { homedir as homedir4, hostname as hostname3 } from "node:os";
 function deriveAppBaseUrl() {
   const override = process.env.CLAUDEMESH_APP_URL;
@@ -4896,8 +4953,8 @@ async function runJoin(args) {
     joinedAt: new Date().toISOString()
   });
   writeConfig(config);
-  const configDir = env.CLAUDEMESH_CONFIG_DIR ?? join4(homedir4(), ".claudemesh");
-  const inviteFile = join4(configDir, `invite-${payload.mesh_slug}.txt`);
+  const configDir = env.CLAUDEMESH_CONFIG_DIR ?? join5(homedir4(), ".claudemesh");
+  const inviteFile = join5(configDir, `invite-${payload.mesh_slug}.txt`);
   try {
     mkdirSync3(dirname2(inviteFile), { recursive: true });
     writeFileSync5(inviteFile, link, "utf-8");
@@ -6640,12 +6697,9 @@ var init_ban = __esm(() => {
 
 // src/services/bridge/protocol.ts
 import { homedir as homedir5 } from "node:os";
-import { join as join5 } from "node:path";
+import { join as join6 } from "node:path";
 function socketPath(meshSlug) {
-  return join5(homedir5(), ".claudemesh", "sockets", `${meshSlug}.sock`);
-}
-function socketDir() {
-  return join5(homedir5(), ".claudemesh", "sockets");
+  return join6(homedir5(), ".claudemesh", "sockets", `${meshSlug}.sock`);
 }
 function frame(obj) {
   return JSON.stringify(obj) + `
@@ -6742,135 +6796,6 @@ var init_client3 = __esm(() => {
   init_protocol();
 });
 
-// src/commands/peers.ts
-var exports_peers = {};
-__export(exports_peers, {
-  runPeers: () => runPeers
-});
-function projectFields(record, fields) {
-  const out = {};
-  for (const f of fields) {
-    const sourceKey = FIELD_ALIAS[f] ?? f;
-    out[f] = record[sourceKey];
-  }
-  return out;
-}
-async function listPeersForMesh(slug) {
-  const config = readConfig();
-  const joined = config.meshes.find((m) => m.slug === slug);
-  const selfMemberPubkey = joined?.pubkey ?? null;
-  const bridged = await tryBridge(slug, "peers");
-  if (bridged && bridged.ok) {
-    const peers = bridged.result;
-    return peers.map((p) => annotateSelf(p, selfMemberPubkey, null));
-  }
-  let result = [];
-  await withMesh({ meshSlug: slug }, async (client) => {
-    const all = await client.listPeers();
-    const selfSessionPubkey = client.getSessionPubkey();
-    result = all.map((p) => annotateSelf(p, selfMemberPubkey, selfSessionPubkey));
-  });
-  return result;
-}
-function annotateSelf(peer, selfMemberPubkey, selfSessionPubkey) {
-  const isSelf = !!(selfMemberPubkey && peer.memberPubkey && peer.memberPubkey === selfMemberPubkey);
-  const isThisSession = !!(isSelf && selfSessionPubkey && peer.pubkey === selfSessionPubkey);
-  return { ...peer, isSelf, isThisSession };
-}
-async function runPeers(flags) {
-  const config = readConfig();
-  const slugs = flags.mesh ? [flags.mesh] : config.meshes.map((m) => m.slug);
-  if (slugs.length === 0) {
-    render.err("No meshes joined.");
-    render.hint("claudemesh <invite-url>    # join + launch");
-    process.exit(1);
-  }
-  const fieldList = typeof flags.json === "string" && flags.json.length > 0 ? flags.json.split(",").map((s) => s.trim()).filter(Boolean) : null;
-  const wantsJson = flags.json !== undefined && flags.json !== false;
-  const allJson = [];
-  for (const slug of slugs) {
-    try {
-      const peers = await listPeersForMesh(slug);
-      if (wantsJson) {
-        const projected = fieldList ? peers.map((p) => projectFields(p, fieldList)) : peers;
-        allJson.push({ mesh: slug, peers: projected });
-        continue;
-      }
-      render.section(`peers on ${slug} (${peers.length})`);
-      if (peers.length === 0) {
-        render.info(dim("  (no peers connected)"));
-        continue;
-      }
-      for (const p of peers) {
-        const groups = p.groups.length ? " [" + p.groups.map((g) => `@${g.name}${g.role ? `:${g.role}` : ""}`).join(", ") + "]" : "";
-        const statusDot = p.status === "working" ? yellow("●") : green("●");
-        const name = bold(p.displayName);
-        const meta = [];
-        if (p.peerType)
-          meta.push(p.peerType);
-        if (p.channel)
-          meta.push(p.channel);
-        if (p.model)
-          meta.push(p.model);
-        const metaStr = meta.length ? dim(` (${meta.join(", ")})`) : "";
-        const summary = p.summary ? dim(`  — ${p.summary}`) : "";
-        const pubkeyTag = dim(` · ${p.pubkey.slice(0, 16)}…`);
-        const selfTag = p.isThisSession ? dim(" ") + yellow("(this session)") : p.isSelf ? dim(" ") + yellow("(your other session)") : "";
-        render.info(`${statusDot} ${name}${selfTag}${groups}${metaStr}${pubkeyTag}${summary}`);
-        if (p.cwd)
-          render.info(dim(`   cwd: ${p.cwd}`));
-      }
-    } catch (e) {
-      render.err(`${slug}: ${e instanceof Error ? e.message : String(e)}`);
-    }
-  }
-  if (wantsJson) {
-    process.stdout.write(JSON.stringify(slugs.length === 1 ? allJson[0]?.peers : allJson, null, 2) + `
-`);
-  }
-}
-var FIELD_ALIAS;
-var init_peers = __esm(() => {
-  init_connect();
-  init_facade();
-  init_client3();
-  init_render();
-  init_styles();
-  FIELD_ALIAS = {
-    name: "displayName"
-  };
-});
-
-// src/daemon/paths.ts
-import { join as join6 } from "node:path";
-var DAEMON_PATHS, DAEMON_TCP_HOST = "127.0.0.1", DAEMON_TCP_DEFAULT_PORT = 47823;
-var init_paths2 = __esm(() => {
-  init_paths();
-  DAEMON_PATHS = {
-    get DAEMON_DIR() {
-      return join6(PATHS.CONFIG_DIR, "daemon");
-    },
-    get PID_FILE() {
-      return join6(this.DAEMON_DIR, "daemon.pid");
-    },
-    get SOCK_FILE() {
-      return join6(this.DAEMON_DIR, "daemon.sock");
-    },
-    get TOKEN_FILE() {
-      return join6(this.DAEMON_DIR, "local-token");
-    },
-    get OUTBOX_DB() {
-      return join6(this.DAEMON_DIR, "outbox.db");
-    },
-    get INBOX_DB() {
-      return join6(this.DAEMON_DIR, "inbox.db");
-    },
-    get LOG_FILE() {
-      return join6(this.DAEMON_DIR, "daemon.log");
-    }
-  };
-});
-
 // src/daemon/local-token.ts
 import { mkdirSync as mkdirSync4, readFileSync as readFileSync5, writeFileSync as writeFileSync6 } from "node:fs";
 import { dirname as dirname3 } from "node:path";
@@ -6952,7 +6877,61 @@ var init_client4 = __esm(() => {
 });
 
 // src/services/bridge/daemon-route.ts
+var exports_daemon_route = {};
+__export(exports_daemon_route, {
+  trySendViaDaemon: () => trySendViaDaemon,
+  tryListSkillsViaDaemon: () => tryListSkillsViaDaemon,
+  tryListPeersViaDaemon: () => tryListPeersViaDaemon,
+  tryGetSkillViaDaemon: () => tryGetSkillViaDaemon
+});
 import { existsSync as existsSync7 } from "node:fs";
+async function tryListPeersViaDaemon() {
+  if (!existsSync7(DAEMON_PATHS.SOCK_FILE))
+    return null;
+  try {
+    const res = await ipc({ path: "/v1/peers", timeoutMs: 3000 });
+    if (res.status !== 200)
+      return null;
+    return Array.isArray(res.body.peers) ? res.body.peers : [];
+  } catch (err) {
+    const msg = String(err);
+    if (/ENOENT|ECONNREFUSED|ipc_timeout/.test(msg))
+      return null;
+    return null;
+  }
+}
+async function tryListSkillsViaDaemon() {
+  if (!existsSync7(DAEMON_PATHS.SOCK_FILE))
+    return null;
+  try {
+    const res = await ipc({ path: "/v1/skills", timeoutMs: 3000 });
+    if (res.status !== 200)
+      return null;
+    return Array.isArray(res.body.skills) ? res.body.skills : [];
+  } catch (err) {
+    const msg = String(err);
+    if (/ENOENT|ECONNREFUSED|ipc_timeout/.test(msg))
+      return null;
+    return null;
+  }
+}
+async function tryGetSkillViaDaemon(name) {
+  if (!existsSync7(DAEMON_PATHS.SOCK_FILE))
+    return null;
+  try {
+    const res = await ipc({
+      path: `/v1/skills/${encodeURIComponent(name)}`,
+      timeoutMs: 3000
+    });
+    if (res.status === 404)
+      return null;
+    if (res.status !== 200)
+      return null;
+    return res.body.skill ?? null;
+  } catch {
+    return null;
+  }
+}
 async function trySendViaDaemon(args) {
   if (!existsSync7(DAEMON_PATHS.SOCK_FILE))
     return null;
@@ -6989,34 +6968,140 @@ var init_daemon_route = __esm(() => {
   init_paths2();
 });
 
-// src/commands/send.ts
-var exports_send = {};
-__export(exports_send, {
-  runSend: () => runSend
+// src/commands/peers.ts
+var exports_peers = {};
+__export(exports_peers, {
+  runPeers: () => runPeers
 });
-async function runSend(flags, to, message) {
-  if (!to || !message) {
-    render.err("Usage: claudemesh send <to> <message>");
-    process.exit(1);
+function projectFields(record, fields) {
+  const out = {};
+  for (const f of fields) {
+    const sourceKey = FIELD_ALIAS[f] ?? f;
+    out[f] = record[sourceKey];
   }
-  const priority = flags.priority === "now" ? "now" : flags.priority === "low" ? "low" : "next";
+  return out;
+}
+async function listPeersForMesh(slug) {
   const config = readConfig();
-  const meshSlug = flags.mesh ?? (config.meshes.length === 1 ? config.meshes[0].slug : null);
-  if (!flags.self && meshSlug) {
-    const joined = config.meshes.find((m) => m.slug === meshSlug);
-    if (joined && /^[0-9a-f]{64}$/i.test(to) && to.toLowerCase() === joined.pubkey.toLowerCase()) {
-      render.err(`Target "${to.slice(0, 16)}…" is your own member pubkey on mesh "${meshSlug}".`);
-      render.hint("Pass --self to message a sibling session of your own member, or pick a different peer's pubkey.");
-      process.exit(1);
+  const joined = config.meshes.find((m) => m.slug === slug);
+  const selfMemberPubkey = joined?.pubkey ?? null;
+  try {
+    const { tryListPeersViaDaemon: tryListPeersViaDaemon2 } = await Promise.resolve().then(() => (init_daemon_route(), exports_daemon_route));
+    const dr = await tryListPeersViaDaemon2();
+    if (dr !== null) {
+      return dr.map((p) => annotateSelf(p, selfMemberPubkey, null));
     }
+  } catch {}
+  const bridged = await tryBridge(slug, "peers");
+  if (bridged && bridged.ok) {
+    const peers = bridged.result;
+    return peers.map((p) => annotateSelf(p, selfMemberPubkey, null));
   }
-  {
-    const dr = await trySendViaDaemon({ to, message, priority, expectedMesh: meshSlug ?? undefined });
-    if (dr !== null) {
-      if (dr.ok) {
-        if (flags.json)
-          console.log(JSON.stringify({ ok: true, messageId: dr.messageId, target: to, via: "daemon", duplicate: !!dr.duplicate }));
-        else
+  let result = [];
+  await withMesh({ meshSlug: slug }, async (client) => {
+    const all = await client.listPeers();
+    const selfSessionPubkey = client.getSessionPubkey();
+    result = all.map((p) => annotateSelf(p, selfMemberPubkey, selfSessionPubkey));
+  });
+  return result;
+}
+function annotateSelf(peer, selfMemberPubkey, selfSessionPubkey) {
+  const isSelf = !!(selfMemberPubkey && peer.memberPubkey && peer.memberPubkey === selfMemberPubkey);
+  const isThisSession = !!(isSelf && selfSessionPubkey && peer.pubkey === selfSessionPubkey);
+  return { ...peer, isSelf, isThisSession };
+}
+async function runPeers(flags) {
+  const config = readConfig();
+  const slugs = flags.mesh ? [flags.mesh] : config.meshes.map((m) => m.slug);
+  if (slugs.length === 0) {
+    render.err("No meshes joined.");
+    render.hint("claudemesh <invite-url>    # join + launch");
+    process.exit(1);
+  }
+  const fieldList = typeof flags.json === "string" && flags.json.length > 0 ? flags.json.split(",").map((s) => s.trim()).filter(Boolean) : null;
+  const wantsJson = flags.json !== undefined && flags.json !== false;
+  const allJson = [];
+  for (const slug of slugs) {
+    try {
+      const peers = await listPeersForMesh(slug);
+      if (wantsJson) {
+        const projected = fieldList ? peers.map((p) => projectFields(p, fieldList)) : peers;
+        allJson.push({ mesh: slug, peers: projected });
+        continue;
+      }
+      render.section(`peers on ${slug} (${peers.length})`);
+      if (peers.length === 0) {
+        render.info(dim("  (no peers connected)"));
+        continue;
+      }
+      for (const p of peers) {
+        const groups = p.groups.length ? " [" + p.groups.map((g) => `@${g.name}${g.role ? `:${g.role}` : ""}`).join(", ") + "]" : "";
+        const statusDot = p.status === "working" ? yellow("●") : green("●");
+        const name = bold(p.displayName);
+        const meta = [];
+        if (p.peerType)
+          meta.push(p.peerType);
+        if (p.channel)
+          meta.push(p.channel);
+        if (p.model)
+          meta.push(p.model);
+        const metaStr = meta.length ? dim(` (${meta.join(", ")})`) : "";
+        const summary = p.summary ? dim(`  — ${p.summary}`) : "";
+        const pubkeyTag = dim(` · ${p.pubkey.slice(0, 16)}…`);
+        const selfTag = p.isThisSession ? dim(" ") + yellow("(this session)") : p.isSelf ? dim(" ") + yellow("(your other session)") : "";
+        render.info(`${statusDot} ${name}${selfTag}${groups}${metaStr}${pubkeyTag}${summary}`);
+        if (p.cwd)
+          render.info(dim(`   cwd: ${p.cwd}`));
+      }
+    } catch (e) {
+      render.err(`${slug}: ${e instanceof Error ? e.message : String(e)}`);
+    }
+  }
+  if (wantsJson) {
+    process.stdout.write(JSON.stringify(slugs.length === 1 ? allJson[0]?.peers : allJson, null, 2) + `
+`);
+  }
+}
+var FIELD_ALIAS;
+var init_peers = __esm(() => {
+  init_connect();
+  init_facade();
+  init_client3();
+  init_render();
+  init_styles();
+  FIELD_ALIAS = {
+    name: "displayName"
+  };
+});
+
+// src/commands/send.ts
+var exports_send = {};
+__export(exports_send, {
+  runSend: () => runSend
+});
+async function runSend(flags, to, message) {
+  if (!to || !message) {
+    render.err("Usage: claudemesh send <to> <message>");
+    process.exit(1);
+  }
+  const priority = flags.priority === "now" ? "now" : flags.priority === "low" ? "low" : "next";
+  const config = readConfig();
+  const meshSlug = flags.mesh ?? (config.meshes.length === 1 ? config.meshes[0].slug : null);
+  if (!flags.self && meshSlug) {
+    const joined = config.meshes.find((m) => m.slug === meshSlug);
+    if (joined && /^[0-9a-f]{64}$/i.test(to) && to.toLowerCase() === joined.pubkey.toLowerCase()) {
+      render.err(`Target "${to.slice(0, 16)}…" is your own member pubkey on mesh "${meshSlug}".`);
+      render.hint("Pass --self to message a sibling session of your own member, or pick a different peer's pubkey.");
+      process.exit(1);
+    }
+  }
+  {
+    const dr = await trySendViaDaemon({ to, message, priority, expectedMesh: meshSlug ?? undefined });
+    if (dr !== null) {
+      if (dr.ok) {
+        if (flags.json)
+          console.log(JSON.stringify({ ok: true, messageId: dr.messageId, target: to, via: "daemon", duplicate: !!dr.duplicate }));
+        else
           render.ok(`sent to ${to} (daemon)`, dr.messageId ? dim(dr.messageId.slice(0, 8)) : undefined);
         return;
       }
@@ -8423,12 +8508,32 @@ function migrateOutbox(db) {
     CREATE INDEX IF NOT EXISTS outbox_aborted
       ON outbox(status, aborted_at) WHERE status = 'aborted';
   `);
+  const hasMesh = columnExists(db, "outbox", "mesh");
+  const hasTargetSpec = columnExists(db, "outbox", "target_spec");
+  const hasNonce = columnExists(db, "outbox", "nonce");
+  const hasCiphertext = columnExists(db, "outbox", "ciphertext");
+  const hasPriority = columnExists(db, "outbox", "priority");
+  if (!hasMesh)
+    db.exec(`ALTER TABLE outbox ADD COLUMN mesh TEXT`);
+  if (!hasTargetSpec)
+    db.exec(`ALTER TABLE outbox ADD COLUMN target_spec TEXT`);
+  if (!hasNonce)
+    db.exec(`ALTER TABLE outbox ADD COLUMN nonce TEXT`);
+  if (!hasCiphertext)
+    db.exec(`ALTER TABLE outbox ADD COLUMN ciphertext TEXT`);
+  if (!hasPriority)
+    db.exec(`ALTER TABLE outbox ADD COLUMN priority TEXT`);
+}
+function columnExists(db, table, column) {
+  const rows = db.prepare(`PRAGMA table_info(${table})`).all();
+  return rows.some((r) => r.name === column);
 }
 function findByClientId(db, clientMessageId) {
   const row = db.prepare(`
     SELECT id, client_message_id, request_fingerprint, payload, enqueued_at,
            attempts, next_attempt_at, status, last_error, delivered_at,
-           broker_message_id, aborted_at, aborted_by, superseded_by
+           broker_message_id, aborted_at, aborted_by, superseded_by,
+           mesh, target_spec, nonce, ciphertext, priority
       FROM outbox WHERE client_message_id = ?
   `).get(clientMessageId);
   return row ?? null;
@@ -8437,9 +8542,10 @@ function insertPending(db, input) {
   db.prepare(`
     INSERT INTO outbox (
       id, client_message_id, request_fingerprint, payload,
-      enqueued_at, attempts, next_attempt_at, status
-    ) VALUES (?, ?, ?, ?, ?, 0, ?, 'pending')
-  `).run(input.id, input.client_message_id, input.request_fingerprint, input.payload, input.now, input.now);
+      enqueued_at, attempts, next_attempt_at, status,
+      mesh, target_spec, nonce, ciphertext, priority
+    ) VALUES (?, ?, ?, ?, ?, 0, ?, 'pending', ?, ?, ?, ?, ?)
+  `).run(input.id, input.client_message_id, input.request_fingerprint, input.payload, input.now, input.now, input.mesh ?? null, input.target_spec ?? null, input.nonce ?? null, input.ciphertext ?? null, input.priority ?? null);
 }
 function fingerprintsEqual(a, b) {
   if (a.length !== b.length)
@@ -8459,7 +8565,8 @@ function listOutbox(db, p = {}) {
   const sql = `
     SELECT id, client_message_id, request_fingerprint, payload, enqueued_at,
            attempts, next_attempt_at, status, last_error, delivered_at,
-           broker_message_id, aborted_at, aborted_by, superseded_by
+           broker_message_id, aborted_at, aborted_by, superseded_by,
+           mesh, target_spec, nonce, ciphertext, priority
       FROM outbox
      ${where.length ? "WHERE " + where.join(" AND ") : ""}
      ORDER BY enqueued_at DESC
@@ -8472,7 +8579,8 @@ function findById(db, id) {
   return db.prepare(`
     SELECT id, client_message_id, request_fingerprint, payload, enqueued_at,
            attempts, next_attempt_at, status, last_error, delivered_at,
-           broker_message_id, aborted_at, aborted_by, superseded_by
+           broker_message_id, aborted_at, aborted_by, superseded_by,
+           mesh, target_spec, nonce, ciphertext, priority
       FROM outbox WHERE id = ?
   `).get(id) ?? null;
 }
@@ -8615,7 +8723,12 @@ function acceptSend(req, deps) {
         client_message_id: clientId,
         request_fingerprint: fingerprint,
         payload: body,
-        now
+        now,
+        mesh: req.mesh,
+        target_spec: req.target_spec,
+        nonce: req.nonce,
+        ciphertext: req.ciphertext,
+        priority: req.priority
       });
       return { kind: "accepted_pending", status: 202, client_message_id: clientId };
     }
@@ -8796,7 +8909,9 @@ function startIpcServer(opts) {
     inboxDb: opts.inboxDb,
     bus: opts.bus,
     broker: opts.broker,
-    onPendingInserted: opts.onPendingInserted
+    onPendingInserted: opts.onPendingInserted,
+    meshSecretKey: opts.meshSecretKey,
+    meshSlug: opts.meshSlug
   });
   if (existsSync9(DAEMON_PATHS.SOCK_FILE)) {
     try {
@@ -8888,7 +9003,7 @@ function makeHandler(opts) {
       respond(res, 200, {
         daemon_version: VERSION,
         ipc_api: "v1",
-        ipc_features: ["version", "health", "send", "inbox", "events", "peers", "profile"],
+        ipc_features: ["version", "health", "send", "inbox", "events", "peers", "profile", "skills"],
         schema_version: 1
       });
       return;
@@ -8918,6 +9033,42 @@ function makeHandler(opts) {
       }
       return;
     }
+    if (req.method === "GET" && url.pathname === "/v1/skills") {
+      if (!opts.broker) {
+        respond(res, 503, { error: "broker not initialised" });
+        return;
+      }
+      const query = url.searchParams.get("query") ?? undefined;
+      try {
+        const skills = await opts.broker.listSkills(query);
+        respond(res, 200, { skills });
+      } catch (e) {
+        respond(res, 502, { error: "broker_unreachable", detail: String(e) });
+      }
+      return;
+    }
+    if (req.method === "GET" && url.pathname.startsWith("/v1/skills/")) {
+      if (!opts.broker) {
+        respond(res, 503, { error: "broker not initialised" });
+        return;
+      }
+      const name = decodeURIComponent(url.pathname.slice("/v1/skills/".length));
+      if (!name) {
+        respond(res, 400, { error: "missing skill name" });
+        return;
+      }
+      try {
+        const skill = await opts.broker.getSkill(name);
+        if (!skill) {
+          respond(res, 404, { error: "skill_not_found", name });
+          return;
+        }
+        respond(res, 200, { skill });
+      } catch (e) {
+        respond(res, 502, { error: "broker_unreachable", detail: String(e) });
+      }
+      return;
+    }
     if (req.method === "POST" && url.pathname === "/v1/profile") {
       if (!opts.broker) {
         respond(res, 503, { error: "broker not initialised" });
@@ -9066,6 +9217,18 @@ function makeHandler(opts) {
           respond(res, 400, { error: parsed.error });
           return;
         }
+        if (opts.broker && opts.meshSecretKey) {
+          try {
+            const routed = await resolveAndEncrypt(parsed.req, opts.broker, opts.meshSecretKey, opts.meshSlug ?? null);
+            parsed.req.target_spec = routed.target_spec;
+            parsed.req.ciphertext = routed.ciphertext;
+            parsed.req.nonce = routed.nonce;
+            parsed.req.mesh = routed.mesh;
+          } catch (e) {
+            respond(res, 502, { error: "route_failed", detail: String(e) });
+            return;
+          }
+        }
         const outcome = acceptSend(parsed.req, { db: opts.outboxDb });
         switch (outcome.kind) {
           case "accepted_pending":
@@ -9171,6 +9334,48 @@ function parseSendRequest(body, idempotencyHeader) {
     }
   };
 }
+async function resolveAndEncrypt(req, broker, meshSecretKey, meshSlug) {
+  const { encryptDirect: encryptDirect2 } = await Promise.resolve().then(() => (init_box(), exports_box));
+  const { randomBytes: randomBytes5 } = await import("node:crypto");
+  const to = req.to.trim();
+  if (to.startsWith("#") && /^#[0-9a-z_-]{20,}$/i.test(to)) {
+    const ciphertext = Buffer.from(req.message, "utf8").toString("base64");
+    const nonce = randomBytes5(24).toString("base64");
+    return { target_spec: to, ciphertext, nonce, mesh: meshSlug ?? "" };
+  }
+  if (to.startsWith("@") || to === "*") {
+    const ciphertext = Buffer.from(req.message, "utf8").toString("base64");
+    const nonce = randomBytes5(24).toString("base64");
+    return { target_spec: to, ciphertext, nonce, mesh: meshSlug ?? "" };
+  }
+  if (/^[0-9a-f]{64}$/i.test(to)) {
+    const sessionKeys2 = broker.getSessionKeys();
+    const senderSecret2 = sessionKeys2?.sessionSecretKey ?? meshSecretKey;
+    const env3 = await encryptDirect2(req.message, to, senderSecret2);
+    return { target_spec: to, ciphertext: env3.ciphertext, nonce: env3.nonce, mesh: meshSlug ?? "" };
+  }
+  const peers = await broker.listPeers().catch(() => []);
+  if (/^[0-9a-f]{16,63}$/i.test(to)) {
+    const matches2 = peers.filter((p) => p.pubkey.toLowerCase().startsWith(to.toLowerCase()) || (p.memberPubkey ?? "").toLowerCase().startsWith(to.toLowerCase()));
+    if (matches2.length === 0)
+      throw new Error(`no peer matching prefix "${to}"`);
+    if (matches2.length > 1)
+      throw new Error(`prefix "${to}" is ambiguous (${matches2.length} matches)`);
+    const recipient2 = matches2[0].pubkey;
+    const sessionKeys2 = broker.getSessionKeys();
+    const senderSecret2 = sessionKeys2?.sessionSecretKey ?? meshSecretKey;
+    const env3 = await encryptDirect2(req.message, recipient2, senderSecret2);
+    return { target_spec: recipient2, ciphertext: env3.ciphertext, nonce: env3.nonce, mesh: meshSlug ?? "" };
+  }
+  const match = peers.find((p) => p.displayName.toLowerCase() === to.toLowerCase());
+  if (!match)
+    throw new Error(`peer "${to}" not found`);
+  const recipient = match.pubkey;
+  const sessionKeys = broker.getSessionKeys();
+  const senderSecret = sessionKeys?.sessionSecretKey ?? meshSecretKey;
+  const env2 = await encryptDirect2(req.message, recipient, senderSecret);
+  return { target_spec: recipient, ciphertext: env2.ciphertext, nonce: env2.nonce, mesh: meshSlug ?? "" };
+}
 function respond(res, status, body) {
   const json = JSON.stringify(body);
   res.statusCode = status;
@@ -9198,6 +9403,8 @@ class DaemonBrokerClient {
   helloTimer = null;
   pendingAcks = new Map;
   peerListResolvers = new Map;
+  skillListResolvers = new Map;
+  skillDataResolvers = new Map;
   sessionPubkey = null;
   sessionSecretKey = null;
   opens = [];
@@ -9318,6 +9525,26 @@ class DaemonBrokerClient {
           }
           return;
         }
+        if (msg.type === "skill_list") {
+          const reqId = String(msg._reqId ?? "");
+          const pending = this.skillListResolvers.get(reqId);
+          if (pending) {
+            this.skillListResolvers.delete(reqId);
+            clearTimeout(pending.timer);
+            pending.resolve(Array.isArray(msg.skills) ? msg.skills : []);
+          }
+          return;
+        }
+        if (msg.type === "skill_data") {
+          const reqId = String(msg._reqId ?? "");
+          const pending = this.skillDataResolvers.get(reqId);
+          if (pending) {
+            this.skillDataResolvers.delete(reqId);
+            clearTimeout(pending.timer);
+            pending.resolve(msg.skill ?? null);
+          }
+          return;
+        }
         if (msg.type === "push" || msg.type === "inbound") {
           this.opts.onPush?.(msg);
           return;
@@ -9400,6 +9627,44 @@ class DaemonBrokerClient {
       }
     });
   }
+  async listSkills(query, timeoutMs = 5000) {
+    if (this._status !== "open" || !this.ws)
+      return [];
+    return new Promise((resolve) => {
+      const reqId = `sl-${++this.reqCounter}`;
+      const timer = setTimeout(() => {
+        if (this.skillListResolvers.delete(reqId))
+          resolve([]);
+      }, timeoutMs);
+      this.skillListResolvers.set(reqId, { resolve, timer });
+      try {
+        this.ws.send(JSON.stringify({ type: "list_skills", query, _reqId: reqId }));
+      } catch {
+        this.skillListResolvers.delete(reqId);
+        clearTimeout(timer);
+        resolve([]);
+      }
+    });
+  }
+  async getSkill(name, timeoutMs = 5000) {
+    if (this._status !== "open" || !this.ws)
+      return null;
+    return new Promise((resolve) => {
+      const reqId = `sg-${++this.reqCounter}`;
+      const timer = setTimeout(() => {
+        if (this.skillDataResolvers.delete(reqId))
+          resolve(null);
+      }, timeoutMs);
+      this.skillDataResolvers.set(reqId, { resolve, timer });
+      try {
+        this.ws.send(JSON.stringify({ type: "get_skill", name, _reqId: reqId }));
+      } catch {
+        this.skillDataResolvers.delete(reqId);
+        clearTimeout(timer);
+        resolve(null);
+      }
+    });
+  }
   setProfile(profile) {
     if (this._status !== "open" || !this.ws)
       return;
@@ -9518,7 +9783,8 @@ function startDrainWorker(opts) {
 async function drainOnce(opts, log2) {
   const now = Date.now();
   const rows = opts.db.prepare(`
-    SELECT id, client_message_id, request_fingerprint, payload, attempts
+    SELECT id, client_message_id, request_fingerprint, payload, attempts,
+           target_spec, nonce, ciphertext, priority, mesh
       FROM outbox
      WHERE status = 'pending' AND next_attempt_at <= ?
      ORDER BY enqueued_at
@@ -9530,15 +9796,26 @@ async function drainOnce(opts, log2) {
     if (markInflight(opts.db, row.id, now) === 0)
       continue;
     const fpHex = bufferToHex(row.request_fingerprint);
-    const sessionKeys = opts.broker.getSessionKeys();
-    const targetSpec = "*";
-    const nonce = await randomNonce2();
-    const ciphertext = Buffer.from(row.payload).toString("base64");
+    let targetSpec;
+    let nonce;
+    let ciphertext;
+    let priority;
+    if (row.target_spec && row.nonce && row.ciphertext) {
+      targetSpec = row.target_spec;
+      nonce = row.nonce;
+      ciphertext = row.ciphertext;
+      priority = row.priority === "now" || row.priority === "low" ? row.priority : "next";
+    } else {
+      targetSpec = "*";
+      nonce = await randomNonce2();
+      ciphertext = Buffer.from(row.payload).toString("base64");
+      priority = "next";
+    }
     let res;
     try {
       res = await opts.broker.send({
         targetSpec,
-        priority: "next",
+        priority,
         nonce,
         ciphertext,
         client_message_id: row.client_message_id,
@@ -9626,11 +9903,14 @@ async function handleBrokerPush(msg, ctx) {
   const brokerMessageId = stringOrNull(msg.messageId);
   const senderPubkey = stringOrNull(msg.senderPubkey) ?? "";
   const senderName = stringOrNull(msg.senderName) ?? senderPubkey.slice(0, 8);
+  const senderMemberPk = stringOrNull(msg.senderMemberPubkey);
   const topic = stringOrNull(msg.topic);
   const replyToId = stringOrNull(msg.replyToId);
   const ciphertext = stringOrNull(msg.ciphertext) ?? "";
   const nonce = stringOrNull(msg.nonce) ?? "";
   const createdAt = stringOrNull(msg.createdAt);
+  const priority = stringOrNull(msg.priority) ?? "next";
+  const subtype = stringOrNull(msg.subtype);
   const clientMessageId = stringOrNull(msg.client_message_id) ?? brokerMessageId ?? randomUUID5();
   const body = await decryptOrFallback({
     ciphertext,
@@ -9660,9 +9940,12 @@ async function handleBrokerPush(msg, ctx) {
     client_message_id: clientMessageId,
     broker_message_id: brokerMessageId,
     sender_pubkey: senderPubkey,
+    sender_member_pubkey: senderMemberPk,
     sender_name: senderName,
     topic,
     reply_to_id: replyToId,
+    priority,
+    ...subtype ? { subtype } : {},
     body,
     created_at: createdAt
   });
@@ -9946,7 +10229,9 @@ async function runDaemon(opts = {}) {
     inboxDb,
     bus,
     broker,
-    onPendingInserted: () => drain?.wake()
+    onPendingInserted: () => drain?.wake(),
+    meshSecretKey: mesh.secretKey,
+    meshSlug: mesh.slug
   });
   try {
     await ipc2.ready;
@@ -10761,6 +11046,7 @@ function installStatusLine() {
 function runInstall(args = []) {
   const skipHooks = args.includes("--no-hooks");
   const skipSkill = args.includes("--no-skill");
+  const skipService = args.includes("--no-service");
   const wantStatusLine = args.includes("--status-line");
   render.section("claudemesh install");
   const entry = resolveEntry();
@@ -10842,10 +11128,25 @@ function runInstall(args = []) {
     }
   }
   let hasMeshes = false;
+  let primaryMesh;
   try {
     const meshConfig = readConfig();
     hasMeshes = meshConfig.meshes.length > 0;
+    primaryMesh = meshConfig.meshes[0]?.slug;
   } catch {}
+  if (!skipService && hasMeshes && primaryMesh) {
+    try {
+      installDaemonService(entry, primaryMesh);
+    } catch (e) {
+      render.warn(`daemon service install failed: ${e instanceof Error ? e.message : String(e)}`, "Run `claudemesh daemon install-service --mesh <slug>` to retry.");
+    }
+  } else if (skipService) {
+    render.info(dim("· Daemon service skipped (--no-service)"));
+    render.info(dim("  MCP integration will fail at boot until you start the daemon manually:"));
+    render.info(dim("    claudemesh daemon up --mesh <slug>"));
+  } else if (!hasMeshes) {
+    render.info(dim("· Daemon service deferred — join a mesh first, then run install again."));
+  }
   render.blank();
   render.warn(`${bold("RESTART CLAUDE CODE")} ${yellow("for MCP tools to appear.")}`);
   if (!hasMeshes) {
@@ -10863,6 +11164,40 @@ function runInstall(args = []) {
   render.info(dim(`  claudemesh install --status-line # live peer count in Claude Code`));
   render.info(dim(`  claudemesh completions zsh       # shell completions`));
 }
+function installDaemonService(binaryEntry, meshSlug) {
+  const {
+    installService: installService2,
+    detectPlatform: detectPlatform2
+  } = (init_service_install(), __toCommonJS(exports_service_install));
+  const platform6 = detectPlatform2();
+  if (!platform6) {
+    render.info(dim(`· Daemon service skipped — unsupported platform: ${process.platform}`));
+    return;
+  }
+  let binary = process.argv[1] ?? binaryEntry;
+  if (!binary || /\.ts$/.test(binary) || /node_modules|src\/entrypoints/.test(binary)) {
+    try {
+      const { execSync: execSync3 } = __require("node:child_process");
+      binary = execSync3("which claudemesh", { encoding: "utf8" }).trim();
+    } catch {
+      render.warn("couldn't resolve a 'claudemesh' binary on PATH; daemon service skipped", "Install via npm/homebrew, then run `claudemesh daemon install-service --mesh " + meshSlug + "`");
+      return;
+    }
+  }
+  const r = installService2({ binaryPath: binary, meshSlug });
+  render.ok(`daemon service installed (${r.platform})`);
+  render.kv([
+    ["unit", dim(r.unitPath)],
+    ["mesh", dim(meshSlug)]
+  ]);
+  try {
+    const { execSync: execSync3 } = __require("node:child_process");
+    execSync3(r.bootCommand, { stdio: "ignore" });
+    render.ok("daemon started");
+  } catch (e) {
+    render.warn(`daemon service installed but failed to start: ${e instanceof Error ? e.message : String(e)}`, `Run manually: ${r.bootCommand}`);
+  }
+}
 function runUninstall() {
   render.section("claudemesh uninstall");
   if (removeMcpServer()) {
@@ -13093,6 +13428,32 @@ async function runSqlSchema(opts) {
   });
 }
 async function runSkillList(opts) {
+  try {
+    const { tryListSkillsViaDaemon: tryListSkillsViaDaemon2 } = await Promise.resolve().then(() => (init_daemon_route(), exports_daemon_route));
+    const dr = await tryListSkillsViaDaemon2();
+    if (dr !== null) {
+      const skills = dr;
+      if (opts.json) {
+        emitJson(skills);
+        return EXIT.SUCCESS;
+      }
+      if (skills.length === 0) {
+        render.info(dim("(no skills)"));
+        return EXIT.SUCCESS;
+      }
+      render.section(`mesh skills (${skills.length})`);
+      for (const s of skills) {
+        process.stdout.write(`  ${bold(s.name)} ${dim("· by " + s.author)}
+`);
+        process.stdout.write(`    ${s.description}
+`);
+        if (s.tags?.length)
+          process.stdout.write(`    ${dim("tags: " + s.tags.join(", "))}
+`);
+      }
+      return EXIT.SUCCESS;
+    }
+  } catch {}
   return await withMesh({ meshSlug: opts.mesh ?? null }, async (client) => {
     const skills = await client.listSkills(opts.query);
     if (opts.json) {
@@ -13121,6 +13482,29 @@ async function runSkillGet(name, opts) {
     render.err("Usage: claudemesh skill get <name>");
     return EXIT.INVALID_ARGS;
   }
+  try {
+    const { tryGetSkillViaDaemon: tryGetSkillViaDaemon2 } = await Promise.resolve().then(() => (init_daemon_route(), exports_daemon_route));
+    const dr = await tryGetSkillViaDaemon2(name);
+    if (dr !== null) {
+      const skill = dr;
+      if (opts.json) {
+        emitJson(skill);
+        return EXIT.SUCCESS;
+      }
+      render.section(skill.name);
+      render.kv([
+        ["author", skill.author],
+        ["created", skill.createdAt],
+        ["tags", skill.tags?.join(", ") || dim("(none)")]
+      ]);
+      render.blank();
+      render.info(skill.description);
+      render.blank();
+      process.stdout.write(skill.instructions + `
+`);
+      return EXIT.SUCCESS;
+    }
+  } catch {}
   return await withMesh({ meshSlug: opts.mesh ?? null }, async (client) => {
     const skill = await client.getSkill(name);
     if (!skill) {
@@ -13638,7 +14022,7 @@ claudemesh send "<from_name>" "..." --mesh "<mesh_slug>"
 
 If the parent Claude session was launched via \`claudemesh launch\`, an MCP push-pipe is running and holds the per-mesh WS connection. CLI invocations dial \`~/.claudemesh/sockets/<mesh-slug>.sock\` and reuse that warm connection (~200ms total round-trip including Node.js startup). If no push-pipe is running (cron, scripts, hooks fired outside a session), the CLI opens its own WS, which takes ~500-700ms cold. **You don't manage this** — every verb auto-detects and falls through.
 
-### Daemon path (v0.9.0, opt-in, fastest)
+### Daemon path (v1.24.0+, REQUIRED for in-Claude-Code use)
 
 \`claudemesh daemon up [--mesh <slug>]\` starts a persistent per-user runtime that holds the broker WS, a durable SQLite outbox/inbox, and listens on \`~/.claudemesh/daemon/daemon.sock\` (UDS) plus an optional loopback TCP. When the daemon socket is present, every verb routes through it first (~1ms IPC) before falling back to bridge / cold paths. The send envelope carries a caller-stable \`client_message_id\`, so a \`claudemesh send\` that started before a daemon crash survives the restart via the on-disk outbox.
 
@@ -13653,11 +14037,15 @@ claudemesh daemon outbox requeue <id>                  # re-enqueue an aborted/d
 claudemesh daemon down                                 # SIGTERM + wait
 \`\`\`
 
-\`claudemesh install\` (MCP + hooks registration) and the daemon are independent — install does not start the daemon, and the daemon does not require install. Run both for the warmest path: install gives you the in-session push-pipe, daemon gives you cross-invocation persistence and a survivable outbox.
+As of 1.24.0 \`claudemesh install\` registers the MCP entry **and** installs/starts the daemon service for the user's primary mesh. The MCP shim hard-requires the daemon to be running — it bails at boot with actionable instructions if the socket isn't present. There is no fallback. CLI verbs (\`send\`, \`peer list\`, \`inbox\`, \`skill list/get\`, etc.) keep working without a daemon via bridge or cold paths, but for any in-Claude-Code use the daemon must be up.
+
+### Ambient mode (1.25.0+)
+
+Once \`claudemesh install\` has run (registers MCP entry + starts daemon service), **raw \`claude\` Just Works** for the daemon's attached mesh. No \`claudemesh launch\` ceremony, no manual flags, no per-session keypair. Channel push, slash commands, and resources all flow through the daemon-backed MCP shim. Use \`claudemesh launch\` only when you need to override defaults (different mesh, custom display name, system-prompt injection, headless modes).
 
 ## Spawning new sessions (no wizard)
 
-\`claudemesh launch\` is the canonical way to start a new Claude Code session connected to claudemesh. Pass every required flag up front so no interactive prompt fires — that's what makes the verb scriptable from tmux send-keys, AppleScript/iTerm spawn helpers, hooks, cron, and the \`claudemesh launch\` you call from inside another session. **Always use this verb, never \`claude\` directly with hand-rolled flags** — it sets up the per-session ed25519 keypair, exports \`CLAUDEMESH_DISPLAY_NAME\`, isolates the mesh config in a tmpdir, and passes the \`--dangerously-load-development-channels server:claudemesh\` plumbing that the MCP push-pipe needs.
+\`claudemesh launch\` remains useful for non-default cases: explicit mesh selection, fresh display name, headless \`--quiet\` runs, system-prompt injection, multi-mesh users with one daemon attached to mesh A who want to spawn into mesh B. For the common case (single joined mesh, daemon installed), prefer raw \`claude\`. Pass every required flag up front so no interactive prompt fires — that's what makes the verb scriptable from tmux send-keys, AppleScript/iTerm spawn helpers, hooks, cron, and the \`claudemesh launch\` you call from inside another session.
 
 ### Full flag surface
 
@@ -15958,435 +16346,194 @@ var init_member = __esm(() => {
   init_exit_codes();
 });
 
-// src/mcp/tools/definitions.ts
-var TOOLS;
-var init_definitions = __esm(() => {
-  TOOLS = [];
-});
-
-// src/services/bridge/server.ts
-import { createServer as createServer3 } from "node:net";
-import { mkdirSync as mkdirSync12, unlinkSync as unlinkSync5, existsSync as existsSync28, chmodSync as chmodSync6 } from "node:fs";
-async function resolveTarget2(client, to) {
-  if (to.startsWith("@") || to === "*" || /^[0-9a-f]{64}$/i.test(to)) {
-    return { ok: true, spec: to };
-  }
-  const peers = await client.listPeers();
-  const match = peers.find((p) => p.displayName.toLowerCase() === to.toLowerCase());
-  if (!match) {
-    return {
-      ok: false,
-      error: `peer "${to}" not found. online: ${peers.map((p) => p.displayName).join(", ") || "(none)"}`
-    };
+// src/mcp/server.ts
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import {
+  ListToolsRequestSchema,
+  CallToolRequestSchema,
+  ListPromptsRequestSchema,
+  GetPromptRequestSchema,
+  ListResourcesRequestSchema,
+  ReadResourceRequestSchema
+} from "@modelcontextprotocol/sdk/types.js";
+import { existsSync as existsSync28 } from "node:fs";
+import { request as httpRequest2 } from "node:http";
+async function daemonReady() {
+  for (let i = 0;i < DAEMON_BOOT_RETRIES; i++) {
+    if (existsSync28(DAEMON_PATHS.SOCK_FILE))
+      return true;
+    await new Promise((r) => setTimeout(r, DAEMON_BOOT_RETRY_MS));
   }
-  return { ok: true, spec: match.pubkey };
+  return false;
 }
-async function dispatch(client, req) {
-  const args = req.args ?? {};
-  try {
-    switch (req.verb) {
-      case "ping": {
-        const peers = await client.listPeers();
-        return {
-          id: req.id,
-          ok: true,
-          result: {
-            mesh: client.meshSlug,
-            ws_status: client.status,
-            peers_online: peers.length,
-            push_buffer: client.pushHistory.length
-          }
-        };
-      }
-      case "peers": {
-        const peers = await client.listPeers();
-        return { id: req.id, ok: true, result: peers };
-      }
-      case "send": {
-        const to = String(args.to ?? "");
-        const message = String(args.message ?? "");
-        const priority = args.priority ?? "next";
-        if (!to || !message) {
-          return { id: req.id, ok: false, error: "send: `to` and `message` required" };
-        }
-        const resolved = await resolveTarget2(client, to);
-        if (!resolved.ok)
-          return { id: req.id, ok: false, error: resolved.error };
-        const result = await client.send(resolved.spec, message, priority);
-        if (!result.ok) {
-          return { id: req.id, ok: false, error: result.error ?? "send failed" };
-        }
-        return {
-          id: req.id,
-          ok: true,
-          result: { messageId: result.messageId, target: resolved.spec }
-        };
-      }
-      case "summary": {
-        const text = String(args.summary ?? "");
-        if (!text)
-          return { id: req.id, ok: false, error: "summary: `summary` required" };
-        await client.setSummary(text);
-        return { id: req.id, ok: true, result: { summary: text } };
-      }
-      case "status_set": {
-        const state = String(args.status ?? "");
-        if (!["idle", "working", "dnd"].includes(state)) {
-          return { id: req.id, ok: false, error: "status_set: must be idle | working | dnd" };
-        }
-        await client.setStatus(state);
-        return { id: req.id, ok: true, result: { status: state } };
-      }
-      case "visible": {
-        const visible = Boolean(args.visible);
-        await client.setVisible(visible);
-        return { id: req.id, ok: true, result: { visible } };
-      }
-      default:
-        return { id: req.id, ok: false, error: `unknown verb: ${req.verb}` };
-    }
-  } catch (err) {
-    return {
-      id: req.id,
-      ok: false,
-      error: err instanceof Error ? err.message : String(err)
-    };
-  }
+function bailNoDaemon() {
+  process.stderr.write(`[claudemesh] daemon is not running.
+` + `  Start it:               claudemesh daemon up --mesh <slug>
+` + `  Or install as service:  claudemesh daemon install-service --mesh <slug>
+` + `  Diagnose:               claudemesh doctor
+` + `
+` + `  As of 1.24.0 the daemon is required for in-Claude-Code use of
+` + `  claudemesh. The CLI itself (claudemesh send/peer/inbox/...) still
+` + `  works without a daemon.
+`);
+  process.exit(1);
 }
-function handleConnection(socket, client) {
-  const parser = new LineParser;
-  socket.on("data", (chunk) => {
-    const lines = parser.feed(chunk);
-    for (const line of lines) {
-      if (!line.trim())
-        continue;
-      let req;
-      try {
-        req = JSON.parse(line);
-      } catch {
-        continue;
-      }
-      if (!req || typeof req !== "object" || !req.id || !req.verb)
-        continue;
-      dispatch(client, req).then((res) => {
+function daemonGet(path2) {
+  return new Promise((resolve3, reject) => {
+    const req = httpRequest2({ socketPath: DAEMON_PATHS.SOCK_FILE, path: path2, method: "GET", timeout: 5000 }, (res) => {
+      const chunks = [];
+      res.on("data", (c) => chunks.push(c));
+      res.on("end", () => {
+        const text = Buffer.concat(chunks).toString("utf8");
+        let body = null;
         try {
-          socket.write(frame(res));
-        } catch {}
+          body = JSON.parse(text);
+        } catch {
+          body = text;
+        }
+        resolve3({ status: res.statusCode ?? 0, body });
       });
-    }
+    });
+    req.on("error", reject);
+    req.on("timeout", () => req.destroy(new Error("daemon_ipc_timeout")));
+    req.end();
   });
-  socket.on("error", () => {});
 }
-function startBridgeServer(client) {
-  const path2 = socketPath(client.meshSlug);
-  const dir = socketDir();
-  if (!existsSync28(dir)) {
-    mkdirSync12(dir, { recursive: true, mode: 448 });
-  }
-  if (existsSync28(path2)) {
-    try {
-      unlinkSync5(path2);
-    } catch {}
-  }
-  const server = createServer3((socket) => handleConnection(socket, client));
-  try {
-    server.listen(path2);
-  } catch (err) {
-    process.stderr.write(`[claudemesh] bridge: failed to bind ${path2}: ${String(err)}
+function subscribeEvents(onEvent) {
+  let active = true;
+  let req = null;
+  const connect = () => {
+    if (!active)
+      return;
+    req = httpRequest2({
+      socketPath: DAEMON_PATHS.SOCK_FILE,
+      path: "/v1/events",
+      method: "GET",
+      headers: { Accept: "text/event-stream" }
+    });
+    let buffer = "";
+    req.on("response", (res) => {
+      res.setEncoding("utf8");
+      res.on("data", (chunk) => {
+        buffer += chunk;
+        let idx;
+        while ((idx = buffer.indexOf(`
+
+`)) >= 0) {
+          const block = buffer.slice(0, idx);
+          buffer = buffer.slice(idx + 2);
+          if (!block.trim())
+            continue;
+          let kind = "message";
+          let dataLine = "";
+          for (const line of block.split(`
+`)) {
+            if (line.startsWith(":"))
+              continue;
+            if (line.startsWith("event:"))
+              kind = line.slice(6).trim();
+            else if (line.startsWith("data:"))
+              dataLine = line.slice(5).trim();
+          }
+          if (!dataLine)
+            continue;
+          try {
+            const parsed = JSON.parse(dataLine);
+            onEvent({ kind, ts: String(parsed.ts ?? ""), data: parsed });
+          } catch {}
+        }
+      });
+      res.on("end", () => {
+        if (active) {
+          process.stderr.write(`[claudemesh-mcp] sse stream ended; reconnecting in 1s
 `);
-    return null;
-  }
-  server.on("error", (err) => {
-    process.stderr.write(`[claudemesh] bridge: ${String(err)}
+          setTimeout(connect, 1000);
+        }
+      });
+      res.on("error", (err) => process.stderr.write(`[claudemesh-mcp] sse error: ${err.message}
+`));
+    });
+    req.on("error", (err) => {
+      process.stderr.write(`[claudemesh-mcp] sse connect error: ${err.message}
 `);
-  });
-  try {
-    chmodSync6(path2, 384);
-  } catch {}
-  let stopped = false;
+      if (active)
+        setTimeout(connect, 2000);
+    });
+    req.end();
+  };
+  connect();
   return {
-    path: path2,
-    stop() {
-      if (stopped)
-        return;
-      stopped = true;
-      try {
-        server.close();
-      } catch {}
+    close: () => {
+      active = false;
       try {
-        unlinkSync5(path2);
+        req?.destroy();
       } catch {}
     }
   };
 }
-var init_server2 = __esm(() => {
-  init_protocol();
-});
-
-// src/mcp/server.ts
-import { Server } from "@modelcontextprotocol/sdk/server/index.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import {
-  ListToolsRequestSchema,
-  CallToolRequestSchema,
-  ListPromptsRequestSchema,
-  GetPromptRequestSchema,
-  ListResourcesRequestSchema,
-  ReadResourceRequestSchema
-} from "@modelcontextprotocol/sdk/types.js";
-function relativeTime(isoStr) {
-  const then = new Date(isoStr).getTime();
-  if (isNaN(then))
-    return "unknown";
-  const diffMs = Date.now() - then;
-  if (diffMs < 0)
-    return "just now";
-  const seconds = Math.floor(diffMs / 1000);
-  if (seconds < 60)
-    return `${seconds}s ago`;
-  const minutes = Math.floor(seconds / 60);
-  if (minutes < 60)
-    return `${minutes}m ago`;
-  const hours = Math.floor(minutes / 60);
-  if (hours < 24)
-    return `${hours}h ago`;
-  const days = Math.floor(hours / 24);
-  return `${days} day${days !== 1 ? "s" : ""} ago`;
-}
-async function resolvePeerName(client, pubkey) {
-  const now = Date.now();
-  if (now - peerNameCacheAge > CACHE_TTL_MS) {
-    peerNameCache.clear();
-    try {
-      const peers = await client.listPeers();
-      for (const p of peers)
-        peerNameCache.set(p.pubkey, p.displayName);
-    } catch {}
-    peerNameCacheAge = now;
-  }
-  return peerNameCache.get(pubkey) ?? `peer-${pubkey.slice(0, 8)}`;
-}
-function decryptFailedWarning(senderPubkey) {
-  const who = senderPubkey ? senderPubkey.slice(0, 12) + "…" : "unknown sender";
-  return `⚠ message from ${who} failed to decrypt (tampered or wrong keypair)`;
-}
 async function startMcpServer() {
   const serviceIdx = process.argv.indexOf("--service");
   if (serviceIdx !== -1 && process.argv[serviceIdx + 1]) {
     return startServiceProxy(process.argv[serviceIdx + 1]);
   }
-  const meshIdx = process.argv.indexOf("--mesh");
-  const onlyMesh = meshIdx !== -1 ? process.argv[meshIdx + 1] : null;
-  const config = readConfig();
-  if (onlyMesh) {
-    const available = config.meshes.map((m) => m.slug);
-    const filtered = config.meshes.filter((m) => m.slug === onlyMesh);
-    if (filtered.length === 0) {
-      process.stderr.write(`[claudemesh] --mesh "${onlyMesh}" not found in config. ` + `Joined meshes: ${available.join(", ") || "(none)"}
-`);
-      process.exit(1);
-    }
-    config.meshes = filtered;
-  }
-  const myName = config.displayName ?? "unnamed";
-  const myRole = config.role ?? process.env.CLAUDEMESH_ROLE ?? null;
-  const myGroups = (config.groups ?? []).map((g) => `@${g.name}${g.role ? ":" + g.role : ""}`).join(", ") || "none";
-  const messageMode = config.messageMode ?? "push";
-  const server = new Server({ name: "claudemesh", version: "0.3.0" }, {
-    capabilities: {
-      experimental: { "claude/channel": {} },
-      tools: {},
-      prompts: {},
-      resources: {}
-    },
-    instructions: `## Identity
-You are "${myName}"${myRole ? ` (${myRole})` : ""} — a peer in the claudemesh network. Your groups: ${myGroups}. You are one of several Claude Code sessions connected to the same mesh. No orchestrator exists — peers are equals. Your identity comes from your name and group roles, not from a central authority.
-
-## Responding to messages
-When you receive a <channel source="claudemesh" ...> message, RESPOND IMMEDIATELY. Pause your current task, reply via send_message (or \`claudemesh topic post --reply-to <message_id>\` for topic threads), then resume. Stay in character per your system prompt. Do not ignore low-priority messages — acknowledge them briefly even if you defer action.
-
-The channel attributes carry everything you need to reply — no extra lookups:
-- \`from_name\` — sender display name. Use as the \`to\` arg when replying to a DM.
-- \`from_pubkey\` / \`from_member_id\` — stable ids. Use \`from_member_id\` if the sender's display name might change.
-- \`mesh_slug\` — pass via \`--mesh\` if your default mesh differs.
-- \`priority\` — \`now\` / \`next\` / \`low\`.
-- \`message_id\` — id of THIS message. To thread a reply onto it in a topic, run \`claudemesh topic post <topic> "<text>" --reply-to <message_id>\`.
-- \`topic\` — set when the message arrived through a topic (vs DM). Reply in the same topic.
-- \`reply_to_id\` — set when the incoming message is itself a reply. Render thread context if you re-narrate.
-
-If the channel meta contains \`subtype: reminder\`, this is a scheduled reminder you set for yourself — act on it immediately (no reply needed).
-
-## Tools
-| Tool | Description |
-|------|-------------|
-| send_message(to, message, priority?) | Send to peer name, @group, or * broadcast. \`to\` accepts display name, pubkey hex, @groupname, or *. |
-| list_peers(mesh_slug?) | List connected peers with status, summary, groups, and roles. |
-| check_messages() | Drain buffered inbound messages (auto-pushed in most cases, use as fallback). |
-| set_summary(summary) | Set 1-2 sentence description of your current work, visible to all peers. |
-| set_status(status) | Override status: idle, working, or dnd. |
-| set_visible(visible) | Toggle visibility. Hidden peers skip list_peers and broadcasts; direct messages still arrive. |
-| set_profile(avatar?, title?, bio?, capabilities?) | Set public profile: emoji avatar, short title, bio, capabilities list. |
-| join_group(name, role?) | Join a @group with optional role (lead, member, observer, or any string). |
-| leave_group(name) | Leave a @group. |
-| set_state(key, value) | Write shared state; pushes change to all peers. |
-| get_state(key) | Read a shared state value. |
-| list_state() | List all state keys with values, authors, and timestamps. |
-| remember(content, tags?) | Store persistent knowledge with optional tags. |
-| recall(query) | Full-text search over mesh memory. |
-| forget(id) | Soft-delete a memory entry. |
-| claudemesh file share <path> [--to peer] [--tags a,b] | Share a file with the mesh, or DM it to a specific peer. Same-host fast path: when --to matches a peer on this machine, sends an absolute filepath instead of uploading (no MinIO round-trip). |
-| claudemesh file get <id> [--out path] | Download a shared file by id. |
-| claudemesh file list [query] | Find files shared in the mesh. |
-| claudemesh file status <id> | Check who has accessed a file. |
-| claudemesh file delete <id> | Remove a shared file from the mesh. |
-| vector_store(collection, text, metadata?) | Store embedding in per-mesh Qdrant collection. |
-| vector_search(collection, query, limit?) | Semantic search over stored embeddings. |
-| vector_delete(collection, id) | Remove an embedding. |
-| list_collections() | List vector collections in this mesh. |
-| graph_query(cypher) | Read-only Cypher query on per-mesh Neo4j. |
-| graph_execute(cypher) | Write Cypher query (CREATE, MERGE, DELETE). |
-| mesh_query(sql) | Run a SELECT query on the per-mesh shared database. |
-| mesh_execute(sql) | Run DDL/DML on the per-mesh database (CREATE TABLE, INSERT, UPDATE, DELETE). |
-| mesh_schema() | List tables and columns in the per-mesh shared database. |
-| create_stream(name) | Create a real-time data stream in the mesh. |
-| publish(stream, data) | Push data to a stream. Subscribers receive it in real-time. |
-| subscribe(stream) | Subscribe to a stream. Data pushes arrive as channel notifications. |
-| list_streams() | List active streams in the mesh. |
-| share_context(summary, files_read?, key_findings?, tags?) | Share session understanding with peers. |
-| get_context(query) | Find context from peers who explored an area. |
-| list_contexts() | See what all peers currently know. |
-| create_task(title, assignee?, priority?, tags?) | Create a work item. |
-| claim_task(id) | Claim an unclaimed task. |
-| complete_task(id, result?) | Mark task done with optional result. |
-| list_tasks(status?, assignee?) | List tasks filtered by status/assignee. |
-| schedule_reminder(message, in_seconds?, deliver_at?, to?) | Schedule a reminder to yourself (no \`to\`) or a delayed message to a peer/group. Delivered as a push with \`subtype: reminder\` in the channel meta. |
-| list_scheduled() | List pending scheduled reminders and messages. |
-| cancel_scheduled(id) | Cancel a pending scheduled item. |
-| read_peer_file(peer, path) | Read a file from another peer's project (max 1MB). |
-| list_peer_files(peer, path?, pattern?) | List files in a peer's shared directory. |
-| mesh_mcp_register(server_name, description, tools) | Register an MCP server with the mesh. Other peers can call its tools. |
-| mesh_mcp_list() | List MCP servers available in the mesh with their tools. |
-| mesh_tool_call(server_name, tool_name, args?) | Call a tool on a mesh-registered MCP server (30s timeout). |
-| mesh_mcp_remove(server_name) | Unregister an MCP server you registered. |
-
-If multiple meshes are joined, prefix \`to\` with \`<mesh-slug>:\` to disambiguate (e.g. \`dev-team:Alice\`).
-
-Multi-target: send_message accepts an array of targets for the 'to' field.
-  send_message(to: ["Alice", "@backend"], message: "sprint starts")
-Targets are deduplicated — each peer receives the message once.
-
-Targeted views: when different audiences need different details about the same event,
-send tailored messages instead of one generic broadcast:
-  send_message(to: "@frontend", message: "Auth v2: useAuth hook changed, see src/auth/")
-  send_message(to: "@backend", message: "Auth v2: new /api/auth/v2 endpoints, v1 deprecated")
-  send_message(to: "@pm", message: "Auth v2 done. 3 points, no blockers.")
-
-## Groups
-Groups are routing labels. Send to @groupname to multicast to all members. Roles are metadata that peers interpret: a "lead" gathers input before synthesizing a response, a "member" contributes when asked, an "observer" watches silently. Join and leave groups dynamically with join_group/leave_group. Check list_peers to see who belongs to which groups and their roles.
-
-## State
-Shared key-value store scoped to the mesh. Use get_state/set_state for live coordination facts (deploy frozen? current sprint? PR queue). set_state pushes the change to all connected peers. Read state before asking peers questions — the answer may already be there. State is operational, not archival.
-
-## Memory
-Persistent knowledge that survives across sessions. Use remember(content, tags?) to store lessons, decisions, and incidents. Use recall(query) to search before asking peers. New peers should recall at session start to load institutional knowledge.
-
-## File access — decision guide
-Three ways to access files. Pick the right one:
-
-1. **Local peer (same machine, [local] tag):** Read files directly via filesystem using their \`cwd\` path from list_peers. No limit, instant. This is the default for local peers.
-2. **Remote peer (different machine, [remote] tag):** Use \`read_peer_file(peer, path)\` — relays through the mesh. **1 MB limit**, base64 encoded. Use \`list_peer_files\` to browse first.
-3. **Persistent sharing (any peer):** Use \`share_file(path)\` — uploads to mesh storage (MinIO). **No size limit**. All peers can download anytime via \`get_file\`. Use for files that need to persist or be shared with multiple peers.
-
-**Rule of thumb:** local peer → filesystem. Remote peer, small file → read_peer_file. Large file or needs to persist → share_file.
-
-## Vectors
-Store and search semantic embeddings. Use vector_store to index content, vector_search to find similar content.
-
-## Graph
-Build and query entity relationship graphs. Use graph_execute for writes (CREATE, MERGE), graph_query for reads (MATCH).
-
-## Mesh Database
-Per-mesh PostgreSQL database. Use mesh_execute for DDL/DML (CREATE TABLE, INSERT), mesh_query for SELECT, mesh_schema to inspect tables. Schema auto-created on first use.
-
-## Streams
-Real-time data channels. create_stream to start one, publish to push data, subscribe to receive pushes. Use for build logs, deploy status, live metrics.
-
-## Context
-Share your session understanding with peers. Use share_context after exploring a codebase area. Check get_context before re-reading files another peer already analyzed.
-
-## Tasks
-Create and claim work items. create_task to propose work, claim_task to take ownership, complete_task when done. Prevents duplicate effort.
-
-## Priority
-- "now": interrupt immediately, even if recipient is in DND (use for urgent: broken deploy, blocking issue)
-- "next" (default): deliver when recipient goes idle (normal coordination)
-- "low": pull-only via check_messages (FYI, non-blocking context)
-
-## Coordination
-Call list_peers at session start to understand who is online, their roles, and what they are working on. If you are a group lead, gather input from members before responding to external requests — do not answer alone. If you are a member, contribute to your lead when asked. Use @group messages for team-wide questions, direct messages for 1:1 coordination. Set a meaningful summary so peers know your current focus.
-
-## Message Mode
-Your message mode is "${messageMode}".
-- push: messages arrive in real-time as channel notifications. Respond immediately.
-- inbox: messages are held. You'll see "[inbox] New message from X" notifications. Call check_messages to read them.
-- off: no message notifications. Use check_messages manually to poll.`
-  });
-  server.setRequestHandler(ListToolsRequestSchema, async () => ({
-    tools: TOOLS
-  }));
+  const ok = await daemonReady();
+  if (!ok)
+    bailNoDaemon();
+  const server = new Server({ name: "claudemesh", version: VERSION }, { capabilities: { tools: {}, prompts: {}, resources: {} } });
+  server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: [] }));
   server.setRequestHandler(ListPromptsRequestSchema, async () => {
-    const client = allClients()[0];
-    if (!client)
+    try {
+      const { status, body } = await daemonGet("/v1/skills");
+      if (status !== 200)
+        return { prompts: [] };
+      const skills = body?.skills ?? [];
+      return { prompts: skills.map((s) => ({ name: s.name, description: s.description, arguments: [] })) };
+    } catch {
       return { prompts: [] };
-    const skills = await client.listSkills();
-    return {
-      prompts: skills.map((s) => ({
-        name: s.name,
-        description: s.description,
-        arguments: []
-      }))
-    };
+    }
   });
   server.setRequestHandler(GetPromptRequestSchema, async (req) => {
-    const { name, arguments: promptArgs } = req.params;
-    const client = allClients()[0];
-    if (!client)
-      throw new Error("Not connected to any mesh");
-    const skill = await client.getSkill(name);
-    if (!skill)
+    const name = req.params.name;
+    const { status, body } = await daemonGet(`/v1/skills/${encodeURIComponent(name)}`);
+    if (status === 404)
       throw new Error(`Skill "${name}" not found in the mesh`);
+    if (status !== 200)
+      throw new Error(`daemon returned ${status} fetching skill`);
+    const skill = body.skill;
     let content = skill.instructions;
-    const manifest = skill.manifest;
-    if (manifest && typeof manifest === "object") {
+    const m = skill.manifest;
+    if (m && typeof m === "object") {
       const fm = ["---"];
-      if (manifest.description)
-        fm.push(`description: "${manifest.description}"`);
-      if (manifest.when_to_use)
-        fm.push(`when_to_use: "${manifest.when_to_use}"`);
-      if (manifest.allowed_tools?.length)
+      if (m.description)
+        fm.push(`description: "${m.description}"`);
+      if (m.when_to_use)
+        fm.push(`when_to_use: "${m.when_to_use}"`);
+      if (Array.isArray(m.allowed_tools) && m.allowed_tools.length) {
         fm.push(`allowed-tools:
-${manifest.allowed_tools.map((t) => `  - ${t}`).join(`
+${m.allowed_tools.map((t) => `  - ${t}`).join(`
 `)}`);
-      if (manifest.model)
-        fm.push(`model: ${manifest.model}`);
-      if (manifest.context)
-        fm.push(`context: ${manifest.context}`);
-      if (manifest.agent)
-        fm.push(`agent: ${manifest.agent}`);
-      if (manifest.user_invocable === false)
+      }
+      if (m.model)
+        fm.push(`model: ${m.model}`);
+      if (m.context)
+        fm.push(`context: ${m.context}`);
+      if (m.agent)
+        fm.push(`agent: ${m.agent}`);
+      if (m.user_invocable === false)
         fm.push(`user-invocable: false`);
-      if (manifest.argument_hint)
-        fm.push(`argument-hint: "${manifest.argument_hint}"`);
+      if (m.argument_hint)
+        fm.push(`argument-hint: "${m.argument_hint}"`);
       fm.push(`---
 `);
       if (fm.length > 3)
         content = fm.join(`
 `) + content;
-      if (manifest.context === "fork") {
-        const agentType = manifest.agent || "general-purpose";
-        const modelHint = manifest.model ? `, model: "${manifest.model}"` : "";
-        const toolsHint = manifest.allowed_tools?.length ? `
-Only use these tools: ${manifest.allowed_tools.join(", ")}.` : "";
+      if (m.context === "fork") {
+        const agentType = m.agent || "general-purpose";
+        const modelHint = m.model ? `, model: "${m.model}"` : "";
+        const toolsHint = m.allowed_tools?.length ? `
+Only use these tools: ${m.allowed_tools.join(", ")}.` : "";
         content = `IMPORTANT: Execute this skill in an isolated sub-agent. Use the Agent tool with subagent_type="${agentType}"${modelHint}. Pass the full instructions below as the agent prompt.${toolsHint}
 
 ` + content;
@@ -16394,273 +16541,127 @@ Only use these tools: ${manifest.allowed_tools.join(", ")}.` : "";
     }
     return {
       description: skill.description,
-      messages: [
-        {
-          role: "user",
-          content: { type: "text", text: content }
-        }
-      ]
+      messages: [{ role: "user", content: { type: "text", text: content } }]
     };
   });
   server.setRequestHandler(ListResourcesRequestSchema, async () => {
-    const client = allClients()[0];
-    if (!client)
+    try {
+      const { body } = await daemonGet("/v1/skills");
+      const skills = body?.skills ?? [];
+      return {
+        resources: skills.map((s) => ({
+          uri: `skill://claudemesh/${encodeURIComponent(s.name)}`,
+          name: s.name,
+          description: s.description,
+          mimeType: "text/markdown"
+        }))
+      };
+    } catch {
       return { resources: [] };
-    const skills = await client.listSkills();
-    return {
-      resources: skills.map((s) => ({
-        uri: `skill://claudemesh/${encodeURIComponent(s.name)}`,
-        name: s.name,
-        description: s.description,
-        mimeType: "text/markdown"
-      }))
-    };
+    }
   });
   server.setRequestHandler(ReadResourceRequestSchema, async (req) => {
-    const { uri } = req.params;
-    const match = uri.match(/^skill:\/\/claudemesh\/(.+)$/);
-    if (!match)
+    const uri = req.params.uri;
+    const m = uri.match(/^skill:\/\/claudemesh\/(.+)$/);
+    if (!m)
       throw new Error(`Unknown resource URI: ${uri}`);
-    const name = decodeURIComponent(match[1]);
-    const client = allClients()[0];
-    if (!client)
-      throw new Error("Not connected to any mesh");
-    const skill = await client.getSkill(name);
-    if (!skill)
+    const name = decodeURIComponent(m[1]);
+    const { status, body } = await daemonGet(`/v1/skills/${encodeURIComponent(name)}`);
+    if (status === 404)
       throw new Error(`Skill "${name}" not found`);
-    const manifest = skill.manifest;
-    const fmLines = ["---"];
-    fmLines.push(`name: ${skill.name}`);
-    fmLines.push(`description: "${skill.description}"`);
-    if (skill.tags.length)
-      fmLines.push(`tags: [${skill.tags.join(", ")}]`);
-    if (manifest && typeof manifest === "object") {
-      if (manifest.when_to_use)
-        fmLines.push(`when_to_use: "${manifest.when_to_use}"`);
-      if (manifest.allowed_tools?.length)
-        fmLines.push(`allowed-tools:
-${manifest.allowed_tools.map((t) => `  - ${t}`).join(`
+    if (status !== 200)
+      throw new Error(`daemon returned ${status} fetching skill`);
+    const skill = body.skill;
+    const fm = ["---"];
+    fm.push(`name: ${skill.name}`);
+    fm.push(`description: "${skill.description}"`);
+    if (skill.tags?.length)
+      fm.push(`tags: [${skill.tags.join(", ")}]`);
+    const mf = skill.manifest;
+    if (mf && typeof mf === "object") {
+      if (mf.when_to_use)
+        fm.push(`when_to_use: "${mf.when_to_use}"`);
+      if (Array.isArray(mf.allowed_tools) && mf.allowed_tools.length) {
+        fm.push(`allowed-tools:
+${mf.allowed_tools.map((t) => `  - ${t}`).join(`
 `)}`);
-      if (manifest.model)
-        fmLines.push(`model: ${manifest.model}`);
-      if (manifest.context)
-        fmLines.push(`context: ${manifest.context}`);
-      if (manifest.agent)
-        fmLines.push(`agent: ${manifest.agent}`);
-      if (manifest.user_invocable === false)
-        fmLines.push(`user-invocable: false`);
-      if (manifest.argument_hint)
-        fmLines.push(`argument-hint: "${manifest.argument_hint}"`);
-    }
-    fmLines.push(`---
+      }
+      if (mf.model)
+        fm.push(`model: ${mf.model}`);
+      if (mf.context)
+        fm.push(`context: ${mf.context}`);
+    }
+    fm.push(`---
 `);
-    const fullContent = fmLines.join(`
-`) + skill.instructions;
-    return {
-      contents: [
-        {
-          uri,
-          mimeType: "text/markdown",
-          text: fullContent
-        }
-      ]
-    };
+    return { contents: [{ uri, mimeType: "text/markdown", text: fm.join(`
+`) + skill.instructions }] };
   });
-  const transport = new StdioServerTransport;
-  await server.connect(transport);
-  const bridges = [];
-  startClients(config).then(() => {
-    wirePushHandlers().catch(() => {});
-    for (const client of allClients()) {
-      const bridge = startBridgeServer(client);
-      if (bridge)
-        bridges.push(bridge);
-    }
-  }).catch(() => {
-    wirePushHandlers().catch(() => {});
-  });
-  async function wirePushHandlers() {
-    for (const client of allClients()) {
-      client.onPush(async (msg) => {
-        if (messageMode === "off")
-          return;
-        if (msg.subtype === "system" && msg.event) {
-          const eventName = msg.event;
-          const data = msg.eventData ?? {};
-          let content2;
-          if (eventName === "tick") {
-            const tick = data.tick ?? 0;
-            const simTime = String(data.simTime ?? "").replace("T", " ").replace(/\..*/, "");
-            const speed = data.speed ?? 1;
-            content2 = `[heartbeat] tick ${tick} | sim time: ${simTime} | speed: x${speed}`;
-          } else if (eventName === "peer_joined") {
-            content2 = `[system] Peer "${data.name ?? "unknown"}" joined the mesh`;
-          } else if (eventName === "peer_returned") {
-            const peerName = String(data.name ?? "unknown");
-            const lastSeenAt = data.lastSeenAt ? relativeTime(String(data.lastSeenAt)) : "unknown";
-            const groups = Array.isArray(data.groups) ? data.groups.map((g) => g.role ? `@${g.name}:${g.role}` : `@${g.name}`).join(", ") : "";
-            const summary = data.summary ? ` Summary: "${data.summary}"` : "";
-            content2 = `[system] Welcome back, "${peerName}"! Last seen ${lastSeenAt}.${groups ? ` Restored: ${groups}` : ""}${summary}`;
-          } else if (eventName === "peer_left") {
-            content2 = `[system] Peer "${data.name ?? "unknown"}" left the mesh`;
-          } else if (eventName === "mcp_registered") {
-            const tools = Array.isArray(data.tools) ? data.tools.join(", ") : "";
-            content2 = `[system] New MCP server available: "${data.serverName}" (hosted by ${data.hostedBy}). Tools: ${tools}. Use mesh_tool_call to invoke.`;
-          } else if (eventName === "mcp_unregistered") {
-            content2 = `[system] MCP server "${data.serverName}" removed (was hosted by ${data.hostedBy})`;
-          } else if (eventName === "mcp_restored") {
-            content2 = `[system] MCP server "${data.serverName}" is back online (hosted by ${data.hostedBy})`;
-          } else if (eventName === "watch_triggered") {
-            content2 = `[WATCH] ${data.label ?? data.url}: ${data.oldValue} → ${data.newValue}`;
-          } else if (eventName === "mcp_deployed") {
-            content2 = `[SERVICE] "${data.name}" deployed (${data.tool_count} tools) by ${data.deployed_by}`;
-          } else if (eventName === "mcp_undeployed") {
-            content2 = `[SERVICE] "${data.name}" undeployed by ${data.by}`;
-          } else if (eventName === "mcp_scope_changed") {
-            content2 = `[SERVICE] "${data.name}" scope changed to ${JSON.stringify(data.scope)} by ${data.by}`;
-          } else {
-            content2 = `[system] ${eventName}: ${JSON.stringify(data)}`;
-          }
-          try {
-            await server.notification({
-              method: "notifications/claude/channel",
-              params: {
-                content: content2,
-                meta: {
-                  kind: "system",
-                  event: eventName,
-                  mesh_slug: client.meshSlug,
-                  mesh_id: client.meshId,
-                  ...Object.keys(data).length > 0 ? { eventData: JSON.stringify(data) } : {}
-                }
-              }
-            });
-            process.stderr.write(`[claudemesh] system: ${content2}
-`);
-          } catch (pushErr) {
-            process.stderr.write(`[claudemesh] system push FAILED: ${pushErr}
-`);
-          }
-          return;
-        }
-        const fromPubkey = msg.senderPubkey || "";
-        const fromName = fromPubkey ? await resolvePeerName(client, fromPubkey) : "unknown";
-        if (fromPubkey) {
-          try {
-            const { isAllowed: isAllowed2 } = await Promise.resolve().then(() => (init_grants(), exports_grants));
-            const kindCap = msg.kind === "broadcast" ? "broadcast" : "dm";
-            if (!isAllowed2(client.meshSlug, fromPubkey, kindCap)) {
-              process.stderr.write(`[claudemesh] dropped ${kindCap} from ${fromName} (not granted)
-`);
-              return;
-            }
-          } catch {}
-        }
-        if (messageMode === "inbox") {
-          try {
-            await server.notification({
-              method: "notifications/claude/channel",
-              params: {
-                content: `[inbox] New message from ${fromName}. Use check_messages to read.`,
-                meta: { kind: "inbox_notification", from_name: fromName }
-              }
-            });
-          } catch {}
-          return;
-        }
-        const body = msg.plaintext ?? decryptFailedWarning(fromPubkey);
-        const prioBadge = msg.priority === "now" ? "[URGENT] " : msg.priority === "low" ? "[low] " : "";
-        const kindBadge = msg.kind === "broadcast" ? " (broadcast)" : "";
-        const content = `${prioBadge}${fromName}${kindBadge}: ${body}`;
-        const fromMemberPubkey = msg.senderMemberPubkey ?? fromPubkey;
-        try {
-          await server.notification({
-            method: "notifications/claude/channel",
-            params: {
-              content,
-              meta: {
-                from_id: fromMemberPubkey,
-                from_pubkey: fromMemberPubkey,
-                from_session_pubkey: fromPubkey,
-                from_name: fromName,
-                ...msg.senderMemberId ? { from_member_id: msg.senderMemberId } : {},
-                mesh_slug: client.meshSlug,
-                mesh_id: client.meshId,
-                priority: msg.priority,
-                sent_at: msg.createdAt,
-                delivered_at: msg.receivedAt,
-                kind: msg.kind,
-                message_id: msg.messageId,
-                ...msg.topic ? { topic: msg.topic } : {},
-                ...msg.replyToId ? { reply_to_id: msg.replyToId } : {},
-                ...msg.subtype ? { subtype: msg.subtype } : {}
-              }
+  const sub = subscribeEvents(async (ev) => {
+    if (ev.kind === "message") {
+      const d = ev.data;
+      const fromName = String(d.sender_name ?? "unknown");
+      const fromMember = String(d.sender_member_pubkey ?? d.sender_pubkey ?? "");
+      const body = String(d.body ?? "(decrypt failed)");
+      const priority = String(d.priority ?? "next");
+      const prioBadge = priority === "now" ? "[URGENT] " : priority === "low" ? "[low] " : "";
+      const topicTag = d.topic ? ` (#${d.topic})` : "";
+      const content = `${prioBadge}${fromName}${topicTag}: ${body}`;
+      try {
+        await server.notification({
+          method: "notifications/claude/channel",
+          params: {
+            content,
+            meta: {
+              from_id: fromMember,
+              from_pubkey: fromMember,
+              from_session_pubkey: String(d.sender_pubkey ?? ""),
+              from_name: fromName,
+              mesh_slug: String(d.mesh ?? ""),
+              priority,
+              message_id: String(d.broker_message_id ?? d.id ?? ""),
+              client_message_id: String(d.client_message_id ?? ""),
+              ...d.topic ? { topic: String(d.topic) } : {},
+              ...d.reply_to_id ? { reply_to_id: String(d.reply_to_id) } : {},
+              ...d.subtype ? { subtype: String(d.subtype) } : {}
             }
-          });
-          process.stderr.write(`[claudemesh] pushed: from=${fromName} content=${body.slice(0, 60)}
-`);
-        } catch (pushErr) {
-          process.stderr.write(`[claudemesh] push FAILED: ${pushErr}
+          }
+        });
+      } catch (err) {
+        process.stderr.write(`[claudemesh-mcp] channel emit failed: ${err}
 `);
-        }
-      });
-      client.onStreamData(async (evt) => {
-        try {
-          await server.notification({
-            method: "notifications/claude/channel",
-            params: {
-              content: `[stream:${evt.stream}] from ${evt.publishedBy}: ${JSON.stringify(evt.data)}`,
-              meta: {
-                kind: "stream_data",
-                stream: evt.stream,
-                published_by: evt.publishedBy
-              }
-            }
-          });
-        } catch {}
-      });
-      client.onStateChange(async (change) => {
-        try {
-          await server.notification({
-            method: "notifications/claude/channel",
-            params: {
-              content: `[state] ${change.key} = ${JSON.stringify(change.value)} (set by ${change.updatedBy})`,
-              meta: {
-                kind: "state_change",
-                key: change.key,
-                updated_by: change.updatedBy
-              }
-            }
-          });
-        } catch {}
-      });
-    }
-    setTimeout(async () => {
-      const welcomeClient = allClients()[0];
-      if (!welcomeClient || welcomeClient.status !== "open")
-        return;
+      }
+    } else if (ev.kind === "peer_join" || ev.kind === "peer_leave" || ev.kind === "system") {
+      const d = ev.data;
+      const eventName = String(d.event ?? ev.kind);
+      let content;
+      if (ev.kind === "peer_join") {
+        content = `[system] Peer "${String(d.name ?? "unknown")}" joined the mesh`;
+      } else if (ev.kind === "peer_leave") {
+        content = `[system] Peer "${String(d.name ?? "unknown")}" left the mesh`;
+      } else {
+        content = `[system] ${eventName}: ${JSON.stringify(d).slice(0, 240)}`;
+      }
       try {
-        const peers = await welcomeClient.listPeers();
-        const peerNames = peers.filter((p) => p.displayName !== myName).map((p) => p.displayName).join(", ") || "none";
         await server.notification({
           method: "notifications/claude/channel",
           params: {
-            content: `[system] Connected as ${myName} to mesh ${welcomeClient.meshSlug}. ${peers.length} peer(s) online: ${peerNames}. Call mesh_info for full details or set_summary to announce yourself.`,
-            meta: { kind: "welcome", mesh_slug: welcomeClient.meshSlug }
+            content,
+            meta: {
+              kind: "system",
+              event: eventName,
+              mesh_slug: String(d.mesh ?? "")
+            }
           }
         });
       } catch {}
-    }, 2000);
-  }
+    }
+  });
+  const transport = new StdioServerTransport;
+  await server.connect(transport);
   const keepalive = setInterval(() => {}, 1000);
   const shutdown = () => {
     clearInterval(keepalive);
-    for (const b of bridges) {
-      try {
-        b.stop();
-      } catch {}
-    }
-    stopAll();
+    sub.close();
     process.exit(0);
   };
   process.on("SIGTERM", shutdown);
@@ -16691,9 +16692,8 @@ async function startServiceProxy(serviceName) {
     tools = fetched;
   } catch {
     const cached2 = client.serviceCatalog.find((s) => s.name === serviceName);
-    if (cached2) {
+    if (cached2)
       tools = cached2.tools;
-    }
   }
   if (tools.length === 0) {
     process.stderr.write(`[mesh:${serviceName}] no tools found — service may not be running
@@ -16718,12 +16718,7 @@ async function startServiceProxy(serviceName) {
       }
       if (client.status !== "open") {
         return {
-          content: [
-            {
-              type: "text",
-              text: `Service temporarily unavailable — broker reconnecting. Retry in a few seconds.`
-            }
-          ],
+          content: [{ type: "text", text: "Service temporarily unavailable — broker reconnecting. Retry in a few seconds." }],
           isError: true
         };
       }
@@ -16731,23 +16726,13 @@ async function startServiceProxy(serviceName) {
     try {
       const result = await client.mcpCall(serviceName, toolName, args);
       if (result.error) {
-        return {
-          content: [{ type: "text", text: `Error: ${result.error}` }],
-          isError: true
-        };
+        return { content: [{ type: "text", text: `Error: ${result.error}` }], isError: true };
       }
       const resultText = typeof result.result === "string" ? result.result : JSON.stringify(result.result, null, 2);
-      return {
-        content: [{ type: "text", text: resultText }]
-      };
+      return { content: [{ type: "text", text: resultText }] };
     } catch (e) {
       return {
-        content: [
-          {
-            type: "text",
-            text: `Call failed: ${e instanceof Error ? e.message : String(e)}`
-          }
-        ],
+        content: [{ type: "text", text: `Call failed: ${e instanceof Error ? e.message : String(e)}` }],
         isError: true
       };
     }
@@ -16763,9 +16748,7 @@ async function startServiceProxy(serviceName) {
       const newTools = push.eventData?.tools;
       if (Array.isArray(newTools)) {
         tools = newTools;
-        server.notification({
-          method: "notifications/tools/list_changed"
-        }).catch(() => {});
+        server.notification({ method: "notifications/tools/list_changed" }).catch(() => {});
       }
     }
   });
@@ -16780,13 +16763,12 @@ async function startServiceProxy(serviceName) {
   process.on("SIGTERM", shutdown);
   process.on("SIGINT", shutdown);
 }
-var peerNameCache, peerNameCacheAge = 0, CACHE_TTL_MS = 30000;
-var init_server3 = __esm(() => {
-  init_definitions();
+var DAEMON_BOOT_RETRIES = 4, DAEMON_BOOT_RETRY_MS = 500;
+var init_server2 = __esm(() => {
+  init_paths2();
+  init_urls();
   init_facade();
   init_facade8();
-  init_server2();
-  peerNameCache = new Map;
 });
 
 // src/commands/mcp.ts
@@ -16801,7 +16783,7 @@ async function runMcp() {
   process.exit(0);
 }
 var init_mcp = __esm(() => {
-  init_server3();
+  init_server2();
 });
 
 // src/commands/hook.ts
@@ -18612,4 +18594,4 @@ main().catch((err) => {
   process.exit(EXIT.INTERNAL_ERROR);
 });
 
-//# debugId=DF34DB4C8E61E91564756E2164756E21
+//# debugId=EC115E4068A7B5F664756E2164756E21