claudemesh-cli 1.1.0 → 1.2.1

package/dist/entrypoints/cli.js

@@ -88,7 +88,7 @@ __export(exports_urls, {
   VERSION: () => VERSION,
   URLS: () => URLS
 });
-var URLS, VERSION = "1.1.0", env;
+var URLS, VERSION = "1.2.1", env;
 var init_urls = __esm(() => {
   URLS = {
     BROKER: process.env.CLAUDEMESH_BROKER_URL ?? "wss://ic.claudemesh.com/ws",
@@ -6392,11 +6392,136 @@ var init_ban = __esm(() => {
   init_exit_codes();
 });
 
+// src/services/bridge/protocol.ts
+import { homedir as homedir4 } from "node:os";
+import { join as join4 } from "node:path";
+function socketPath(meshSlug) {
+  return join4(homedir4(), ".claudemesh", "sockets", `${meshSlug}.sock`);
+}
+function socketDir() {
+  return join4(homedir4(), ".claudemesh", "sockets");
+}
+function frame(obj) {
+  return JSON.stringify(obj) + `
+`;
+}
+
+class LineParser {
+  buf = "";
+  feed(chunk) {
+    this.buf += typeof chunk === "string" ? chunk : chunk.toString("utf-8");
+    const lines = [];
+    let nl = this.buf.indexOf(`
+`);
+    while (nl !== -1) {
+      lines.push(this.buf.slice(0, nl));
+      this.buf = this.buf.slice(nl + 1);
+      nl = this.buf.indexOf(`
+`);
+    }
+    return lines;
+  }
+}
+var init_protocol = () => {};
+
+// src/services/bridge/client.ts
+import { createConnection } from "node:net";
+import { existsSync as existsSync5 } from "node:fs";
+import { randomUUID as randomUUID2 } from "node:crypto";
+async function tryBridge(meshSlug, verb, args = {}, timeoutMs = DEFAULT_TIMEOUT_MS) {
+  const path = socketPath(meshSlug);
+  if (!existsSync5(path))
+    return null;
+  return new Promise((resolve) => {
+    const id = randomUUID2();
+    const req = { id, verb, args };
+    const parser = new LineParser;
+    let settled = false;
+    const finish = (value) => {
+      if (settled)
+        return;
+      settled = true;
+      try {
+        socket.destroy();
+      } catch {}
+      clearTimeout(timer);
+      resolve(value);
+    };
+    const socket = createConnection({ path });
+    const timer = setTimeout(() => {
+      finish(null);
+    }, timeoutMs);
+    socket.on("connect", () => {
+      try {
+        socket.write(frame(req));
+      } catch {
+        finish(null);
+      }
+    });
+    socket.on("data", (chunk) => {
+      const lines = parser.feed(chunk);
+      for (const line of lines) {
+        if (!line.trim())
+          continue;
+        let res;
+        try {
+          res = JSON.parse(line);
+        } catch {
+          continue;
+        }
+        if (res.id !== id)
+          continue;
+        if (res.ok)
+          finish({ ok: true, result: res.result });
+        else
+          finish({ ok: false, error: res.error });
+        return;
+      }
+    });
+    socket.on("error", (err) => {
+      const code = err.code;
+      if (code === "ECONNREFUSED" || code === "ENOENT" || code === "EPERM") {
+        finish(null);
+      } else {
+        finish(null);
+      }
+    });
+    socket.on("close", () => {
+      finish(null);
+    });
+  });
+}
+var DEFAULT_TIMEOUT_MS = 5000;
+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 bridged = await tryBridge(slug, "peers");
+  if (bridged && bridged.ok) {
+    return bridged.result;
+  }
+  let result = [];
+  await withMesh({ meshSlug: slug }, async (client) => {
+    const all = await client.listPeers();
+    const selfPubkey = client.getSessionPubkey();
+    result = selfPubkey ? all.filter((p) => p.pubkey !== selfPubkey) : all;
+  });
+  return result;
+}
 async function runPeers(flags) {
   const config = readConfig();
   const slugs = flags.mesh ? [flags.mesh] : config.meshes.map((m) => m.slug);
@@ -6405,55 +6530,59 @@ async function runPeers(flags) {
     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 {
-      await withMesh({ meshSlug: slug }, async (client, mesh) => {
-        const allPeers = await client.listPeers();
-        const selfPubkey = client.getSessionPubkey();
-        const peers = selfPubkey ? allPeers.filter((p) => p.pubkey !== selfPubkey) : allPeers;
-        if (flags.json) {
-          allJson.push({ mesh: mesh.slug, peers });
-          return;
-        }
-        render.section(`peers on ${mesh.slug} (${peers.length})`);
-        if (peers.length === 0) {
-          render.info(dim("  (no peers connected)"));
-          return;
-        }
-        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)}…`);
-          render.info(`${statusDot} ${name}${groups}${metaStr}${pubkeyTag}${summary}`);
-          if (p.cwd)
-            render.info(dim(`   cwd: ${p.cwd}`));
-        }
-      });
+      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)}…`);
+        render.info(`${statusDot} ${name}${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 (flags.json) {
+  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
@@ -6462,7 +6591,33 @@ __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 (meshSlug) {
+    const bridged = await tryBridge(meshSlug, "send", { to, message, priority });
+    if (bridged !== null) {
+      if (bridged.ok) {
+        const r = bridged.result;
+        if (flags.json) {
+          console.log(JSON.stringify({ ok: true, messageId: r.messageId, target: to }));
+        } else {
+          render.ok(`sent to ${to}`, r.messageId ? dim(r.messageId.slice(0, 8)) : undefined);
+        }
+        return;
+      }
+      if (flags.json) {
+        console.log(JSON.stringify({ ok: false, error: bridged.error }));
+      } else {
+        render.err(`send failed: ${bridged.error}`);
+      }
+      process.exit(1);
+    }
+  }
   await withMesh({ meshSlug: flags.mesh ?? null }, async (client) => {
     let targetSpec = to;
     if (!to.startsWith("@") && to !== "*" && !/^[0-9a-f]{64}$/i.test(to)) {
@@ -6470,22 +6625,34 @@ async function runSend(flags, to, message) {
       const match = peers.find((p) => p.displayName.toLowerCase() === to.toLowerCase());
       if (!match) {
         const names = peers.map((p) => p.displayName).join(", ");
-        console.error(`Peer "${to}" not found. Online: ${names || "(none)"}`);
+        render.err(`Peer "${to}" not found.`, `online: ${names || "(none)"}`);
         process.exit(1);
       }
       targetSpec = match.pubkey;
     }
     const result = await client.send(targetSpec, message, priority);
     if (result.ok) {
-      console.log(`✓ Sent to ${to}${result.messageId ? ` (${result.messageId.slice(0, 8)})` : ""}`);
+      if (flags.json) {
+        console.log(JSON.stringify({ ok: true, messageId: result.messageId, target: to }));
+      } else {
+        render.ok(`sent to ${to}`, result.messageId ? dim(result.messageId.slice(0, 8)) : undefined);
+      }
     } else {
-      console.error(`✗ Send failed: ${result.error ?? "unknown error"}`);
+      if (flags.json) {
+        console.log(JSON.stringify({ ok: false, error: result.error ?? "unknown" }));
+      } else {
+        render.err(`send failed: ${result.error ?? "unknown error"}`);
+      }
       process.exit(1);
     }
   });
 }
 var init_send = __esm(() => {
   init_connect();
+  init_facade();
+  init_client3();
+  init_render();
+  init_styles();
 });
 
 // src/commands/inbox.ts
@@ -6731,20 +6898,40 @@ __export(exports_broker_actions, {
   runForget: () => runForget,
   runClock: () => runClock
 });
+function unambiguousMesh(opts) {
+  if (opts.mesh)
+    return opts.mesh;
+  const config = readConfig();
+  return config.meshes.length === 1 ? config.meshes[0].slug : null;
+}
 async function runStatusSet(state, opts) {
   const valid = ["idle", "working", "dnd"];
   if (!valid.includes(state)) {
     render.err(`Invalid status: ${state}`, `must be one of: ${valid.join(", ")}`);
     return EXIT.INVALID_ARGS;
   }
+  const meshSlug = unambiguousMesh(opts);
+  if (meshSlug) {
+    const bridged = await tryBridge(meshSlug, "status_set", { status: state });
+    if (bridged !== null) {
+      if (bridged.ok) {
+        if (opts.json)
+          console.log(JSON.stringify({ status: state }));
+        else
+          render.ok(`status set to ${bold(state)}`);
+        return EXIT.SUCCESS;
+      }
+      render.err(bridged.error);
+      return EXIT.INTERNAL_ERROR;
+    }
+  }
   await withMesh({ meshSlug: opts.mesh ?? null }, async (client) => {
     await client.setStatus(state);
   });
-  if (opts.json) {
+  if (opts.json)
     console.log(JSON.stringify({ status: state }));
-    return EXIT.SUCCESS;
-  }
-  render.ok(`status set to ${bold(state)}`);
+  else
+    render.ok(`status set to ${bold(state)}`);
   return EXIT.SUCCESS;
 }
 async function runSummary(text, opts) {
@@ -6752,14 +6939,28 @@ async function runSummary(text, opts) {
     render.err("Usage: claudemesh summary <text>");
     return EXIT.INVALID_ARGS;
   }
+  const meshSlug = unambiguousMesh(opts);
+  if (meshSlug) {
+    const bridged = await tryBridge(meshSlug, "summary", { summary: text });
+    if (bridged !== null) {
+      if (bridged.ok) {
+        if (opts.json)
+          console.log(JSON.stringify({ summary: text }));
+        else
+          render.ok("summary set", dim(text));
+        return EXIT.SUCCESS;
+      }
+      render.err(bridged.error);
+      return EXIT.INTERNAL_ERROR;
+    }
+  }
   await withMesh({ meshSlug: opts.mesh ?? null }, async (client) => {
     await client.setSummary(text);
   });
-  if (opts.json) {
+  if (opts.json)
     console.log(JSON.stringify({ summary: text }));
-    return EXIT.SUCCESS;
-  }
-  render.ok("summary set", dim(text));
+  else
+    render.ok("summary set", dim(text));
   return EXIT.SUCCESS;
 }
 async function runVisible(value, opts) {
@@ -6772,14 +6973,28 @@ async function runVisible(value, opts) {
     render.err("Usage: claudemesh visible <true|false>");
     return EXIT.INVALID_ARGS;
   }
+  const meshSlug = unambiguousMesh(opts);
+  if (meshSlug) {
+    const bridged = await tryBridge(meshSlug, "visible", { visible });
+    if (bridged !== null) {
+      if (bridged.ok) {
+        if (opts.json)
+          console.log(JSON.stringify({ visible }));
+        else
+          render.ok(visible ? "you are now visible to peers" : "you are now hidden", visible ? undefined : "direct messages still reach you");
+        return EXIT.SUCCESS;
+      }
+      render.err(bridged.error);
+      return EXIT.INTERNAL_ERROR;
+    }
+  }
   await withMesh({ meshSlug: opts.mesh ?? null }, async (client) => {
     await client.setVisible(visible);
   });
-  if (opts.json) {
+  if (opts.json)
     console.log(JSON.stringify({ visible }));
-    return EXIT.SUCCESS;
-  }
-  render.ok(visible ? "you are now visible to peers" : "you are now hidden", visible ? undefined : "direct messages still reach you");
+  else
+    render.ok(visible ? "you are now visible to peers" : "you are now hidden", visible ? undefined : "direct messages still reach you");
   return EXIT.SUCCESS;
 }
 async function runGroupJoin(name, opts) {
@@ -6967,6 +7182,8 @@ async function runTaskComplete(id, result, opts) {
 }
 var init_broker_actions = __esm(() => {
   init_connect();
+  init_facade();
+  init_client3();
   init_render();
   init_styles();
   init_exit_codes();
@@ -7278,17 +7495,17 @@ __export(exports_install, {
 import {
   chmodSync as chmodSync3,
   copyFileSync,
-  existsSync as existsSync5,
+  existsSync as existsSync6,
   mkdirSync as mkdirSync3,
   readFileSync as readFileSync4,
   writeFileSync as writeFileSync5
 } from "node:fs";
-import { homedir as homedir4, platform as platform5 } from "node:os";
-import { dirname as dirname2, join as join4, resolve } from "node:path";
+import { homedir as homedir5, platform as platform5 } from "node:os";
+import { dirname as dirname2, join as join5, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { spawnSync as spawnSync3 } from "node:child_process";
 function readClaudeConfig() {
-  if (!existsSync5(CLAUDE_CONFIG))
+  if (!existsSync6(CLAUDE_CONFIG))
     return {};
   const text = readFileSync4(CLAUDE_CONFIG, "utf-8").trim();
   if (!text)
@@ -7300,12 +7517,12 @@ function readClaudeConfig() {
   }
 }
 function backupClaudeConfig() {
-  if (!existsSync5(CLAUDE_CONFIG))
+  if (!existsSync6(CLAUDE_CONFIG))
     return;
-  const backupDir = join4(dirname2(CLAUDE_CONFIG), ".claude", "backups");
+  const backupDir = join5(dirname2(CLAUDE_CONFIG), ".claude", "backups");
   mkdirSync3(backupDir, { recursive: true });
   const ts = Date.now();
-  const dest = join4(backupDir, `.claude.json.pre-claudemesh.${ts}`);
+  const dest = join5(backupDir, `.claude.json.pre-claudemesh.${ts}`);
   copyFileSync(CLAUDE_CONFIG, dest);
 }
 function patchMcpServer(entry) {
@@ -7329,7 +7546,7 @@ function patchMcpServer(entry) {
   return action;
 }
 function removeMcpServer() {
-  if (!existsSync5(CLAUDE_CONFIG))
+  if (!existsSync6(CLAUDE_CONFIG))
     return false;
   backupClaudeConfig();
   const cfg = readClaudeConfig();
@@ -7353,16 +7570,65 @@ function bunAvailable() {
   const res = platform5() === "win32" ? spawnSync3("where", ["bun"]) : spawnSync3("sh", ["-c", "command -v bun"]);
   return res.status === 0;
 }
+function isBundledFile(p) {
+  return /[/\\]dist[/\\]/.test(p);
+}
 function resolveEntry() {
   const here = fileURLToPath(import.meta.url);
-  if (here.endsWith("/dist/index.js") || here.endsWith("\\dist\\index.js")) {
+  if (isBundledFile(here))
     return here;
-  }
   return resolve(dirname2(here), "..", "index.ts");
 }
+function resolveBundledSkillsDir() {
+  const here = fileURLToPath(import.meta.url);
+  const pkgRoot = resolve(dirname2(here), "..", "..");
+  const skillsDir = join5(pkgRoot, "skills");
+  if (existsSync6(skillsDir))
+    return skillsDir;
+  return null;
+}
+function installSkills() {
+  const src = resolveBundledSkillsDir();
+  if (!src)
+    return [];
+  const fs = __require("node:fs");
+  const installed = [];
+  for (const entry of fs.readdirSync(src, { withFileTypes: true })) {
+    if (!entry.isDirectory())
+      continue;
+    const srcDir = join5(src, entry.name);
+    const dstDir = join5(CLAUDE_SKILLS_ROOT, entry.name);
+    mkdirSync3(dstDir, { recursive: true });
+    for (const file of fs.readdirSync(srcDir, { withFileTypes: true })) {
+      if (!file.isFile())
+        continue;
+      copyFileSync(join5(srcDir, file.name), join5(dstDir, file.name));
+    }
+    installed.push(entry.name);
+  }
+  return installed;
+}
+function uninstallSkills() {
+  const src = resolveBundledSkillsDir();
+  if (!src)
+    return [];
+  const fs = __require("node:fs");
+  const removed = [];
+  for (const entry of fs.readdirSync(src, { withFileTypes: true })) {
+    if (!entry.isDirectory())
+      continue;
+    const dstDir = join5(CLAUDE_SKILLS_ROOT, entry.name);
+    if (existsSync6(dstDir)) {
+      try {
+        fs.rmSync(dstDir, { recursive: true, force: true });
+        removed.push(entry.name);
+      } catch {}
+    }
+  }
+  return removed;
+}
 function buildMcpEntry(entryPath) {
-  const isBundled = entryPath.endsWith("/dist/index.js") || entryPath.endsWith("\\dist\\index.js");
-  if (isBundled) {
+  if (isBundledFile(entryPath)) {
     return {
       command: "claudemesh",
       args: ["mcp"]
@@ -7377,7 +7643,7 @@ function entriesEqual(a, b) {
   return a.command === b.command && JSON.stringify(a.args ?? []) === JSON.stringify(b.args ?? []);
 }
 function readClaudeSettings() {
-  if (!existsSync5(CLAUDE_SETTINGS))
+  if (!existsSync6(CLAUDE_SETTINGS))
     return {};
   const text = readFileSync4(CLAUDE_SETTINGS, "utf-8").trim();
   if (!text)
@@ -7404,7 +7670,7 @@ function installAllowedTools() {
   return { added: toAdd, unchanged: CLAUDEMESH_TOOLS.length - toAdd.length };
 }
 function uninstallAllowedTools() {
-  if (!existsSync5(CLAUDE_SETTINGS))
+  if (!existsSync6(CLAUDE_SETTINGS))
     return 0;
   const settings = readClaudeSettings();
   const existing = settings.allowedTools ?? [];
@@ -7439,7 +7705,7 @@ function installHooks() {
   return { added, unchanged };
 }
 function uninstallHooks() {
-  if (!existsSync5(CLAUDE_SETTINGS))
+  if (!existsSync6(CLAUDE_SETTINGS))
     return 0;
   const settings = readClaudeSettings();
   const hooks = settings.hooks;
@@ -7479,15 +7745,16 @@ function installStatusLine() {
 }
 function runInstall(args = []) {
   const skipHooks = args.includes("--no-hooks");
+  const skipSkill = args.includes("--no-skill");
   const wantStatusLine = args.includes("--status-line");
   render.section("claudemesh install");
   const entry = resolveEntry();
-  const isBundled = entry.endsWith("/dist/index.js") || entry.endsWith("\\dist\\index.js");
-  if (!isBundled && !bunAvailable()) {
+  const bundled = isBundledFile(entry);
+  if (!bundled && !bunAvailable()) {
     render.err("`bun` is not on PATH.", "Install Bun first: https://bun.com");
     process.exit(1);
   }
-  if (!existsSync5(entry)) {
+  if (!existsSync6(entry)) {
     render.err(`MCP entry not found at ${entry}`);
     process.exit(1);
   }
@@ -7533,6 +7800,19 @@ function runInstall(args = []) {
   } else {
     render.info(dim("· Hooks skipped (--no-hooks)"));
   }
+  if (!skipSkill) {
+    try {
+      const installed = installSkills();
+      if (installed.length > 0) {
+        render.ok(`Claude skill${installed.length === 1 ? "" : "s"} installed`, installed.join(", "));
+        render.info(dim(`  ${join5(CLAUDE_SKILLS_ROOT, installed[0])}/SKILL.md`));
+      }
+    } catch (e) {
+      render.warn(`skill install failed: ${e instanceof Error ? e.message : String(e)}`);
+    }
+  } else {
+    render.info(dim("· Skill install skipped (--no-skill)"));
+  }
   if (wantStatusLine) {
     try {
       const { installed } = installStatusLine();
@@ -7595,16 +7875,27 @@ function runUninstall() {
   } catch (e) {
     render.warn(`hook removal failed: ${e instanceof Error ? e.message : String(e)}`);
   }
+  try {
+    const removed = uninstallSkills();
+    if (removed.length > 0) {
+      render.ok(`Skill${removed.length === 1 ? "" : "s"} removed`, removed.join(", "));
+    } else {
+      render.info(dim("· No claudemesh skills to remove"));
+    }
+  } catch (e) {
+    render.warn(`skill removal failed: ${e instanceof Error ? e.message : String(e)}`);
+  }
   render.blank();
   render.info("Restart Claude Code to drop the MCP connection + hooks.");
 }
-var MCP_NAME = "claudemesh", CLAUDE_CONFIG, CLAUDE_SETTINGS, HOOK_COMMAND_STOP = "claudemesh hook idle", HOOK_COMMAND_USER_PROMPT = "claudemesh hook working", HOOK_MARKER = "claudemesh hook ", CLAUDEMESH_TOOLS;
+var MCP_NAME = "claudemesh", CLAUDE_CONFIG, CLAUDE_SETTINGS, HOOK_COMMAND_STOP = "claudemesh hook idle", HOOK_COMMAND_USER_PROMPT = "claudemesh hook working", HOOK_MARKER = "claudemesh hook ", CLAUDE_SKILLS_ROOT, CLAUDEMESH_TOOLS;
 var init_install = __esm(() => {
   init_facade();
   init_render();
   init_styles();
-  CLAUDE_CONFIG = join4(homedir4(), ".claude.json");
-  CLAUDE_SETTINGS = join4(homedir4(), ".claude", "settings.json");
+  CLAUDE_CONFIG = join5(homedir5(), ".claude.json");
+  CLAUDE_SETTINGS = join5(homedir5(), ".claude", "settings.json");
+  CLAUDE_SKILLS_ROOT = join5(homedir5(), ".claude", "skills");
   CLAUDEMESH_TOOLS = [
     "mcp__claudemesh__cancel_scheduled",
     "mcp__claudemesh__check_messages",
@@ -7659,10 +7950,19 @@ var exports_uninstall = {};
 __export(exports_uninstall, {
   uninstall: () => uninstall
 });
-import { readFileSync as readFileSync5, writeFileSync as writeFileSync6, existsSync as existsSync6 } from "node:fs";
+import { readFileSync as readFileSync5, writeFileSync as writeFileSync6, existsSync as existsSync7, rmSync as rmSync2, readdirSync as readdirSync2 } from "node:fs";
+import { join as join6, dirname as dirname3 } from "node:path";
+import { homedir as homedir6 } from "node:os";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+function bundledSkillsDir() {
+  const here = fileURLToPath2(import.meta.url);
+  const pkgRoot = join6(dirname3(here), "..", "..");
+  const skillsDir = join6(pkgRoot, "skills");
+  return existsSync7(skillsDir) ? skillsDir : null;
+}
 async function uninstall() {
   let removed = 0;
-  if (existsSync6(PATHS.CLAUDE_JSON)) {
+  if (existsSync7(PATHS.CLAUDE_JSON)) {
     try {
       const raw = readFileSync5(PATHS.CLAUDE_JSON, "utf-8");
       const config = JSON.parse(raw);
@@ -7676,7 +7976,7 @@ async function uninstall() {
       }
     } catch {}
   }
-  if (existsSync6(PATHS.CLAUDE_SETTINGS)) {
+  if (existsSync7(PATHS.CLAUDE_SETTINGS)) {
     try {
       const raw = readFileSync5(PATHS.CLAUDE_SETTINGS, "utf-8");
       const config = JSON.parse(raw);
@@ -7707,16 +8007,39 @@ async function uninstall() {
       }
     } catch {}
   }
+  const src = bundledSkillsDir();
+  if (src) {
+    const removedSkills = [];
+    try {
+      for (const entry of readdirSync2(src, { withFileTypes: true })) {
+        if (!entry.isDirectory())
+          continue;
+        const dst = join6(CLAUDE_SKILLS_ROOT2, entry.name);
+        if (existsSync7(dst)) {
+          try {
+            rmSync2(dst, { recursive: true, force: true });
+            removedSkills.push(entry.name);
+          } catch {}
+        }
+      }
+      if (removedSkills.length > 0) {
+        render.ok(`removed Claude skill${removedSkills.length === 1 ? "" : "s"}`, removedSkills.join(", "));
+        removed++;
+      }
+    } catch {}
+  }
   if (removed === 0) {
     render.info(dim("Nothing to remove — claudemesh was not installed."));
   }
   return EXIT.SUCCESS;
 }
+var CLAUDE_SKILLS_ROOT2;
 var init_uninstall = __esm(() => {
   init_paths();
   init_render();
   init_styles();
   init_exit_codes();
+  CLAUDE_SKILLS_ROOT2 = join6(homedir6(), ".claude", "skills");
 });
 
 // src/commands/doctor.ts
@@ -7724,9 +8047,9 @@ var exports_doctor = {};
 __export(exports_doctor, {
   runDoctor: () => runDoctor
 });
-import { existsSync as existsSync7, readFileSync as readFileSync6, statSync as statSync2 } from "node:fs";
-import { homedir as homedir5, platform as platform6 } from "node:os";
-import { join as join5 } from "node:path";
+import { existsSync as existsSync8, readFileSync as readFileSync6, statSync as statSync2 } from "node:fs";
+import { homedir as homedir7, platform as platform6 } from "node:os";
+import { join as join7 } from "node:path";
 import { spawnSync as spawnSync4 } from "node:child_process";
 function checkNode() {
   const major = Number(process.versions.node.split(".")[0]);
@@ -7750,8 +8073,8 @@ function checkClaudeOnPath() {
   };
 }
 function checkMcpRegistered() {
-  const claudeConfig = join5(homedir5(), ".claude.json");
-  if (!existsSync7(claudeConfig)) {
+  const claudeConfig = join7(homedir7(), ".claude.json");
+  if (!existsSync8(claudeConfig)) {
     return {
       name: "claudemesh MCP registered in ~/.claude.json",
       pass: false,
@@ -7776,8 +8099,8 @@ function checkMcpRegistered() {
   }
 }
 function checkHooksRegistered() {
-  const settings = join5(homedir5(), ".claude", "settings.json");
-  if (!existsSync7(settings)) {
+  const settings = join7(homedir7(), ".claude", "settings.json");
+  if (!existsSync8(settings)) {
     return {
       name: "Status hooks registered in ~/.claude/settings.json",
       pass: false,
@@ -7802,7 +8125,7 @@ function checkHooksRegistered() {
 }
 function checkConfigFile() {
   const path = getConfigPath();
-  if (!existsSync7(path)) {
+  if (!existsSync8(path)) {
     return {
       name: "~/.claudemesh/config.json exists and parses",
       pass: true,
@@ -7985,7 +8308,7 @@ var exports_status = {};
 __export(exports_status, {
   runStatus: () => runStatus
 });
-import { statSync as statSync3, existsSync as existsSync8 } from "node:fs";
+import { statSync as statSync3, existsSync as existsSync9 } from "node:fs";
 import WebSocket2 from "ws";
 async function probeBroker(url, timeoutMs = 4000) {
   return new Promise((resolve2) => {
@@ -8015,7 +8338,7 @@ async function runStatus() {
   render.section(`status (v${VERSION})`);
   const configPath = getConfigPath();
   let configPermsNote = "missing";
-  if (existsSync8(configPath)) {
+  if (existsSync9(configPath)) {
     const mode = (statSync3(configPath).mode & 511).toString(8).padStart(4, "0");
     configPermsNote = mode === "0600" ? `${mode}` : `${mode} — expected 0600`;
   }
@@ -8161,10 +8484,10 @@ var init_check_claude_binary = __esm(() => {
 });
 
 // src/services/health/check-mcp-registered.ts
-import { existsSync as existsSync9, readFileSync as readFileSync7 } from "node:fs";
+import { existsSync as existsSync10, readFileSync as readFileSync7 } from "node:fs";
 function checkMcpRegistered2() {
   try {
-    if (!existsSync9(PATHS.CLAUDE_JSON)) {
+    if (!existsSync10(PATHS.CLAUDE_JSON)) {
       return { name: "mcp-registered", ok: false, message: "~/.claude.json not found" };
     }
     const raw = readFileSync7(PATHS.CLAUDE_JSON, "utf-8");
@@ -8182,10 +8505,10 @@ var init_check_mcp_registered = __esm(() => {
 });
 
 // src/services/health/check-hooks-registered.ts
-import { existsSync as existsSync10, readFileSync as readFileSync8 } from "node:fs";
+import { existsSync as existsSync11, readFileSync as readFileSync8 } from "node:fs";
 function checkHooksRegistered2() {
   try {
-    if (!existsSync10(PATHS.CLAUDE_SETTINGS)) {
+    if (!existsSync11(PATHS.CLAUDE_SETTINGS)) {
       return { name: "hooks-registered", ok: false, message: "~/.claude/settings.json not found" };
     }
     const raw = readFileSync8(PATHS.CLAUDE_SETTINGS, "utf-8");
@@ -8203,10 +8526,10 @@ var init_check_hooks_registered = __esm(() => {
 });
 
 // src/services/health/check-config-perms.ts
-import { existsSync as existsSync11, statSync as statSync4 } from "node:fs";
+import { existsSync as existsSync12, statSync as statSync4 } from "node:fs";
 function checkConfigPerms() {
   const configFile = PATHS.CONFIG_FILE;
-  if (!existsSync11(configFile)) {
+  if (!existsSync12(configFile)) {
     return { name: "config-perms", ok: true, message: "No config file yet (first run)" };
   }
   try {
@@ -8224,9 +8547,9 @@ var init_check_config_perms = __esm(() => {
 });
 
 // src/services/health/check-keypairs-valid.ts
-import { existsSync as existsSync12, readFileSync as readFileSync9 } from "node:fs";
+import { existsSync as existsSync13, readFileSync as readFileSync9 } from "node:fs";
 function checkKeypairsValid() {
-  if (!existsSync12(PATHS.CONFIG_FILE)) {
+  if (!existsSync13(PATHS.CONFIG_FILE)) {
     return { name: "keypairs-valid", ok: true, message: "No config (first run)" };
   }
   try {
@@ -8710,18 +9033,18 @@ var exports_url_handler = {};
 __export(exports_url_handler, {
   runUrlHandler: () => runUrlHandler
 });
-import { platform as platform7, homedir as homedir6 } from "node:os";
-import { existsSync as existsSync13, mkdirSync as mkdirSync4, writeFileSync as writeFileSync7, rmSync as rmSync2, chmodSync as chmodSync4 } from "node:fs";
-import { join as join6 } from "node:path";
+import { platform as platform7, homedir as homedir8 } from "node:os";
+import { existsSync as existsSync14, mkdirSync as mkdirSync4, writeFileSync as writeFileSync7, rmSync as rmSync3, chmodSync as chmodSync4 } from "node:fs";
+import { join as join8 } from "node:path";
 import { spawnSync as spawnSync5 } from "node:child_process";
 function resolveClaudemeshBin() {
   return process.argv[1] ?? "claudemesh";
 }
 function installDarwin() {
   const binPath = resolveClaudemeshBin();
-  const appDir = join6(homedir6(), "Library", "Application Support", "claudemesh", "ClaudemeshHandler.app");
-  const contents = join6(appDir, "Contents");
-  const macOS = join6(contents, "MacOS");
+  const appDir = join8(homedir8(), "Library", "Application Support", "claudemesh", "ClaudemeshHandler.app");
+  const contents = join8(appDir, "Contents");
+  const macOS = join8(contents, "MacOS");
   mkdirSync4(macOS, { recursive: true });
   const plist = `<?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
@@ -8745,7 +9068,7 @@ function installDarwin() {
   </array>
 </dict>
 </plist>`;
-  writeFileSync7(join6(contents, "Info.plist"), plist);
+  writeFileSync7(join8(contents, "Info.plist"), plist);
   const shim = `#!/bin/sh
 URL="$1"
 CODE=\${URL#claudemesh://}
@@ -8759,7 +9082,7 @@ tell application "Terminal"
 end tell
 EOF
 `;
-  const shimPath = join6(macOS, "open-url");
+  const shimPath = join8(macOS, "open-url");
   writeFileSync7(shimPath, shim);
   chmodSync4(shimPath, 493);
   const lsreg = spawnSync5("/System/Library/Frameworks/CoreServices.framework/Frameworks/LaunchServices.framework/Support/lsregister", ["-f", appDir], { encoding: "utf-8" });
@@ -8771,7 +9094,7 @@ EOF
 }
 function installLinux() {
   const binPath = resolveClaudemeshBin();
-  const appsDir = join6(homedir6(), ".local", "share", "applications");
+  const appsDir = join8(homedir8(), ".local", "share", "applications");
   mkdirSync4(appsDir, { recursive: true });
   const desktop = `[Desktop Entry]
 Type=Application
@@ -8783,7 +9106,7 @@ Terminal=true
 MimeType=x-scheme-handler/claudemesh;
 NoDisplay=true
 `;
-  const desktopPath = join6(appsDir, "claudemesh.desktop");
+  const desktopPath = join8(appsDir, "claudemesh.desktop");
   writeFileSync7(desktopPath, desktop);
   const xdg1 = spawnSync5("xdg-mime", ["default", "claudemesh.desktop", "x-scheme-handler/claudemesh"], { encoding: "utf-8" });
   if (xdg1.status !== 0) {
@@ -8806,7 +9129,7 @@ function installWindows() {
     `[HKEY_CURRENT_USER\\Software\\Classes\\claudemesh\\shell\\open\\command]`,
     `@="\\"${binPath.replace(/\\/g, "\\\\")}\\" \\"%1\\""`
   ];
-  const regPath = join6(homedir6(), "claudemesh-handler.reg");
+  const regPath = join8(homedir8(), "claudemesh-handler.reg");
   writeFileSync7(regPath, lines.join(`\r
 `));
   const res = spawnSync5("reg.exe", ["import", regPath], { encoding: "utf-8" });
@@ -8818,16 +9141,16 @@ function installWindows() {
   return EXIT.SUCCESS;
 }
 function uninstallDarwin() {
-  const appDir = join6(homedir6(), "Library", "Application Support", "claudemesh", "ClaudemeshHandler.app");
-  if (existsSync13(appDir))
-    rmSync2(appDir, { recursive: true, force: true });
+  const appDir = join8(homedir8(), "Library", "Application Support", "claudemesh", "ClaudemeshHandler.app");
+  if (existsSync14(appDir))
+    rmSync3(appDir, { recursive: true, force: true });
   render.ok("removed claudemesh:// handler on macOS");
   return EXIT.SUCCESS;
 }
 function uninstallLinux() {
-  const desktopPath = join6(homedir6(), ".local", "share", "applications", "claudemesh.desktop");
-  if (existsSync13(desktopPath))
-    rmSync2(desktopPath, { force: true });
+  const desktopPath = join8(homedir8(), ".local", "share", "applications", "claudemesh.desktop");
+  if (existsSync14(desktopPath))
+    rmSync3(desktopPath, { force: true });
   render.ok("removed claudemesh:// handler on Linux");
   return EXIT.SUCCESS;
 }
@@ -8871,9 +9194,9 @@ var exports_status_line = {};
 __export(exports_status_line, {
   runStatusLine: () => runStatusLine
 });
-import { existsSync as existsSync14, readFileSync as readFileSync10 } from "node:fs";
-import { join as join7 } from "node:path";
-import { homedir as homedir7 } from "node:os";
+import { existsSync as existsSync15, readFileSync as readFileSync10 } from "node:fs";
+import { join as join9 } from "node:path";
+import { homedir as homedir9 } from "node:os";
 async function runStatusLine() {
   try {
     const config = readConfig();
@@ -8881,9 +9204,9 @@ async function runStatusLine() {
       process.stdout.write("◇ claudemesh (not joined)");
       return EXIT.SUCCESS;
     }
-    const cachePath = join7(homedir7(), ".claudemesh", "peer-cache.json");
+    const cachePath = join9(homedir9(), ".claudemesh", "peer-cache.json");
     let cache = {};
-    if (existsSync14(cachePath)) {
+    if (existsSync15(cachePath)) {
       try {
         cache = JSON.parse(readFileSync10(cachePath, "utf-8"));
       } catch {}
@@ -8916,7 +9239,7 @@ __export(exports_backup, {
   runRestore: () => runRestore,
   runBackup: () => runBackup
 });
-import { readFileSync as readFileSync11, writeFileSync as writeFileSync8, existsSync as existsSync15 } from "node:fs";
+import { readFileSync as readFileSync11, writeFileSync as writeFileSync8, existsSync as existsSync16 } from "node:fs";
 import { createInterface as createInterface10 } from "node:readline";
 function readHidden(prompt5) {
   return new Promise((resolve2) => {
@@ -8958,7 +9281,7 @@ async function deriveKey(pass, salt, s) {
 }
 async function runBackup(outPath) {
   const configPath = getConfigPath();
-  if (!existsSync15(configPath)) {
+  if (!existsSync16(configPath)) {
     console.error("  No config found — nothing to back up. Join a mesh first.");
     return EXIT.NOT_FOUND;
   }
@@ -8992,7 +9315,7 @@ async function runRestore(inPath) {
     console.error("  Usage: claudemesh restore <backup-file>");
     return EXIT.INVALID_ARGS;
   }
-  if (!existsSync15(inPath)) {
+  if (!existsSync16(inPath)) {
     console.error(`  ✗ File not found: ${inPath}`);
     return EXIT.NOT_FOUND;
   }
@@ -9015,7 +9338,7 @@ async function runRestore(inPath) {
     return EXIT.INTERNAL_ERROR;
   }
   const configPath = getConfigPath();
-  if (existsSync15(configPath)) {
+  if (existsSync16(configPath)) {
     const backupOld = `${configPath}.before-restore.${Date.now()}`;
     writeFileSync8(backupOld, readFileSync11(configPath), { mode: 384 });
     console.log(`  ↻ Existing config saved to ${backupOld}`);
@@ -9040,8 +9363,8 @@ __export(exports_upgrade, {
   runUpgrade: () => runUpgrade
 });
 import { spawnSync as spawnSync6 } from "node:child_process";
-import { existsSync as existsSync16 } from "node:fs";
-import { dirname as dirname3, join as join8, resolve as resolve2 } from "node:path";
+import { existsSync as existsSync17 } from "node:fs";
+import { dirname as dirname4, join as join10, resolve as resolve2 } from "node:path";
 async function latestVersion() {
   try {
     const res = await fetch(URLS.NPM_REGISTRY, { signal: AbortSignal.timeout(8000) });
@@ -9054,15 +9377,15 @@ async function latestVersion() {
   }
 }
 function findNpm() {
-  const portable = join8(process.env.HOME ?? "", ".claudemesh", "node", "bin", "npm");
-  if (existsSync16(portable)) {
-    return { npm: portable, prefix: join8(process.env.HOME ?? "", ".claudemesh") };
+  const portable = join10(process.env.HOME ?? "", ".claudemesh", "node", "bin", "npm");
+  if (existsSync17(portable)) {
+    return { npm: portable, prefix: join10(process.env.HOME ?? "", ".claudemesh") };
   }
   let cur = resolve2(process.argv[1] ?? ".");
   for (let i = 0;i < 6; i++) {
-    cur = dirname3(cur);
-    const candidate = join8(cur, "bin", "npm");
-    if (existsSync16(candidate))
+    cur = dirname4(cur);
+    const candidate = join10(cur, "bin", "npm");
+    if (existsSync17(candidate))
       return { npm: candidate };
   }
   return { npm: "npm" };
@@ -9124,9 +9447,9 @@ __export(exports_grants, {
   runBlock: () => runBlock,
   isAllowed: () => isAllowed
 });
-import { existsSync as existsSync17, mkdirSync as mkdirSync5, readFileSync as readFileSync12, writeFileSync as writeFileSync9 } from "node:fs";
-import { homedir as homedir8 } from "node:os";
-import { join as join9 } from "node:path";
+import { existsSync as existsSync18, mkdirSync as mkdirSync5, readFileSync as readFileSync12, writeFileSync as writeFileSync9 } from "node:fs";
+import { homedir as homedir10 } from "node:os";
+import { join as join11 } from "node:path";
 async function syncToBroker(meshSlug, grants) {
   const auth = getStoredToken();
   if (!auth)
@@ -9144,7 +9467,7 @@ async function syncToBroker(meshSlug, grants) {
   }
 }
 function readGrants() {
-  if (!existsSync17(GRANT_FILE))
+  if (!existsSync18(GRANT_FILE))
     return {};
   try {
     return JSON.parse(readFileSync12(GRANT_FILE, "utf-8"));
@@ -9153,8 +9476,8 @@ function readGrants() {
   }
 }
 function writeGrants(g) {
-  const dir = join9(homedir8(), ".claudemesh");
-  if (!existsSync17(dir))
+  const dir = join11(homedir10(), ".claudemesh");
+  if (!existsSync18(dir))
     mkdirSync5(dir, { recursive: true });
   writeFileSync9(GRANT_FILE, JSON.stringify(g, null, 2), { mode: 384 });
 }
@@ -9312,7 +9635,7 @@ var init_grants = __esm(() => {
   BROKER_HTTP7 = URLS.BROKER.replace("wss://", "https://").replace("ws://", "http://").replace("/ws", "");
   ALL_CAPS = ["read", "dm", "broadcast", "state-read", "state-write", "file-read"];
   DEFAULT_CAPS = ["read", "dm", "broadcast", "state-read"];
-  GRANT_FILE = join9(homedir8(), ".claudemesh", "grants.json");
+  GRANT_FILE = join11(homedir10(), ".claudemesh", "grants.json");
 });
 
 // src/mcp/tools/definitions.ts
@@ -10238,6 +10561,165 @@ var init_definitions = __esm(() => {
   ];
 });
 
+// src/services/bridge/server.ts
+import { createServer as createServer2 } from "node:net";
+import { mkdirSync as mkdirSync6, unlinkSync as unlinkSync2, existsSync as existsSync19, chmodSync as chmodSync5 } 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)"}`
+    };
+  }
+  return { ok: true, spec: match.pubkey };
+}
+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 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) => {
+        try {
+          socket.write(frame(res));
+        } catch {}
+      });
+    }
+  });
+  socket.on("error", () => {});
+}
+function startBridgeServer(client) {
+  const path = socketPath(client.meshSlug);
+  const dir = socketDir();
+  if (!existsSync19(dir)) {
+    mkdirSync6(dir, { recursive: true, mode: 448 });
+  }
+  if (existsSync19(path)) {
+    try {
+      unlinkSync2(path);
+    } catch {}
+  }
+  const server = createServer2((socket) => handleConnection(socket, client));
+  try {
+    server.listen(path);
+  } catch (err) {
+    process.stderr.write(`[claudemesh] bridge: failed to bind ${path}: ${String(err)}
+`);
+    return null;
+  }
+  server.on("error", (err) => {
+    process.stderr.write(`[claudemesh] bridge: ${String(err)}
+`);
+  });
+  try {
+    chmodSync5(path, 384);
+  } catch {}
+  let stopped = false;
+  return {
+    path,
+    stop() {
+      if (stopped)
+        return;
+      stopped = true;
+      try {
+        server.close();
+      } catch {}
+      try {
+        unlinkSync2(path);
+      } catch {}
+    }
+  };
+}
+var init_server = __esm(() => {
+  init_protocol();
+});
+
 // src/mcp/server.ts
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
@@ -10803,12 +11285,12 @@ ${peerLines.join(`
           }
         }
         try {
-          const { writeFileSync: writeFileSync10, mkdirSync: mkdirSync6, existsSync: existsSync18 } = await import("node:fs");
+          const { writeFileSync: writeFileSync10, mkdirSync: mkdirSync7, existsSync: existsSync20 } = await import("node:fs");
           const { join: joinPath } = await import("node:path");
-          const { homedir: homedir9 } = await import("node:os");
-          const dir = joinPath(homedir9(), ".claudemesh");
-          if (!existsSync18(dir))
-            mkdirSync6(dir, { recursive: true });
+          const { homedir: homedir11 } = await import("node:os");
+          const dir = joinPath(homedir11(), ".claudemesh");
+          if (!existsSync20(dir))
+            mkdirSync7(dir, { recursive: true });
           writeFileSync10(joinPath(dir, "peer-cache.json"), JSON.stringify(statusCache));
         } catch {}
         return text(sections.join(`
@@ -11051,17 +11533,17 @@ ${lines.join(`
         const { path: filePath, name: fileName, tags, to: fileTo } = args ?? {};
         if (!filePath)
           return text("share_file: `path` required", true);
-        const { existsSync: existsSync18 } = await import("node:fs");
-        if (!existsSync18(filePath))
+        const { existsSync: existsSync20 } = await import("node:fs");
+        if (!existsSync20(filePath))
           return text(`share_file: file not found: ${filePath}`, true);
         const client = allClients()[0];
         if (!client)
           return text("share_file: not connected", true);
         if (fileTo) {
           const { encryptFile: encryptFile2, sealKeyForPeer: sealKeyForPeer2 } = await Promise.resolve().then(() => (init_file_crypto(), exports_file_crypto));
-          const { readFileSync: readFileSync13, writeFileSync: writeFileSync10, mkdtempSync: mkdtempSync2, unlinkSync: unlinkSync2, rmdirSync } = await import("node:fs");
+          const { readFileSync: readFileSync13, writeFileSync: writeFileSync10, mkdtempSync: mkdtempSync2, unlinkSync: unlinkSync3, rmdirSync } = await import("node:fs");
           const { tmpdir: tmpdir2 } = await import("node:os");
-          const { join: join10, basename } = await import("node:path");
+          const { join: join12, basename } = await import("node:path");
           const peers = await client.listPeers();
           const targetPeer = peers.find((p) => p.pubkey === fileTo || p.displayName === fileTo);
           if (!targetPeer) {
@@ -11084,8 +11566,8 @@ ${lines.join(`
           combined.set(ciphertext, nonceBytes.length);
           const rawName = fileName ?? basename(filePath);
           const baseName = basename(rawName).replace(/[^a-zA-Z0-9._-]/g, "_").slice(0, 255);
-          const tmpDir = mkdtempSync2(join10(tmpdir2(), "cm-"));
-          const tmpPath = join10(tmpDir, baseName);
+          const tmpDir = mkdtempSync2(join12(tmpdir2(), "cm-"));
+          const tmpPath = join12(tmpDir, baseName);
           writeFileSync10(tmpPath, combined);
           try {
             const fileId = await client.uploadFile(tmpPath, client.meshId, client.meshSlug, {
@@ -11101,7 +11583,7 @@ ${lines.join(`
             return text(`share_file: upload failed — ${e instanceof Error ? e.message : String(e)}`, true);
           } finally {
             try {
-              unlinkSync2(tmpPath);
+              unlinkSync3(tmpPath);
             } catch {}
             try {
               rmdirSync(tmpDir);
@@ -11161,9 +11643,9 @@ ${lines.join(`
           const plaintext = await decryptFile2(ciphertext, nonce, kf);
           if (!plaintext)
             return text(genericErr, true);
-          const { writeFileSync: writeFileSync11, mkdirSync: mkdirSync7 } = await import("node:fs");
-          const { dirname: dirname5 } = await import("node:path");
-          mkdirSync7(dirname5(save_to), { recursive: true });
+          const { writeFileSync: writeFileSync11, mkdirSync: mkdirSync8 } = await import("node:fs");
+          const { dirname: dirname6 } = await import("node:path");
+          mkdirSync8(dirname6(save_to), { recursive: true });
           writeFileSync11(save_to, plaintext);
           return text(`Downloaded and decrypted: ${result.name} → ${save_to}`);
         }
@@ -11174,9 +11656,9 @@ ${lines.join(`
         }
         if (!res.ok)
           return text(`get_file: download failed (${res.status})`, true);
-        const { writeFileSync: writeFileSync10, mkdirSync: mkdirSync6 } = await import("node:fs");
-        const { dirname: dirname4 } = await import("node:path");
-        mkdirSync6(dirname4(save_to), { recursive: true });
+        const { writeFileSync: writeFileSync10, mkdirSync: mkdirSync7 } = await import("node:fs");
+        const { dirname: dirname5 } = await import("node:path");
+        mkdirSync7(dirname5(save_to), { recursive: true });
         writeFileSync10(save_to, Buffer.from(await res.arrayBuffer()));
         return text(`Downloaded: ${result.name} → ${save_to}`);
       }
@@ -11935,8 +12417,8 @@ ${lines.join(`
         const entryType = vType ?? "env";
         let plaintextBytes;
         if (entryType === "file") {
-          const { existsSync: existsSync18, readFileSync: readFileSync13 } = await import("node:fs");
-          if (!existsSync18(value))
+          const { existsSync: existsSync20, readFileSync: readFileSync13 } = await import("node:fs");
+          if (!existsSync20(value))
             return text(`vault_set: file not found: ${value}`, true);
           plaintextBytes = new Uint8Array(readFileSync13(value));
         } else {
@@ -12195,8 +12677,14 @@ ${lines.join(`
   });
   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(() => {});
   });
@@ -12369,6 +12857,11 @@ ${lines.join(`
   const keepalive = setInterval(() => {}, 1000);
   const shutdown = () => {
     clearInterval(keepalive);
+    for (const b of bridges) {
+      try {
+        b.stop();
+      } catch {}
+    }
     stopAll();
     process.exit(0);
   };
@@ -12490,10 +12983,11 @@ async function startServiceProxy(serviceName) {
   process.on("SIGINT", shutdown);
 }
 var peerNameCache, peerNameCacheAge = 0, CACHE_TTL_MS = 30000, DEPRECATED_TOOL_HINTS, warnedTools;
-var init_server = __esm(() => {
+var init_server2 = __esm(() => {
   init_definitions();
   init_facade();
   init_facade8();
+  init_server();
   peerNameCache = new Map;
   DEPRECATED_TOOL_HINTS = {
     send_message: "claudemesh send <to> <msg> [--mesh X] [--priority Y]",
@@ -12537,7 +13031,7 @@ async function runMcp() {
   process.exit(0);
 }
 var init_mcp = __esm(() => {
-  init_server();
+  init_server2();
 });
 
 // src/commands/hook.ts
@@ -12993,12 +13487,12 @@ async function main() {
     }
     case "peers": {
       const { runPeers: runPeers2 } = await Promise.resolve().then(() => (init_peers(), exports_peers));
-      await runPeers2({ mesh: flags.mesh, json: !!flags.json });
+      await runPeers2({ mesh: flags.mesh, json: flags.json });
       break;
     }
     case "send": {
       const { runSend: runSend2 } = await Promise.resolve().then(() => (init_send(), exports_send));
-      await runSend2({}, positionals[0] ?? "", positionals.slice(1).join(" "));
+      await runSend2({ mesh: flags.mesh, priority: flags.priority, json: !!flags.json }, positionals[0] ?? "", positionals.slice(1).join(" "));
       break;
     }
     case "inbox": {
@@ -13246,4 +13740,4 @@ main().catch((err) => {
   process.exit(EXIT.INTERNAL_ERROR);
 });
 
-//# debugId=0A4A6F72C9E014B864756E2164756E21
+//# debugId=E126BD4968D2FCDF64756E2164756E21