claudemesh-cli 1.0.3 → 1.2.0

package/dist/entrypoints/cli.js

@@ -88,7 +88,7 @@ __export(exports_urls, {
   VERSION: () => VERSION,
   URLS: () => URLS
 });
-var URLS, VERSION = "1.0.3", env;
+var URLS, VERSION = "1.2.0", 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
@@ -6715,6 +6882,313 @@ var init_recall = __esm(() => {
   init_exit_codes();
 });
 
+// src/commands/broker-actions.ts
+var exports_broker_actions = {};
+__export(exports_broker_actions, {
+  runVisible: () => runVisible,
+  runTaskComplete: () => runTaskComplete,
+  runTaskClaim: () => runTaskClaim,
+  runSummary: () => runSummary,
+  runStatusSet: () => runStatusSet,
+  runStats: () => runStats,
+  runPing: () => runPing,
+  runMsgStatus: () => runMsgStatus,
+  runGroupLeave: () => runGroupLeave,
+  runGroupJoin: () => runGroupJoin,
+  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)
+    console.log(JSON.stringify({ status: state }));
+  else
+    render.ok(`status set to ${bold(state)}`);
+  return EXIT.SUCCESS;
+}
+async function runSummary(text, opts) {
+  if (!text) {
+    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)
+    console.log(JSON.stringify({ summary: text }));
+  else
+    render.ok("summary set", dim(text));
+  return EXIT.SUCCESS;
+}
+async function runVisible(value, opts) {
+  let visible;
+  if (value === "true" || value === "1" || value === "yes")
+    visible = true;
+  else if (value === "false" || value === "0" || value === "no")
+    visible = false;
+  else {
+    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)
+    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;
+}
+async function runGroupJoin(name, opts) {
+  if (!name) {
+    render.err("Usage: claudemesh group join @<name> [--role X]");
+    return EXIT.INVALID_ARGS;
+  }
+  const cleanName = name.startsWith("@") ? name.slice(1) : name;
+  await withMesh({ meshSlug: opts.mesh ?? null }, async (client) => {
+    await client.joinGroup(cleanName, opts.role);
+  });
+  if (opts.json) {
+    console.log(JSON.stringify({ group: cleanName, role: opts.role ?? null }));
+    return EXIT.SUCCESS;
+  }
+  render.ok(`joined ${clay("@" + cleanName)}`, opts.role ? `as ${opts.role}` : undefined);
+  return EXIT.SUCCESS;
+}
+async function runGroupLeave(name, opts) {
+  if (!name) {
+    render.err("Usage: claudemesh group leave @<name>");
+    return EXIT.INVALID_ARGS;
+  }
+  const cleanName = name.startsWith("@") ? name.slice(1) : name;
+  await withMesh({ meshSlug: opts.mesh ?? null }, async (client) => {
+    await client.leaveGroup(cleanName);
+  });
+  if (opts.json) {
+    console.log(JSON.stringify({ group: cleanName, left: true }));
+    return EXIT.SUCCESS;
+  }
+  render.ok(`left ${clay("@" + cleanName)}`);
+  return EXIT.SUCCESS;
+}
+async function runForget(id, opts) {
+  if (!id) {
+    render.err("Usage: claudemesh forget <memory-id>");
+    return EXIT.INVALID_ARGS;
+  }
+  await withMesh({ meshSlug: opts.mesh ?? null }, async (client) => {
+    await client.forget(id);
+  });
+  if (opts.json) {
+    console.log(JSON.stringify({ id, forgotten: true }));
+    return EXIT.SUCCESS;
+  }
+  render.ok(`forgot ${dim(id.slice(0, 8))}`);
+  return EXIT.SUCCESS;
+}
+async function runMsgStatus(id, opts) {
+  if (!id) {
+    render.err("Usage: claudemesh msg-status <message-id>");
+    return EXIT.INVALID_ARGS;
+  }
+  return await withMesh({ meshSlug: opts.mesh ?? null }, async (client) => {
+    const result = await client.messageStatus(id);
+    if (!result) {
+      if (opts.json)
+        console.log(JSON.stringify({ id, found: false }));
+      else
+        render.err(`Message ${id} not found or timed out.`);
+      return EXIT.NOT_FOUND;
+    }
+    if (opts.json) {
+      console.log(JSON.stringify(result, null, 2));
+      return EXIT.SUCCESS;
+    }
+    render.section(`message ${id.slice(0, 12)}…`);
+    render.kv([
+      ["target", result.targetSpec],
+      ["delivered", result.delivered ? "yes" : "no"],
+      ["delivered_at", result.deliveredAt ?? dim("—")]
+    ]);
+    if (result.recipients.length > 0) {
+      render.blank();
+      render.heading("recipients");
+      for (const r of result.recipients) {
+        process.stdout.write(`  ${bold(r.name)} ${dim(r.pubkey.slice(0, 12) + "…")} ${dim("·")} ${r.status}
+`);
+      }
+    }
+    return EXIT.SUCCESS;
+  });
+}
+async function runClock(opts) {
+  return await withMesh({ meshSlug: opts.mesh ?? null }, async (client) => {
+    const result = await client.getClock();
+    if (!result) {
+      if (opts.json)
+        console.log(JSON.stringify({ error: "timed out" }));
+      else
+        render.err("Clock query timed out");
+      return EXIT.INTERNAL_ERROR;
+    }
+    if (opts.json) {
+      console.log(JSON.stringify(result, null, 2));
+      return EXIT.SUCCESS;
+    }
+    const statusLabel = result.speed === 0 ? "not started" : result.paused ? "paused" : "running";
+    render.section(`mesh clock — ${statusLabel}`);
+    render.kv([
+      ["speed", `x${result.speed}`],
+      ["tick", String(result.tick)],
+      ["sim_time", result.simTime],
+      ["started_at", result.startedAt]
+    ]);
+    return EXIT.SUCCESS;
+  });
+}
+async function runStats(opts) {
+  return await withMesh({ meshSlug: opts.mesh ?? null }, async (client) => {
+    const peers = await client.listPeers();
+    if (opts.json) {
+      console.log(JSON.stringify({
+        mesh: client.meshSlug,
+        peers: peers.map((p) => ({ name: p.displayName, pubkey: p.pubkey, stats: p.stats ?? null }))
+      }, null, 2));
+      return EXIT.SUCCESS;
+    }
+    render.section(client.meshSlug);
+    for (const p of peers) {
+      const s = p.stats;
+      if (!s) {
+        process.stdout.write(`  ${bold(p.displayName)} ${dim("(no stats)")}
+`);
+        continue;
+      }
+      const up = s.uptime != null ? `${Math.floor(s.uptime / 60)}m` : "—";
+      process.stdout.write(`  ${bold(p.displayName)}  ${dim(`in:${s.messagesIn ?? 0}  out:${s.messagesOut ?? 0}  tools:${s.toolCalls ?? 0}  up:${up}  err:${s.errors ?? 0}`)}
+`);
+    }
+    return EXIT.SUCCESS;
+  });
+}
+async function runPing(opts) {
+  return await withMesh({ meshSlug: opts.mesh ?? null }, async (client) => {
+    const peers = await client.listPeers();
+    if (opts.json) {
+      console.log(JSON.stringify({
+        mesh: client.meshSlug,
+        ws_status: client.status,
+        peers_online: peers.length,
+        push_buffer: client.pushHistory.length
+      }, null, 2));
+      return EXIT.SUCCESS;
+    }
+    render.section(`ping ${client.meshSlug}`);
+    render.kv([
+      ["ws_status", client.status],
+      ["peers_online", String(peers.length)],
+      ["push_buffer", String(client.pushHistory.length)]
+    ]);
+    return EXIT.SUCCESS;
+  });
+}
+async function runTaskClaim(id, opts) {
+  if (!id) {
+    render.err("Usage: claudemesh task claim <id>");
+    return EXIT.INVALID_ARGS;
+  }
+  await withMesh({ meshSlug: opts.mesh ?? null }, async (client) => {
+    await client.claimTask(id);
+  });
+  if (opts.json) {
+    console.log(JSON.stringify({ id, claimed: true }));
+    return EXIT.SUCCESS;
+  }
+  render.ok(`claimed ${dim(id.slice(0, 8))}`);
+  return EXIT.SUCCESS;
+}
+async function runTaskComplete(id, result, opts) {
+  if (!id) {
+    render.err("Usage: claudemesh task complete <id> [result]");
+    return EXIT.INVALID_ARGS;
+  }
+  await withMesh({ meshSlug: opts.mesh ?? null }, async (client) => {
+    await client.completeTask(id, result);
+  });
+  if (opts.json) {
+    console.log(JSON.stringify({ id, completed: true, result: result ?? null }));
+    return EXIT.SUCCESS;
+  }
+  render.ok(`completed ${dim(id.slice(0, 8))}`, result);
+  return EXIT.SUCCESS;
+}
+var init_broker_actions = __esm(() => {
+  init_connect();
+  init_facade();
+  init_client3();
+  init_render();
+  init_styles();
+  init_exit_codes();
+});
+
 // src/commands/remind.ts
 var exports_remind = {};
 __export(exports_remind, {
@@ -7021,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)
@@ -7043,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) {
@@ -7072,7 +7546,7 @@ function patchMcpServer(entry) {
   return action;
 }
 function removeMcpServer() {
-  if (!existsSync5(CLAUDE_CONFIG))
+  if (!existsSync6(CLAUDE_CONFIG))
     return false;
   backupClaudeConfig();
   const cfg = readClaudeConfig();
@@ -7120,7 +7594,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)
@@ -7147,7 +7621,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 ?? [];
@@ -7182,7 +7656,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;
@@ -7230,7 +7704,7 @@ function runInstall(args = []) {
     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);
   }
@@ -7346,8 +7820,8 @@ 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");
   CLAUDEMESH_TOOLS = [
     "mcp__claudemesh__cancel_scheduled",
     "mcp__claudemesh__check_messages",
@@ -7402,10 +7876,10 @@ 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 } from "node:fs";
 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);
@@ -7419,7 +7893,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);
@@ -7467,9 +7941,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 homedir6, platform as platform6 } from "node:os";
+import { join as join6 } from "node:path";
 import { spawnSync as spawnSync4 } from "node:child_process";
 function checkNode() {
   const major = Number(process.versions.node.split(".")[0]);
@@ -7493,8 +7967,8 @@ function checkClaudeOnPath() {
   };
 }
 function checkMcpRegistered() {
-  const claudeConfig = join5(homedir5(), ".claude.json");
-  if (!existsSync7(claudeConfig)) {
+  const claudeConfig = join6(homedir6(), ".claude.json");
+  if (!existsSync8(claudeConfig)) {
     return {
       name: "claudemesh MCP registered in ~/.claude.json",
       pass: false,
@@ -7519,8 +7993,8 @@ function checkMcpRegistered() {
   }
 }
 function checkHooksRegistered() {
-  const settings = join5(homedir5(), ".claude", "settings.json");
-  if (!existsSync7(settings)) {
+  const settings = join6(homedir6(), ".claude", "settings.json");
+  if (!existsSync8(settings)) {
     return {
       name: "Status hooks registered in ~/.claude/settings.json",
       pass: false,
@@ -7545,7 +8019,7 @@ function checkHooksRegistered() {
 }
 function checkConfigFile() {
   const path = getConfigPath();
-  if (!existsSync7(path)) {
+  if (!existsSync8(path)) {
     return {
       name: "~/.claudemesh/config.json exists and parses",
       pass: true,
@@ -7728,7 +8202,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) => {
@@ -7758,7 +8232,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`;
   }
@@ -7904,10 +8378,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");
@@ -7925,10 +8399,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");
@@ -7946,10 +8420,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 {
@@ -7967,9 +8441,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 {
@@ -8453,18 +8927,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 homedir7 } from "node:os";
+import { existsSync as existsSync14, mkdirSync as mkdirSync4, writeFileSync as writeFileSync7, rmSync as rmSync2, chmodSync as chmodSync4 } from "node:fs";
+import { join as join7 } 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 = join7(homedir7(), "Library", "Application Support", "claudemesh", "ClaudemeshHandler.app");
+  const contents = join7(appDir, "Contents");
+  const macOS = join7(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">
@@ -8488,7 +8962,7 @@ function installDarwin() {
   </array>
 </dict>
 </plist>`;
-  writeFileSync7(join6(contents, "Info.plist"), plist);
+  writeFileSync7(join7(contents, "Info.plist"), plist);
   const shim = `#!/bin/sh
 URL="$1"
 CODE=\${URL#claudemesh://}
@@ -8502,7 +8976,7 @@ tell application "Terminal"
 end tell
 EOF
 `;
-  const shimPath = join6(macOS, "open-url");
+  const shimPath = join7(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" });
@@ -8514,7 +8988,7 @@ EOF
 }
 function installLinux() {
   const binPath = resolveClaudemeshBin();
-  const appsDir = join6(homedir6(), ".local", "share", "applications");
+  const appsDir = join7(homedir7(), ".local", "share", "applications");
   mkdirSync4(appsDir, { recursive: true });
   const desktop = `[Desktop Entry]
 Type=Application
@@ -8526,7 +9000,7 @@ Terminal=true
 MimeType=x-scheme-handler/claudemesh;
 NoDisplay=true
 `;
-  const desktopPath = join6(appsDir, "claudemesh.desktop");
+  const desktopPath = join7(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) {
@@ -8549,7 +9023,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 = join7(homedir7(), "claudemesh-handler.reg");
   writeFileSync7(regPath, lines.join(`\r
 `));
   const res = spawnSync5("reg.exe", ["import", regPath], { encoding: "utf-8" });
@@ -8561,15 +9035,15 @@ function installWindows() {
   return EXIT.SUCCESS;
 }
 function uninstallDarwin() {
-  const appDir = join6(homedir6(), "Library", "Application Support", "claudemesh", "ClaudemeshHandler.app");
-  if (existsSync13(appDir))
+  const appDir = join7(homedir7(), "Library", "Application Support", "claudemesh", "ClaudemeshHandler.app");
+  if (existsSync14(appDir))
     rmSync2(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))
+  const desktopPath = join7(homedir7(), ".local", "share", "applications", "claudemesh.desktop");
+  if (existsSync14(desktopPath))
     rmSync2(desktopPath, { force: true });
   render.ok("removed claudemesh:// handler on Linux");
   return EXIT.SUCCESS;
@@ -8614,9 +9088,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 join8 } from "node:path";
+import { homedir as homedir8 } from "node:os";
 async function runStatusLine() {
   try {
     const config = readConfig();
@@ -8624,9 +9098,9 @@ async function runStatusLine() {
       process.stdout.write("◇ claudemesh (not joined)");
       return EXIT.SUCCESS;
     }
-    const cachePath = join7(homedir7(), ".claudemesh", "peer-cache.json");
+    const cachePath = join8(homedir8(), ".claudemesh", "peer-cache.json");
     let cache = {};
-    if (existsSync14(cachePath)) {
+    if (existsSync15(cachePath)) {
       try {
         cache = JSON.parse(readFileSync10(cachePath, "utf-8"));
       } catch {}
@@ -8659,7 +9133,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) => {
@@ -8701,7 +9175,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;
   }
@@ -8735,7 +9209,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;
   }
@@ -8758,7 +9232,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}`);
@@ -8783,8 +9257,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 dirname3, join as join9, resolve as resolve2 } from "node:path";
 async function latestVersion() {
   try {
     const res = await fetch(URLS.NPM_REGISTRY, { signal: AbortSignal.timeout(8000) });
@@ -8797,15 +9271,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 = join9(process.env.HOME ?? "", ".claudemesh", "node", "bin", "npm");
+  if (existsSync17(portable)) {
+    return { npm: portable, prefix: join9(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))
+    const candidate = join9(cur, "bin", "npm");
+    if (existsSync17(candidate))
       return { npm: candidate };
   }
   return { npm: "npm" };
@@ -8867,9 +9341,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 homedir9 } from "node:os";
+import { join as join10 } from "node:path";
 async function syncToBroker(meshSlug, grants) {
   const auth = getStoredToken();
   if (!auth)
@@ -8887,7 +9361,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"));
@@ -8896,8 +9370,8 @@ function readGrants() {
   }
 }
 function writeGrants(g) {
-  const dir = join9(homedir8(), ".claudemesh");
-  if (!existsSync17(dir))
+  const dir = join10(homedir9(), ".claudemesh");
+  if (!existsSync18(dir))
     mkdirSync5(dir, { recursive: true });
   writeFileSync9(GRANT_FILE, JSON.stringify(g, null, 2), { mode: 384 });
 }
@@ -9055,7 +9529,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 = join10(homedir9(), ".claudemesh", "grants.json");
 });
 
 // src/mcp/tools/definitions.ts
@@ -9981,6 +10455,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";
@@ -10163,6 +10796,16 @@ function formatPush(p, meshSlug) {
   return `[${meshSlug}]${tag} from ${p.senderPubkey.slice(0, 12)}… (${p.priority}, ${p.createdAt}):
 ${body}`;
 }
+function maybeWarnDeprecated(toolName) {
+  const hint = DEPRECATED_TOOL_HINTS[toolName];
+  if (!hint)
+    return;
+  if (warnedTools.has(toolName))
+    return;
+  warnedTools.add(toolName);
+  process.stderr.write(`[claudemesh] mcp tool "${toolName}" is soft-deprecated in 1.1.0 ` + `and will be removed in 2.0.0. Use \`${hint}\` instead.
+`);
+}
 async function startMcpServer() {
   const serviceIdx = process.argv.indexOf("--service");
   if (serviceIdx !== -1 && process.argv[serviceIdx + 1]) {
@@ -10458,6 +11101,7 @@ ${manifest.allowed_tools.map((t) => `  - ${t}`).join(`
     if (config.meshes.length === 0) {
       return text("No meshes joined. Run `claudemesh join https://claudemesh.com/join/<token>` first.", true);
     }
+    maybeWarnDeprecated(name);
     switch (name) {
       case "send_message": {
         const { to, message, priority } = args ?? {};
@@ -10535,12 +11179,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: homedir10 } = await import("node:os");
+          const dir = joinPath(homedir10(), ".claudemesh");
+          if (!existsSync20(dir))
+            mkdirSync7(dir, { recursive: true });
           writeFileSync10(joinPath(dir, "peer-cache.json"), JSON.stringify(statusCache));
         } catch {}
         return text(sections.join(`
@@ -10783,17 +11427,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: join11, basename } = await import("node:path");
           const peers = await client.listPeers();
           const targetPeer = peers.find((p) => p.pubkey === fileTo || p.displayName === fileTo);
           if (!targetPeer) {
@@ -10816,8 +11460,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(join11(tmpdir2(), "cm-"));
+          const tmpPath = join11(tmpDir, baseName);
           writeFileSync10(tmpPath, combined);
           try {
             const fileId = await client.uploadFile(tmpPath, client.meshId, client.meshSlug, {
@@ -10833,7 +11477,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);
@@ -10893,9 +11537,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 { writeFileSync: writeFileSync11, mkdirSync: mkdirSync8 } = await import("node:fs");
           const { dirname: dirname5 } = await import("node:path");
-          mkdirSync7(dirname5(save_to), { recursive: true });
+          mkdirSync8(dirname5(save_to), { recursive: true });
           writeFileSync11(save_to, plaintext);
           return text(`Downloaded and decrypted: ${result.name} → ${save_to}`);
         }
@@ -10906,9 +11550,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 { writeFileSync: writeFileSync10, mkdirSync: mkdirSync7 } = await import("node:fs");
         const { dirname: dirname4 } = await import("node:path");
-        mkdirSync6(dirname4(save_to), { recursive: true });
+        mkdirSync7(dirname4(save_to), { recursive: true });
         writeFileSync10(save_to, Buffer.from(await res.arrayBuffer()));
         return text(`Downloaded: ${result.name} → ${save_to}`);
       }
@@ -11667,8 +12311,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 {
@@ -11927,8 +12571,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(() => {});
   });
@@ -12101,6 +12751,11 @@ ${lines.join(`
   const keepalive = setInterval(() => {}, 1000);
   const shutdown = () => {
     clearInterval(keepalive);
+    for (const b of bridges) {
+      try {
+        b.stop();
+      } catch {}
+    }
     stopAll();
     process.exit(0);
   };
@@ -12221,12 +12876,41 @@ async function startServiceProxy(serviceName) {
   process.on("SIGTERM", shutdown);
   process.on("SIGINT", shutdown);
 }
-var peerNameCache, peerNameCacheAge = 0, CACHE_TTL_MS = 30000;
-var init_server = __esm(() => {
+var peerNameCache, peerNameCacheAge = 0, CACHE_TTL_MS = 30000, DEPRECATED_TOOL_HINTS, warnedTools;
+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]",
+    list_peers: "claudemesh peers --json",
+    check_messages: "claudemesh inbox --json",
+    message_status: "claudemesh msg-status <id>",
+    set_profile: "claudemesh profile --avatar X --bio Y",
+    set_status: "claudemesh status set <state>",
+    set_summary: "claudemesh summary <text>",
+    set_visible: "claudemesh visible <true|false>",
+    join_group: "claudemesh group join @<name> [--role X]",
+    leave_group: "claudemesh group leave @<name>",
+    get_state: "claudemesh state get <key> --json",
+    set_state: "claudemesh state set <key> <value>",
+    list_state: "claudemesh state list --json",
+    remember: "claudemesh remember <text>",
+    recall: "claudemesh recall <query> --json",
+    forget: "claudemesh forget <id>",
+    schedule_reminder: "claudemesh remind <msg> --in/--at/--cron",
+    list_scheduled: "claudemesh remind list --json",
+    cancel_scheduled: "claudemesh remind cancel <id>",
+    mesh_info: "claudemesh info --json",
+    mesh_stats: "claudemesh stats --json",
+    mesh_clock: "claudemesh clock --json",
+    ping_mesh: "claudemesh ping",
+    claim_task: "claudemesh task claim <id>",
+    complete_task: "claudemesh task complete <id>"
+  };
+  warnedTools = new Set;
 });
 
 // src/commands/mcp.ts
@@ -12241,7 +12925,7 @@ async function runMcp() {
   process.exit(0);
 }
 var init_mcp = __esm(() => {
-  init_server();
+  init_server2();
 });
 
 // src/commands/hook.ts
@@ -12521,12 +13205,28 @@ Messaging
   claudemesh peers                 see who's online
   claudemesh send <to> <msg>       send a message
   claudemesh inbox                 drain pending messages
+  claudemesh msg-status <id>       check delivery status
   claudemesh state get|set|list    shared state
   claudemesh remember <text>       store a memory
   claudemesh recall <query>        search memories
+  claudemesh forget <id>           remove a memory
   claudemesh remind ...            schedule a reminder
   claudemesh profile               view or edit your profile
   claudemesh info                  mesh overview
+  claudemesh stats                 per-peer activity counters
+  claudemesh clock                 mesh logical clock state
+  claudemesh ping                  diagnostic round-trip
+
+Identity / presence
+  claudemesh status set <state>    set peer status (idle | working | dnd)
+  claudemesh summary <text>        broadcast 1-2 sentence work summary
+  claudemesh visible <true|false>  toggle peer visibility
+  claudemesh group join @<name>    join a group (--role X optional)
+  claudemesh group leave @<name>   leave a group
+
+Tasks
+  claudemesh task claim <id>       claim an unclaimed task
+  claudemesh task complete <id>    mark task done [result]
 
 Auth
   claudemesh login                 sign in (browser or paste token)
@@ -12681,12 +13381,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": {
@@ -12723,6 +13423,11 @@ async function main() {
       process.exit(await recall2(positionals.join(" "), { json: !!flags.json }));
       break;
     }
+    case "forget": {
+      const { runForget: runForget2 } = await Promise.resolve().then(() => (init_broker_actions(), exports_broker_actions));
+      process.exit(await runForget2(positionals[0], { mesh: flags.mesh, json: !!flags.json }));
+      break;
+    }
     case "remind": {
       const { runRemind: runRemind2 } = await Promise.resolve().then(() => (init_remind(), exports_remind));
       await runRemind2({ mesh: flags.mesh }, positionals);
@@ -12733,6 +13438,64 @@ async function main() {
       await runProfile2(flags);
       break;
     }
+    case "summary": {
+      const { runSummary: runSummary2 } = await Promise.resolve().then(() => (init_broker_actions(), exports_broker_actions));
+      process.exit(await runSummary2(positionals.join(" "), { mesh: flags.mesh, json: !!flags.json }));
+      break;
+    }
+    case "visible": {
+      const { runVisible: runVisible2 } = await Promise.resolve().then(() => (init_broker_actions(), exports_broker_actions));
+      process.exit(await runVisible2(positionals[0], { mesh: flags.mesh, json: !!flags.json }));
+      break;
+    }
+    case "group": {
+      const sub = positionals[0];
+      if (sub === "join") {
+        const { runGroupJoin: runGroupJoin2 } = await Promise.resolve().then(() => (init_broker_actions(), exports_broker_actions));
+        process.exit(await runGroupJoin2(positionals[1], { mesh: flags.mesh, role: flags.role, json: !!flags.json }));
+      } else if (sub === "leave") {
+        const { runGroupLeave: runGroupLeave2 } = await Promise.resolve().then(() => (init_broker_actions(), exports_broker_actions));
+        process.exit(await runGroupLeave2(positionals[1], { mesh: flags.mesh, json: !!flags.json }));
+      } else {
+        console.error("Usage: claudemesh group <join|leave> @<name> [--role X]");
+        process.exit(EXIT.INVALID_ARGS);
+      }
+      break;
+    }
+    case "msg-status": {
+      const { runMsgStatus: runMsgStatus2 } = await Promise.resolve().then(() => (init_broker_actions(), exports_broker_actions));
+      process.exit(await runMsgStatus2(positionals[0], { mesh: flags.mesh, json: !!flags.json }));
+      break;
+    }
+    case "clock": {
+      const { runClock: runClock2 } = await Promise.resolve().then(() => (init_broker_actions(), exports_broker_actions));
+      process.exit(await runClock2({ mesh: flags.mesh, json: !!flags.json }));
+      break;
+    }
+    case "stats": {
+      const { runStats: runStats2 } = await Promise.resolve().then(() => (init_broker_actions(), exports_broker_actions));
+      process.exit(await runStats2({ mesh: flags.mesh, json: !!flags.json }));
+      break;
+    }
+    case "ping": {
+      const { runPing: runPing2 } = await Promise.resolve().then(() => (init_broker_actions(), exports_broker_actions));
+      process.exit(await runPing2({ mesh: flags.mesh, json: !!flags.json }));
+      break;
+    }
+    case "task": {
+      const sub = positionals[0];
+      if (sub === "claim") {
+        const { runTaskClaim: runTaskClaim2 } = await Promise.resolve().then(() => (init_broker_actions(), exports_broker_actions));
+        process.exit(await runTaskClaim2(positionals[1], { mesh: flags.mesh, json: !!flags.json }));
+      } else if (sub === "complete") {
+        const { runTaskComplete: runTaskComplete2 } = await Promise.resolve().then(() => (init_broker_actions(), exports_broker_actions));
+        process.exit(await runTaskComplete2(positionals[1], positionals.slice(2).join(" ") || undefined, { mesh: flags.mesh, json: !!flags.json }));
+      } else {
+        console.error("Usage: claudemesh task <claim|complete> <id> [result]");
+        process.exit(EXIT.INVALID_ARGS);
+      }
+      break;
+    }
     case "login": {
       const { login: login2 } = await Promise.resolve().then(() => (init_login(), exports_login));
       process.exit(await login2());
@@ -12769,8 +13532,13 @@ async function main() {
       break;
     }
     case "status": {
-      const { runStatus: runStatus2 } = await Promise.resolve().then(() => (init_status(), exports_status));
-      await runStatus2();
+      if (positionals[0] === "set") {
+        const { runStatusSet: runStatusSet2 } = await Promise.resolve().then(() => (init_broker_actions(), exports_broker_actions));
+        process.exit(await runStatusSet2(positionals[1] ?? "", { mesh: flags.mesh, json: !!flags.json }));
+      } else {
+        const { runStatus: runStatus2 } = await Promise.resolve().then(() => (init_status(), exports_status));
+        await runStatus2();
+      }
       break;
     }
     case "sync": {
@@ -12866,4 +13634,4 @@ main().catch((err) => {
   process.exit(EXIT.INTERNAL_ERROR);
 });
 
-//# debugId=AC9613431467FF4964756E2164756E21
+//# debugId=25926A42D1A4B83764756E2164756E21