claudemesh-cli 1.25.0 → 1.27.0

package/dist/entrypoints/cli.js

@@ -103,7 +103,7 @@ __export(exports_urls, {
   VERSION: () => VERSION,
   URLS: () => URLS
 });
-var URLS, VERSION = "1.25.0", env;
+var URLS, VERSION = "1.27.0", env;
 var init_urls = __esm(() => {
   URLS = {
     BROKER: process.env.CLAUDEMESH_BROKER_URL ?? "wss://ic.claudemesh.com/ws",
@@ -6524,1226 +6524,1369 @@ var init_connect = __esm(() => {
   init_facade();
 });
 
-// src/commands/kick.ts
-var exports_kick = {};
-__export(exports_kick, {
-  runKick: () => runKick,
-  runDisconnect: () => runDisconnect
+// src/commands/info.ts
+var exports_info = {};
+__export(exports_info, {
+  runInfo: () => runInfo
 });
-function parseStaleMs(input) {
-  const m = input.match(/^(\d+)(s|m|h)$/);
-  if (!m)
-    return null;
-  const val = parseInt(m[1], 10);
-  const unit = m[2];
-  if (unit === "s")
-    return val * 1000;
-  if (unit === "m")
-    return val * 60000;
-  if (unit === "h")
-    return val * 3600000;
-  return null;
-}
-function buildPayload(kind, target, opts) {
-  if (opts.all)
-    return { type: kind, all: true };
-  if (opts.stale) {
-    const ms = parseStaleMs(opts.stale);
-    if (!ms)
-      return { error: `Invalid stale duration: "${opts.stale}". Use e.g. 30m, 1h, 300s.` };
-    return { type: kind, stale: ms };
-  }
-  if (target)
-    return { type: kind, target };
-  return { error: `Usage: claudemesh ${kind} <peer> | --stale 30m | --all` };
-}
-async function runDisconnect(target, opts = {}) {
+async function runInfo(flags) {
   const config = readConfig();
-  const meshSlug = opts.mesh ?? config.meshes[0]?.slug;
-  if (!meshSlug) {
-    render.err("No mesh joined.");
-    return EXIT.NOT_FOUND;
-  }
-  const built = buildPayload("disconnect", target, opts);
-  if ("error" in built) {
-    render.err(String(built.error));
-    return EXIT.INVALID_ARGS;
-  }
-  return await withMesh({ meshSlug }, async (client) => {
-    const result = await client.sendAndWait(built);
-    const peers = result?.affected ?? result?.kicked ?? [];
-    if (peers.length === 0)
-      render.info("No peers matched.");
-    else {
-      render.ok(`Disconnected ${peers.length} peer(s): ${peers.join(", ")}`);
-      render.hint("They will auto-reconnect within seconds. For a session-ending kick, use `claudemesh kick`.");
+  await withMesh({ meshSlug: flags.mesh ?? null }, async (client, mesh) => {
+    const [brokerInfo, peers, state] = await Promise.all([
+      client.meshInfo(),
+      client.listPeers(),
+      client.listState()
+    ]);
+    const output = {
+      slug: mesh.slug,
+      meshId: mesh.meshId,
+      memberId: mesh.memberId,
+      brokerUrl: mesh.brokerUrl,
+      displayName: config.displayName ?? null,
+      peerCount: peers.length,
+      stateCount: state.length,
+      ...brokerInfo ?? {}
+    };
+    if (flags.json) {
+      process.stdout.write(JSON.stringify(output, null, 2) + `
+`);
+      return;
     }
-    return EXIT.SUCCESS;
-  });
-}
-async function runKick(target, opts = {}) {
-  const config = readConfig();
-  const meshSlug = opts.mesh ?? config.meshes[0]?.slug;
-  if (!meshSlug) {
-    render.err("No mesh joined.");
-    return EXIT.NOT_FOUND;
-  }
-  const built = buildPayload("kick", target, opts);
-  if ("error" in built) {
-    render.err(String(built.error));
-    return EXIT.INVALID_ARGS;
-  }
-  return await withMesh({ meshSlug }, async (client) => {
-    const result = await client.sendAndWait(built);
-    const peers = result?.affected ?? result?.kicked ?? [];
-    if (peers.length === 0)
-      render.info("No peers matched.");
-    else {
-      render.ok(`Kicked ${peers.length} peer(s): ${peers.join(", ")}`);
-      render.hint("Their Claude Code session ended. They can rejoin anytime by running `claudemesh`.");
+    render.section(`${mesh.slug} · ${mesh.brokerUrl}`);
+    render.kv([
+      ["mesh", mesh.meshId],
+      ["member", mesh.memberId],
+      ["peers", `${peers.length} connected`],
+      ["state", `${state.length} keys`]
+    ]);
+    if (brokerInfo && typeof brokerInfo === "object") {
+      const extras = [];
+      for (const [k, v] of Object.entries(brokerInfo)) {
+        if (["slug", "meshId", "brokerUrl"].includes(k))
+          continue;
+        extras.push([k, JSON.stringify(v)]);
+      }
+      if (extras.length)
+        render.kv(extras);
     }
-    return EXIT.SUCCESS;
   });
 }
-var init_kick = __esm(() => {
+var init_info2 = __esm(() => {
   init_connect();
   init_facade();
   init_render();
-  init_exit_codes();
 });
 
-// src/commands/ban.ts
-var exports_ban = {};
-__export(exports_ban, {
-  runUnban: () => runUnban,
-  runBans: () => runBans,
-  runBan: () => runBan
-});
-async function runBan(target, opts = {}) {
-  if (!target) {
-    render.err("Usage: claudemesh ban <peer-name-or-pubkey>");
-    return EXIT.INVALID_ARGS;
-  }
-  const config = readConfig();
-  const meshSlug = opts.mesh ?? config.meshes[0]?.slug;
-  if (!meshSlug) {
-    render.err("No mesh joined.");
-    return EXIT.NOT_FOUND;
-  }
-  return await withMesh({ meshSlug }, async (client) => {
-    const result = await client.sendAndWait({ type: "ban", target });
-    if (result?.banned) {
-      render.ok(`Banned ${result.banned} from ${meshSlug}. They cannot reconnect until unbanned.`);
-      render.hint(`Undo: claudemesh unban ${result.banned} --mesh ${meshSlug}`);
-    } else {
-      render.err(result?.message ?? result?.error ?? result?.code ?? "ban failed");
-    }
-    return result?.banned ? EXIT.SUCCESS : EXIT.INTERNAL_ERROR;
-  });
-}
-async function runUnban(target, opts = {}) {
-  if (!target) {
-    render.err("Usage: claudemesh unban <peer-name-or-pubkey>");
-    return EXIT.INVALID_ARGS;
-  }
-  const config = readConfig();
-  const meshSlug = opts.mesh ?? config.meshes[0]?.slug;
-  if (!meshSlug) {
-    render.err("No mesh joined.");
-    return EXIT.NOT_FOUND;
-  }
-  return await withMesh({ meshSlug }, async (client) => {
-    const result = await client.sendAndWait({ type: "unban", target });
-    if (result?.unbanned) {
-      render.ok(`Unbanned ${result.unbanned} from ${meshSlug}. They can rejoin.`);
-    } else {
-      render.err(result?.message ?? result?.error ?? result?.code ?? "unban failed");
-    }
-    return result?.unbanned ? EXIT.SUCCESS : EXIT.INTERNAL_ERROR;
-  });
-}
-async function runBans(opts = {}) {
-  const config = readConfig();
-  const meshSlug = opts.mesh ?? config.meshes[0]?.slug;
-  if (!meshSlug) {
-    render.err("No mesh joined.");
-    return EXIT.NOT_FOUND;
-  }
-  return await withMesh({ meshSlug }, async (client) => {
-    const result = await client.sendAndWait({ type: "list_bans" });
-    const bans = result?.bans ?? [];
-    if (opts.json) {
-      process.stdout.write(JSON.stringify(bans, null, 2) + `
-`);
-      return EXIT.SUCCESS;
-    }
-    if (bans.length === 0) {
-      render.info("No banned members.");
-      return EXIT.SUCCESS;
+// src/services/api/with-rest-key.ts
+async function withRestKey(opts, fn) {
+  return withMesh({ meshSlug: opts.meshSlug ?? null }, async (client, mesh) => {
+    const result = await client.apiKeyCreate({
+      label: `cli-${opts.purpose ?? "rest"}-${process.pid}`,
+      capabilities: opts.capabilities ?? ["read"],
+      topicScopes: opts.topicScopes ?? undefined,
+      expiresAt: new Date(Date.now() + 5 * 60 * 1000).toISOString()
+    });
+    if (!result || !result.secret) {
+      throw new Error("apikey mint failed — broker did not return a secret");
     }
-    render.section(`banned members on ${meshSlug}`);
-    for (const b of bans) {
-      render.kv([[b.name, `${b.pubkey.slice(0, 16)}… · banned ${new Date(b.revokedAt).toLocaleDateString()}`]]);
+    try {
+      return await fn({
+        secret: result.secret,
+        meshId: mesh.meshId,
+        meshSlug: mesh.slug,
+        client,
+        mesh
+      });
+    } finally {
+      try {
+        await client.apiKeyRevoke(result.id);
+      } catch {}
     }
-    return EXIT.SUCCESS;
   });
 }
-var init_ban = __esm(() => {
+var init_with_rest_key = __esm(() => {
   init_connect();
-  init_facade();
-  init_render();
-  init_exit_codes();
 });
 
-// src/services/bridge/protocol.ts
-import { homedir as homedir5 } from "node:os";
-import { join as join6 } from "node:path";
-function socketPath(meshSlug) {
-  return join6(homedir5(), ".claudemesh", "sockets", `${meshSlug}.sock`);
-}
-function frame(obj) {
-  return JSON.stringify(obj) + `
-`;
+// src/commands/me.ts
+var exports_me = {};
+__export(exports_me, {
+  runMeTopics: () => runMeTopics,
+  runMeTasks: () => runMeTasks,
+  runMeState: () => runMeState,
+  runMeSearch: () => runMeSearch,
+  runMeNotifications: () => runMeNotifications,
+  runMeMemory: () => runMeMemory,
+  runMeActivity: () => runMeActivity,
+  runMe: () => runMe
+});
+function resolveMeshForMint(explicit) {
+  if (explicit)
+    return explicit;
+  const cfg = readConfig();
+  return cfg.meshes[0]?.slug ?? null;
 }
-
-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(`
+async function runMe(flags) {
+  return withRestKey({
+    meshSlug: resolveMeshForMint(flags.mesh),
+    purpose: "workspace-overview",
+    capabilities: ["read"]
+  }, async ({ secret }) => {
+    const ws = await request({
+      path: "/api/v1/me/workspace",
+      token: secret
+    });
+    if (flags.json) {
+      console.log(JSON.stringify(ws, null, 2));
+      return EXIT.SUCCESS;
+    }
+    render.section(`${clay("workspace")} — ${bold(ws.userId.slice(0, 8))}  ${dim(`· ${ws.totals.meshes} mesh${ws.totals.meshes === 1 ? "" : "es"}`)}`);
+    const totalsLine = [
+      `${green(String(ws.totals.online))}/${ws.totals.peers} online`,
+      `${ws.totals.topics} topic${ws.totals.topics === 1 ? "" : "s"}`,
+      ws.totals.unreadMentions > 0 ? yellow(`${ws.totals.unreadMentions} unread @you`) : dim("0 unread @you")
+    ].join(dim(" · "));
+    process.stdout.write("  " + totalsLine + `
+
 `);
+    if (ws.meshes.length === 0) {
+      process.stdout.write(dim("  no meshes joined — run `claudemesh new` or accept an invite\n"));
+      return EXIT.SUCCESS;
     }
-    return lines;
-  }
+    const slugWidth = Math.max(...ws.meshes.map((m) => m.slug.length), 8);
+    for (const m of ws.meshes) {
+      const slug = cyan(m.slug.padEnd(slugWidth));
+      const peers = `${m.online}/${m.peers}`;
+      const role = dim(m.myRole);
+      const unread = m.unreadMentions > 0 ? "  " + yellow(`${m.unreadMentions} @you`) : "";
+      process.stdout.write(`  ${slug}  ${peers.padStart(5)} online  ${dim(String(m.topics).padStart(2) + " topics")}  ${role}${unread}
+`);
+    }
+    return EXIT.SUCCESS;
+  });
 }
-var init_protocol = () => {};
-
-// src/services/bridge/client.ts
-import { createConnection } from "node:net";
-import { existsSync as existsSync6 } 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 (!existsSync6(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);
+async function runMeTopics(flags) {
+  return withRestKey({
+    meshSlug: resolveMeshForMint(flags.mesh),
+    purpose: "workspace-topics",
+    capabilities: ["read"]
+  }, async ({ secret }) => {
+    const ws = await request({
+      path: "/api/v1/me/topics",
+      token: secret
     });
+    const visible = flags.unread ? ws.topics.filter((t) => t.unread > 0) : ws.topics;
+    if (flags.json) {
+      console.log(JSON.stringify({ topics: visible, totals: ws.totals }, null, 2));
+      return EXIT.SUCCESS;
+    }
+    render.section(`${clay("topics")} — ${ws.totals.topics} across all meshes  ${dim(ws.totals.unread > 0 ? `· ${ws.totals.unread} unread` : "· all read")}`);
+    if (visible.length === 0) {
+      process.stdout.write(dim(flags.unread ? `  no unread topics
+` : "  no topics — run `claudemesh topic create #general`\n"));
+      return EXIT.SUCCESS;
+    }
+    const slugWidth = Math.max(...visible.map((t) => t.meshSlug.length), 6);
+    const nameWidth = Math.max(...visible.map((t) => t.name.length), 8);
+    for (const t of visible) {
+      const slug = dim(t.meshSlug.padEnd(slugWidth));
+      const name = cyan(t.name.padEnd(nameWidth));
+      const unread = t.unread > 0 ? yellow(`${t.unread} unread`.padStart(10)) : dim("·".padStart(10));
+      const last = t.lastMessageAt ? dim(formatRelativeTime(t.lastMessageAt)) : dim("never");
+      process.stdout.write(`  ${slug}  ${name}  ${unread}  ${last}
+`);
+    }
+    return EXIT.SUCCESS;
   });
 }
-var DEFAULT_TIMEOUT_MS = 5000;
-var init_client3 = __esm(() => {
-  init_protocol();
-});
-
-// src/daemon/local-token.ts
-import { mkdirSync as mkdirSync4, readFileSync as readFileSync5, writeFileSync as writeFileSync6 } from "node:fs";
-import { dirname as dirname3 } from "node:path";
-import { randomBytes as randomBytes4 } from "node:crypto";
-function readLocalToken() {
-  try {
-    return readFileSync5(DAEMON_PATHS.TOKEN_FILE, "utf8").trim();
-  } catch {
-    return null;
-  }
+async function runMeNotifications(flags) {
+  return withRestKey({
+    meshSlug: resolveMeshForMint(flags.mesh),
+    purpose: "workspace-notifications",
+    capabilities: ["read"]
+  }, async ({ secret }) => {
+    const params = new URLSearchParams;
+    if (flags.all)
+      params.set("include", "all");
+    if (flags.since)
+      params.set("since", flags.since);
+    const path = "/api/v1/me/notifications" + (params.toString() ? `?${params.toString()}` : "");
+    const ws = await request({
+      path,
+      token: secret
+    });
+    if (flags.json) {
+      console.log(JSON.stringify(ws, null, 2));
+      return EXIT.SUCCESS;
+    }
+    const headerLabel = flags.all ? "@-mentions (all)" : "@-mentions (unread)";
+    render.section(`${clay(headerLabel)} — ${ws.totals.total} ${dim(ws.totals.unread > 0 ? `· ${ws.totals.unread} unread` : "· nothing pending")}`);
+    if (ws.notifications.length === 0) {
+      process.stdout.write(dim(flags.all ? `  no @-mentions in window
+` : `  inbox zero — nothing waiting
+`));
+      return EXIT.SUCCESS;
+    }
+    const slugWidth = Math.max(...ws.notifications.map((n) => n.meshSlug.length), 6);
+    for (const n of ws.notifications) {
+      const slug = dim(n.meshSlug.padEnd(slugWidth));
+      const topic = cyan(`#${n.topicName}`);
+      const sender = n.senderName ? `from ${n.senderName}` : "from ?";
+      const ago = formatRelativeTime(n.createdAt);
+      const dot = n.read ? dim("·") : yellow("●");
+      const snippet = n.snippet ?? (n.ciphertext ? dim("[encrypted]") : dim("[empty]"));
+      process.stdout.write(`  ${dot}  ${slug}  ${topic}  ${dim(sender)}  ${dim(ago)}
+` + `     ${snippet.length > 200 ? snippet.slice(0, 200) + "…" : snippet}
+`);
+    }
+    return EXIT.SUCCESS;
+  });
 }
-function ensureLocalToken() {
-  const existing = readLocalToken();
-  if (existing)
-    return existing;
-  mkdirSync4(dirname3(DAEMON_PATHS.TOKEN_FILE), { recursive: true, mode: 448 });
-  const tok = randomBytes4(32).toString("base64url");
-  writeFileSync6(DAEMON_PATHS.TOKEN_FILE, tok + `
-`, { mode: 384 });
-  return tok;
+async function runMeActivity(flags) {
+  return withRestKey({
+    meshSlug: resolveMeshForMint(flags.mesh),
+    purpose: "workspace-activity",
+    capabilities: ["read"]
+  }, async ({ secret }) => {
+    const params = new URLSearchParams;
+    if (flags.since)
+      params.set("since", flags.since);
+    const path = "/api/v1/me/activity" + (params.toString() ? `?${params.toString()}` : "");
+    const ws = await request({
+      path,
+      token: secret
+    });
+    if (flags.json) {
+      console.log(JSON.stringify(ws, null, 2));
+      return EXIT.SUCCESS;
+    }
+    render.section(`${clay("activity")} — ${ws.totals.events} ${dim(flags.since ? `since ${flags.since}` : "in the last 24h")}`);
+    if (ws.activity.length === 0) {
+      process.stdout.write(dim(`  quiet — no activity in window
+`));
+      return EXIT.SUCCESS;
+    }
+    const slugWidth = Math.max(...ws.activity.map((a) => a.meshSlug.length), 6);
+    for (const a of ws.activity) {
+      const slug = dim(a.meshSlug.padEnd(slugWidth));
+      const topic = cyan(`#${a.topicName}`);
+      const sender = a.senderName ?? "?";
+      const ago = formatRelativeTime(a.createdAt);
+      const snippet = a.snippet ?? (a.ciphertext ? dim("[encrypted]") : dim("[empty]"));
+      process.stdout.write(`  ${slug}  ${topic}  ${dim(sender + " ·")} ${dim(ago)}
+` + `     ${snippet.length > 200 ? snippet.slice(0, 200) + "…" : snippet}
+`);
+    }
+    return EXIT.SUCCESS;
+  });
 }
-var init_local_token = __esm(() => {
-  init_paths2();
-});
-
-// src/daemon/ipc/client.ts
-import { request as httpRequest } from "node:http";
-async function ipc(opts) {
-  const useTcp = !!opts.preferTcp;
-  const headers = {
-    accept: "application/json",
-    host: "localhost"
-  };
-  let bodyBuf;
-  if (opts.body !== undefined) {
-    bodyBuf = Buffer.from(JSON.stringify(opts.body), "utf8");
-    headers["content-type"] = "application/json";
-    headers["content-length"] = String(bodyBuf.length);
-  }
-  if (useTcp) {
-    const tok = readLocalToken();
-    if (!tok)
-      throw new IpcError(0, null, "daemon local token not found; is the daemon running?");
-    headers.authorization = `Bearer ${tok}`;
+async function runMeSearch(flags) {
+  if (!flags.query || flags.query.length < 2) {
+    process.stderr.write(`Usage: claudemesh me search <query> (min 2 chars)
+`);
+    return EXIT.INVALID_ARGS;
   }
-  return new Promise((resolve, reject) => {
-    const req = httpRequest(useTcp ? { host: DAEMON_TCP_HOST, port: DAEMON_TCP_DEFAULT_PORT, path: opts.path, method: opts.method ?? "GET", headers } : { socketPath: DAEMON_PATHS.SOCK_FILE, path: opts.path, method: opts.method ?? "GET", headers }, (res) => {
-      const chunks = [];
-      res.on("data", (c) => chunks.push(c));
-      res.on("end", () => {
-        const raw = Buffer.concat(chunks).toString("utf8");
-        let parsed = raw;
-        try {
-          parsed = raw.length > 0 ? JSON.parse(raw) : null;
-        } catch {}
-        resolve({ status: res.statusCode ?? 0, body: parsed });
-      });
+  return withRestKey({
+    meshSlug: resolveMeshForMint(flags.mesh),
+    purpose: "workspace-search",
+    capabilities: ["read"]
+  }, async ({ secret }) => {
+    const params = new URLSearchParams({ q: flags.query });
+    const ws = await request({
+      path: `/api/v1/me/search?${params.toString()}`,
+      token: secret
     });
-    req.setTimeout(opts.timeoutMs ?? 5000, () => req.destroy(new Error("ipc_timeout")));
-    req.on("error", (err) => reject(err));
-    if (bodyBuf)
-      req.write(bodyBuf);
-    req.end();
+    if (flags.json) {
+      console.log(JSON.stringify(ws, null, 2));
+      return EXIT.SUCCESS;
+    }
+    render.section(`${clay("search")} — "${flags.query}"  ${dim(`${ws.totals.topics} topic${ws.totals.topics === 1 ? "" : "s"}, ` + `${ws.totals.messages} message${ws.totals.messages === 1 ? "" : "s"}`)}`);
+    if (ws.topics.length === 0 && ws.messages.length === 0) {
+      process.stdout.write(dim(`  no matches
+`));
+      return EXIT.SUCCESS;
+    }
+    if (ws.topics.length > 0) {
+      process.stdout.write(dim(`
+  topics
+`));
+      const slugWidth = Math.max(...ws.topics.map((t) => t.meshSlug.length), 6);
+      for (const t of ws.topics) {
+        const slug = dim(t.meshSlug.padEnd(slugWidth));
+        const name = cyan(`#${t.name}`);
+        const desc = t.description ? dim(` — ${t.description}`) : "";
+        process.stdout.write(`  ${slug}  ${name}${desc}
+`);
+      }
+    }
+    if (ws.messages.length > 0) {
+      process.stdout.write(dim(`
+  messages
+`));
+      const slugWidth = Math.max(...ws.messages.map((m) => m.meshSlug.length), 6);
+      for (const m of ws.messages) {
+        const slug = dim(m.meshSlug.padEnd(slugWidth));
+        const topic = cyan(`#${m.topicName}`);
+        const sender = m.senderName;
+        const ago = formatRelativeTime(m.createdAt);
+        const snippet = m.snippet ?? (m.bodyVersion === 2 ? dim("[encrypted — open the topic to decrypt]") : dim("[empty]"));
+        const highlighted = m.snippet ? highlightMatch(snippet, flags.query) : snippet;
+        process.stdout.write(`  ${slug}  ${topic}  ${dim(sender + " ·")} ${dim(ago)}
+` + `     ${highlighted}
+`);
+      }
+    }
+    return EXIT.SUCCESS;
   });
 }
-var IpcError;
-var init_client4 = __esm(() => {
-  init_paths2();
-  init_local_token();
-  IpcError = class IpcError extends Error {
-    status;
-    payload;
-    constructor(status, payload, msg) {
-      super(msg);
-      this.status = status;
-      this.payload = payload;
-    }
-  };
-});
-
-// src/services/bridge/daemon-route.ts
-var exports_daemon_route = {};
-__export(exports_daemon_route, {
-  trySendViaDaemon: () => trySendViaDaemon,
-  tryListSkillsViaDaemon: () => tryListSkillsViaDaemon,
-  tryListPeersViaDaemon: () => tryListPeersViaDaemon,
-  tryGetSkillViaDaemon: () => tryGetSkillViaDaemon
-});
-import { existsSync as existsSync7 } from "node:fs";
-async function tryListPeersViaDaemon() {
-  if (!existsSync7(DAEMON_PATHS.SOCK_FILE))
-    return null;
-  try {
-    const res = await ipc({ path: "/v1/peers", timeoutMs: 3000 });
-    if (res.status !== 200)
-      return null;
-    return Array.isArray(res.body.peers) ? res.body.peers : [];
-  } catch (err) {
-    const msg = String(err);
-    if (/ENOENT|ECONNREFUSED|ipc_timeout/.test(msg))
-      return null;
-    return null;
-  }
+function highlightMatch(text, query) {
+  if (!query)
+    return text;
+  const idx = text.toLowerCase().indexOf(query.toLowerCase());
+  if (idx === -1)
+    return text;
+  const before = text.slice(0, idx);
+  const match = text.slice(idx, idx + query.length);
+  const after = text.slice(idx + query.length);
+  return `${before}${yellow(match)}${after}`;
 }
-async function tryListSkillsViaDaemon() {
-  if (!existsSync7(DAEMON_PATHS.SOCK_FILE))
-    return null;
-  try {
-    const res = await ipc({ path: "/v1/skills", timeoutMs: 3000 });
-    if (res.status !== 200)
-      return null;
-    return Array.isArray(res.body.skills) ? res.body.skills : [];
-  } catch (err) {
-    const msg = String(err);
-    if (/ENOENT|ECONNREFUSED|ipc_timeout/.test(msg))
-      return null;
-    return null;
-  }
+async function runMeTasks(flags) {
+  return withRestKey({
+    meshSlug: resolveMeshForMint(flags.mesh),
+    purpose: "workspace-tasks",
+    capabilities: ["read"]
+  }, async ({ secret }) => {
+    const params = new URLSearchParams;
+    if (flags.status)
+      params.set("status", flags.status);
+    const path = "/api/v1/me/tasks" + (params.toString() ? `?${params.toString()}` : "");
+    const ws = await request({
+      path,
+      token: secret
+    });
+    if (flags.json) {
+      console.log(JSON.stringify(ws, null, 2));
+      return EXIT.SUCCESS;
+    }
+    render.section(`${clay("tasks")} — ${dim(`${ws.totals.open} open · ${ws.totals.claimed} in-flight · ${ws.totals.completed} done`)}`);
+    if (ws.tasks.length === 0) {
+      process.stdout.write(dim(`  no tasks in window
+`));
+      return EXIT.SUCCESS;
+    }
+    const slugWidth = Math.max(...ws.tasks.map((t) => t.meshSlug.length), 6);
+    for (const t of ws.tasks) {
+      const slug = dim(t.meshSlug.padEnd(slugWidth));
+      const status = t.status === "open" ? yellow("open    ") : t.status === "claimed" ? cyan("working ") : green("done    ");
+      const prio = t.priority === "urgent" ? yellow("!") : t.priority === "low" ? dim("·") : " ";
+      const claimer = t.claimedByName ? dim(` ← ${t.claimedByName}`) : "";
+      process.stdout.write(`  ${slug} ${prio} ${status}  ${t.title}${claimer}
+`);
+    }
+    return EXIT.SUCCESS;
+  });
 }
-async function tryGetSkillViaDaemon(name) {
-  if (!existsSync7(DAEMON_PATHS.SOCK_FILE))
-    return null;
-  try {
-    const res = await ipc({
-      path: `/v1/skills/${encodeURIComponent(name)}`,
-      timeoutMs: 3000
+async function runMeState(flags) {
+  return withRestKey({
+    meshSlug: resolveMeshForMint(flags.mesh),
+    purpose: "workspace-state",
+    capabilities: ["read"]
+  }, async ({ secret }) => {
+    const params = new URLSearchParams;
+    if (flags.key)
+      params.set("key", flags.key);
+    const path = "/api/v1/me/state" + (params.toString() ? `?${params.toString()}` : "");
+    const ws = await request({
+      path,
+      token: secret
     });
-    if (res.status === 404)
-      return null;
-    if (res.status !== 200)
-      return null;
-    return res.body.skill ?? null;
-  } catch {
-    return null;
-  }
+    if (flags.json) {
+      console.log(JSON.stringify(ws, null, 2));
+      return EXIT.SUCCESS;
+    }
+    render.section(`${clay("state")} — ${ws.totals.entries} entr${ws.totals.entries === 1 ? "y" : "ies"} ${dim(`across ${ws.totals.meshes} mesh${ws.totals.meshes === 1 ? "" : "es"}`)}`);
+    if (ws.entries.length === 0) {
+      process.stdout.write(dim(`  no state entries
+`));
+      return EXIT.SUCCESS;
+    }
+    const slugWidth = Math.max(...ws.entries.map((e) => e.meshSlug.length), 6);
+    const keyWidth = Math.max(...ws.entries.map((e) => e.key.length), 8);
+    for (const e of ws.entries) {
+      const slug = dim(e.meshSlug.padEnd(slugWidth));
+      const key = cyan(e.key.padEnd(keyWidth));
+      const valueStr = typeof e.value === "string" ? e.value : JSON.stringify(e.value);
+      const trimmed = valueStr.length > 80 ? valueStr.slice(0, 80) + "…" : valueStr;
+      const ago = dim(formatRelativeTime(e.updatedAt));
+      process.stdout.write(`  ${slug}  ${key}  ${trimmed}  ${ago}
+`);
+    }
+    return EXIT.SUCCESS;
+  });
 }
-async function trySendViaDaemon(args) {
-  if (!existsSync7(DAEMON_PATHS.SOCK_FILE))
-    return null;
-  try {
-    const res = await ipc({
-      method: "POST",
-      path: "/v1/send",
-      timeoutMs: 3000,
-      body: {
-        to: args.to,
-        message: args.message,
-        priority: args.priority,
-        ...args.idempotencyKey ? { client_message_id: args.idempotencyKey } : {}
-      }
+async function runMeMemory(flags) {
+  return withRestKey({
+    meshSlug: resolveMeshForMint(flags.mesh),
+    purpose: "workspace-memory",
+    capabilities: ["read"]
+  }, async ({ secret }) => {
+    const params = new URLSearchParams;
+    if (flags.query)
+      params.set("q", flags.query);
+    const path = "/api/v1/me/memory" + (params.toString() ? `?${params.toString()}` : "");
+    const ws = await request({
+      path,
+      token: secret
     });
-    if (res.status === 202 || res.status === 200) {
-      return {
-        ok: true,
-        messageId: res.body.broker_message_id ?? res.body.client_message_id ?? "",
-        duplicate: res.body.duplicate,
-        status: res.body.status
-      };
+    if (flags.json) {
+      console.log(JSON.stringify(ws, null, 2));
+      return EXIT.SUCCESS;
     }
-    return { ok: false, error: res.body.error ?? `daemon http ${res.status}` };
-  } catch (err) {
-    const msg = String(err);
-    if (/ENOENT|ECONNREFUSED|ipc_timeout/.test(msg))
-      return null;
-    return { ok: false, error: msg };
-  }
+    const headerLabel = flags.query ? `recall — "${flags.query}"` : "recall — last 30 days";
+    render.section(`${clay(headerLabel)}  ${dim(`${ws.totals.entries} match${ws.totals.entries === 1 ? "" : "es"}`)}`);
+    if (ws.memories.length === 0) {
+      process.stdout.write(dim(`  no memories
+`));
+      return EXIT.SUCCESS;
+    }
+    const slugWidth = Math.max(...ws.memories.map((m) => m.meshSlug.length), 6);
+    for (const m of ws.memories) {
+      const slug = dim(m.meshSlug.padEnd(slugWidth));
+      const ago = dim(formatRelativeTime(m.rememberedAt));
+      const tags = m.tags.length > 0 ? "  " + dim("[" + m.tags.join(", ") + "]") : "";
+      const content = m.content.length > 240 ? m.content.slice(0, 240) + "…" : m.content;
+      process.stdout.write(`  ${slug}  ${ago}${tags}
+     ${content}
+`);
+    }
+    return EXIT.SUCCESS;
+  });
 }
-var init_daemon_route = __esm(() => {
-  init_client4();
-  init_paths2();
+function formatRelativeTime(iso) {
+  const then = new Date(iso).getTime();
+  const now = Date.now();
+  const sec = Math.max(0, Math.floor((now - then) / 1000));
+  if (sec < 60)
+    return `${sec}s ago`;
+  if (sec < 3600)
+    return `${Math.floor(sec / 60)}m ago`;
+  if (sec < 86400)
+    return `${Math.floor(sec / 3600)}h ago`;
+  if (sec < 86400 * 30)
+    return `${Math.floor(sec / 86400)}d ago`;
+  if (sec < 86400 * 365)
+    return `${Math.floor(sec / (86400 * 30))}mo ago`;
+  return `${Math.floor(sec / (86400 * 365))}y ago`;
+}
+var init_me = __esm(() => {
+  init_with_rest_key();
+  init_client();
+  init_facade();
+  init_render();
+  init_styles();
+  init_exit_codes();
 });
 
-// src/commands/peers.ts
-var exports_peers = {};
-__export(exports_peers, {
-  runPeers: () => runPeers
+// src/commands/kick.ts
+var exports_kick = {};
+__export(exports_kick, {
+  runKick: () => runKick,
+  runDisconnect: () => runDisconnect
 });
-function projectFields(record, fields) {
-  const out = {};
-  for (const f of fields) {
-    const sourceKey = FIELD_ALIAS[f] ?? f;
-    out[f] = record[sourceKey];
+function parseStaleMs(input) {
+  const m = input.match(/^(\d+)(s|m|h)$/);
+  if (!m)
+    return null;
+  const val = parseInt(m[1], 10);
+  const unit = m[2];
+  if (unit === "s")
+    return val * 1000;
+  if (unit === "m")
+    return val * 60000;
+  if (unit === "h")
+    return val * 3600000;
+  return null;
+}
+function buildPayload(kind, target, opts) {
+  if (opts.all)
+    return { type: kind, all: true };
+  if (opts.stale) {
+    const ms = parseStaleMs(opts.stale);
+    if (!ms)
+      return { error: `Invalid stale duration: "${opts.stale}". Use e.g. 30m, 1h, 300s.` };
+    return { type: kind, stale: ms };
   }
-  return out;
+  if (target)
+    return { type: kind, target };
+  return { error: `Usage: claudemesh ${kind} <peer> | --stale 30m | --all` };
 }
-async function listPeersForMesh(slug) {
+async function runDisconnect(target, opts = {}) {
   const config = readConfig();
-  const joined = config.meshes.find((m) => m.slug === slug);
-  const selfMemberPubkey = joined?.pubkey ?? null;
-  try {
-    const { tryListPeersViaDaemon: tryListPeersViaDaemon2 } = await Promise.resolve().then(() => (init_daemon_route(), exports_daemon_route));
-    const dr = await tryListPeersViaDaemon2();
-    if (dr !== null) {
-      return dr.map((p) => annotateSelf(p, selfMemberPubkey, null));
-    }
-  } catch {}
-  const bridged = await tryBridge(slug, "peers");
-  if (bridged && bridged.ok) {
-    const peers = bridged.result;
-    return peers.map((p) => annotateSelf(p, selfMemberPubkey, null));
+  const meshSlug = opts.mesh ?? config.meshes[0]?.slug;
+  if (!meshSlug) {
+    render.err("No mesh joined.");
+    return EXIT.NOT_FOUND;
   }
-  let result = [];
-  await withMesh({ meshSlug: slug }, async (client) => {
-    const all = await client.listPeers();
-    const selfSessionPubkey = client.getSessionPubkey();
-    result = all.map((p) => annotateSelf(p, selfMemberPubkey, selfSessionPubkey));
+  const built = buildPayload("disconnect", target, opts);
+  if ("error" in built) {
+    render.err(String(built.error));
+    return EXIT.INVALID_ARGS;
+  }
+  return await withMesh({ meshSlug }, async (client) => {
+    const result = await client.sendAndWait(built);
+    const peers = result?.affected ?? result?.kicked ?? [];
+    if (peers.length === 0)
+      render.info("No peers matched.");
+    else {
+      render.ok(`Disconnected ${peers.length} peer(s): ${peers.join(", ")}`);
+      render.hint("They will auto-reconnect within seconds. For a session-ending kick, use `claudemesh kick`.");
+    }
+    return EXIT.SUCCESS;
   });
-  return result;
-}
-function annotateSelf(peer, selfMemberPubkey, selfSessionPubkey) {
-  const isSelf = !!(selfMemberPubkey && peer.memberPubkey && peer.memberPubkey === selfMemberPubkey);
-  const isThisSession = !!(isSelf && selfSessionPubkey && peer.pubkey === selfSessionPubkey);
-  return { ...peer, isSelf, isThisSession };
 }
-async function runPeers(flags) {
+async function runKick(target, opts = {}) {
   const config = readConfig();
-  const slugs = flags.mesh ? [flags.mesh] : config.meshes.map((m) => m.slug);
-  if (slugs.length === 0) {
-    render.err("No meshes joined.");
-    render.hint("claudemesh <invite-url>    # join + launch");
-    process.exit(1);
+  const meshSlug = opts.mesh ?? config.meshes[0]?.slug;
+  if (!meshSlug) {
+    render.err("No mesh joined.");
+    return EXIT.NOT_FOUND;
   }
-  const fieldList = typeof flags.json === "string" && flags.json.length > 0 ? flags.json.split(",").map((s) => s.trim()).filter(Boolean) : null;
-  const wantsJson = flags.json !== undefined && flags.json !== false;
-  const allJson = [];
-  for (const slug of slugs) {
-    try {
-      const peers = await listPeersForMesh(slug);
-      if (wantsJson) {
-        const projected = fieldList ? peers.map((p) => projectFields(p, fieldList)) : peers;
-        allJson.push({ mesh: slug, peers: projected });
-        continue;
-      }
-      render.section(`peers on ${slug} (${peers.length})`);
-      if (peers.length === 0) {
-        render.info(dim("  (no peers connected)"));
-        continue;
-      }
-      for (const p of peers) {
-        const groups = p.groups.length ? " [" + p.groups.map((g) => `@${g.name}${g.role ? `:${g.role}` : ""}`).join(", ") + "]" : "";
-        const statusDot = p.status === "working" ? yellow("●") : green("●");
-        const name = bold(p.displayName);
-        const meta = [];
-        if (p.peerType)
-          meta.push(p.peerType);
-        if (p.channel)
-          meta.push(p.channel);
-        if (p.model)
-          meta.push(p.model);
-        const metaStr = meta.length ? dim(` (${meta.join(", ")})`) : "";
-        const summary = p.summary ? dim(`  — ${p.summary}`) : "";
-        const pubkeyTag = dim(` · ${p.pubkey.slice(0, 16)}…`);
-        const selfTag = p.isThisSession ? dim(" ") + yellow("(this session)") : p.isSelf ? dim(" ") + yellow("(your other session)") : "";
-        render.info(`${statusDot} ${name}${selfTag}${groups}${metaStr}${pubkeyTag}${summary}`);
-        if (p.cwd)
-          render.info(dim(`   cwd: ${p.cwd}`));
-      }
-    } catch (e) {
-      render.err(`${slug}: ${e instanceof Error ? e.message : String(e)}`);
+  const built = buildPayload("kick", target, opts);
+  if ("error" in built) {
+    render.err(String(built.error));
+    return EXIT.INVALID_ARGS;
+  }
+  return await withMesh({ meshSlug }, async (client) => {
+    const result = await client.sendAndWait(built);
+    const peers = result?.affected ?? result?.kicked ?? [];
+    if (peers.length === 0)
+      render.info("No peers matched.");
+    else {
+      render.ok(`Kicked ${peers.length} peer(s): ${peers.join(", ")}`);
+      render.hint("Their Claude Code session ended. They can rejoin anytime by running `claudemesh`.");
     }
-  }
-  if (wantsJson) {
-    process.stdout.write(JSON.stringify(slugs.length === 1 ? allJson[0]?.peers : allJson, null, 2) + `
-`);
-  }
+    return EXIT.SUCCESS;
+  });
 }
-var FIELD_ALIAS;
-var init_peers = __esm(() => {
+var init_kick = __esm(() => {
   init_connect();
   init_facade();
-  init_client3();
   init_render();
-  init_styles();
-  FIELD_ALIAS = {
-    name: "displayName"
-  };
+  init_exit_codes();
 });
 
-// src/commands/send.ts
-var exports_send = {};
-__export(exports_send, {
-  runSend: () => runSend
+// src/commands/ban.ts
+var exports_ban = {};
+__export(exports_ban, {
+  runUnban: () => runUnban,
+  runBans: () => runBans,
+  runBan: () => runBan
 });
-async function runSend(flags, to, message) {
-  if (!to || !message) {
-    render.err("Usage: claudemesh send <to> <message>");
-    process.exit(1);
+async function runBan(target, opts = {}) {
+  if (!target) {
+    render.err("Usage: claudemesh ban <peer-name-or-pubkey>");
+    return EXIT.INVALID_ARGS;
   }
-  const priority = flags.priority === "now" ? "now" : flags.priority === "low" ? "low" : "next";
   const config = readConfig();
-  const meshSlug = flags.mesh ?? (config.meshes.length === 1 ? config.meshes[0].slug : null);
-  if (!flags.self && meshSlug) {
-    const joined = config.meshes.find((m) => m.slug === meshSlug);
-    if (joined && /^[0-9a-f]{64}$/i.test(to) && to.toLowerCase() === joined.pubkey.toLowerCase()) {
-      render.err(`Target "${to.slice(0, 16)}…" is your own member pubkey on mesh "${meshSlug}".`);
-      render.hint("Pass --self to message a sibling session of your own member, or pick a different peer's pubkey.");
-      process.exit(1);
+  const meshSlug = opts.mesh ?? config.meshes[0]?.slug;
+  if (!meshSlug) {
+    render.err("No mesh joined.");
+    return EXIT.NOT_FOUND;
+  }
+  return await withMesh({ meshSlug }, async (client) => {
+    const result = await client.sendAndWait({ type: "ban", target });
+    if (result?.banned) {
+      render.ok(`Banned ${result.banned} from ${meshSlug}. They cannot reconnect until unbanned.`);
+      render.hint(`Undo: claudemesh unban ${result.banned} --mesh ${meshSlug}`);
+    } else {
+      render.err(result?.message ?? result?.error ?? result?.code ?? "ban failed");
     }
+    return result?.banned ? EXIT.SUCCESS : EXIT.INTERNAL_ERROR;
+  });
+}
+async function runUnban(target, opts = {}) {
+  if (!target) {
+    render.err("Usage: claudemesh unban <peer-name-or-pubkey>");
+    return EXIT.INVALID_ARGS;
   }
-  {
-    const dr = await trySendViaDaemon({ to, message, priority, expectedMesh: meshSlug ?? undefined });
-    if (dr !== null) {
-      if (dr.ok) {
-        if (flags.json)
-          console.log(JSON.stringify({ ok: true, messageId: dr.messageId, target: to, via: "daemon", duplicate: !!dr.duplicate }));
-        else
-          render.ok(`sent to ${to} (daemon)`, dr.messageId ? dim(dr.messageId.slice(0, 8)) : undefined);
-        return;
-      }
-      if (flags.json)
-        console.log(JSON.stringify({ ok: false, error: dr.error, via: "daemon" }));
-      else
-        render.err(`send failed (daemon): ${dr.error}`);
-      process.exit(1);
+  const config = readConfig();
+  const meshSlug = opts.mesh ?? config.meshes[0]?.slug;
+  if (!meshSlug) {
+    render.err("No mesh joined.");
+    return EXIT.NOT_FOUND;
+  }
+  return await withMesh({ meshSlug }, async (client) => {
+    const result = await client.sendAndWait({ type: "unban", target });
+    if (result?.unbanned) {
+      render.ok(`Unbanned ${result.unbanned} from ${meshSlug}. They can rejoin.`);
+    } else {
+      render.err(result?.message ?? result?.error ?? result?.code ?? "unban failed");
     }
+    return result?.unbanned ? EXIT.SUCCESS : EXIT.INTERNAL_ERROR;
+  });
+}
+async function runBans(opts = {}) {
+  const config = readConfig();
+  const meshSlug = opts.mesh ?? config.meshes[0]?.slug;
+  if (!meshSlug) {
+    render.err("No mesh joined.");
+    return EXIT.NOT_FOUND;
   }
-  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);
+  return await withMesh({ meshSlug }, async (client) => {
+    const result = await client.sendAndWait({ type: "list_bans" });
+    const bans = result?.bans ?? [];
+    if (opts.json) {
+      process.stdout.write(JSON.stringify(bans, null, 2) + `
+`);
+      return EXIT.SUCCESS;
+    }
+    if (bans.length === 0) {
+      render.info("No banned members.");
+      return EXIT.SUCCESS;
+    }
+    render.section(`banned members on ${meshSlug}`);
+    for (const b of bans) {
+      render.kv([[b.name, `${b.pubkey.slice(0, 16)}… · banned ${new Date(b.revokedAt).toLocaleDateString()}`]]);
+    }
+    return EXIT.SUCCESS;
+  });
+}
+var init_ban = __esm(() => {
+  init_connect();
+  init_facade();
+  init_render();
+  init_exit_codes();
+});
+
+// src/services/bridge/protocol.ts
+import { homedir as homedir5 } from "node:os";
+import { join as join6 } from "node:path";
+function socketPath(meshSlug) {
+  return join6(homedir5(), ".claudemesh", "sockets", `${meshSlug}.sock`);
+}
+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;
   }
-  await withMesh({ meshSlug: flags.mesh ?? null }, async (client) => {
-    let targetSpec = to;
-    if (to.startsWith("#") && !/^#[0-9a-z_-]{20,}$/i.test(to)) {
-      const name = to.slice(1);
-      const topics = await client.topicList();
-      const match = topics.find((t) => t.name === name);
-      if (!match) {
-        const names = topics.map((t) => "#" + t.name).join(", ");
-        render.err(`Topic "${to}" not found.`, `topics: ${names || "(none)"}`);
-        process.exit(1);
-      }
-      targetSpec = "#" + match.id;
-    } else if (!to.startsWith("@") && !to.startsWith("#") && to !== "*" && !/^[0-9a-f]{64}$/i.test(to)) {
-      const peers = await client.listPeers();
-      const match = peers.find((p) => p.displayName.toLowerCase() === to.toLowerCase());
-      if (!match) {
-        const names = peers.map((p) => p.displayName).join(", ");
-        render.err(`Peer "${to}" not found.`, `online: ${names || "(none)"}`);
-        process.exit(1);
+}
+var init_protocol = () => {};
+
+// src/services/bridge/client.ts
+import { createConnection } from "node:net";
+import { existsSync as existsSync6 } 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 (!existsSync6(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);
       }
-      targetSpec = match.pubkey;
-    }
-    const result = await client.send(targetSpec, message, priority);
-    if (result.ok) {
-      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);
+    });
+    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;
       }
-    } else {
-      if (flags.json) {
-        console.log(JSON.stringify({ ok: false, error: result.error ?? "unknown" }));
+    });
+    socket.on("error", (err) => {
+      const code = err.code;
+      if (code === "ECONNREFUSED" || code === "ENOENT" || code === "EPERM") {
+        finish(null);
       } else {
-        render.err(`send failed: ${result.error ?? "unknown error"}`);
+        finish(null);
       }
-      process.exit(1);
-    }
+    });
+    socket.on("close", () => {
+      finish(null);
+    });
   });
 }
-var init_send = __esm(() => {
-  init_connect();
-  init_facade();
-  init_client3();
-  init_daemon_route();
-  init_render();
-  init_styles();
+var DEFAULT_TIMEOUT_MS = 5000;
+var init_client3 = __esm(() => {
+  init_protocol();
 });
 
-// src/commands/inbox.ts
-var exports_inbox = {};
-__export(exports_inbox, {
-  runInbox: () => runInbox
-});
-function formatMessage(msg) {
-  const text = msg.plaintext ?? `[encrypted: ${msg.ciphertext.slice(0, 32)}…]`;
-  const from = msg.senderPubkey.slice(0, 8);
-  const time = new Date(msg.createdAt).toLocaleTimeString();
-  const kindTag = msg.kind === "direct" ? "→ direct" : msg.kind;
-  return `  ${bold(from)} ${dim(`[${kindTag}] ${time}`)}
-  ${text}`;
+// src/daemon/local-token.ts
+import { mkdirSync as mkdirSync4, readFileSync as readFileSync5, writeFileSync as writeFileSync6 } from "node:fs";
+import { dirname as dirname3 } from "node:path";
+import { randomBytes as randomBytes4 } from "node:crypto";
+function readLocalToken() {
+  try {
+    return readFileSync5(DAEMON_PATHS.TOKEN_FILE, "utf8").trim();
+  } catch {
+    return null;
+  }
 }
-async function runInbox(flags) {
-  const waitMs = (flags.wait ?? 1) * 1000;
-  await withMesh({ meshSlug: flags.mesh ?? null }, async (client, mesh) => {
-    await new Promise((resolve) => setTimeout(resolve, waitMs));
-    const messages = client.drainPushBuffer();
-    if (flags.json) {
-      process.stdout.write(JSON.stringify(messages, null, 2) + `
-`);
-      return;
-    }
-    if (messages.length === 0) {
-      render.info(dim(`No messages on mesh "${mesh.slug}".`));
-      return;
-    }
-    render.section(`inbox — ${mesh.slug} (${messages.length} message${messages.length === 1 ? "" : "s"})`);
-    for (const msg of messages) {
-      process.stdout.write(formatMessage(msg) + `
+function ensureLocalToken() {
+  const existing = readLocalToken();
+  if (existing)
+    return existing;
+  mkdirSync4(dirname3(DAEMON_PATHS.TOKEN_FILE), { recursive: true, mode: 448 });
+  const tok = randomBytes4(32).toString("base64url");
+  writeFileSync6(DAEMON_PATHS.TOKEN_FILE, tok + `
+`, { mode: 384 });
+  return tok;
+}
+var init_local_token = __esm(() => {
+  init_paths2();
+});
 
-`);
-    }
+// src/daemon/ipc/client.ts
+import { request as httpRequest } from "node:http";
+async function ipc(opts) {
+  const useTcp = !!opts.preferTcp;
+  const headers = {
+    accept: "application/json",
+    host: "localhost"
+  };
+  let bodyBuf;
+  if (opts.body !== undefined) {
+    bodyBuf = Buffer.from(JSON.stringify(opts.body), "utf8");
+    headers["content-type"] = "application/json";
+    headers["content-length"] = String(bodyBuf.length);
+  }
+  if (useTcp) {
+    const tok = readLocalToken();
+    if (!tok)
+      throw new IpcError(0, null, "daemon local token not found; is the daemon running?");
+    headers.authorization = `Bearer ${tok}`;
+  }
+  return new Promise((resolve, reject) => {
+    const req = httpRequest(useTcp ? { host: DAEMON_TCP_HOST, port: DAEMON_TCP_DEFAULT_PORT, path: opts.path, method: opts.method ?? "GET", headers } : { socketPath: DAEMON_PATHS.SOCK_FILE, path: opts.path, method: opts.method ?? "GET", headers }, (res) => {
+      const chunks = [];
+      res.on("data", (c) => chunks.push(c));
+      res.on("end", () => {
+        const raw = Buffer.concat(chunks).toString("utf8");
+        let parsed = raw;
+        try {
+          parsed = raw.length > 0 ? JSON.parse(raw) : null;
+        } catch {}
+        resolve({ status: res.statusCode ?? 0, body: parsed });
+      });
+    });
+    req.setTimeout(opts.timeoutMs ?? 5000, () => req.destroy(new Error("ipc_timeout")));
+    req.on("error", (err) => reject(err));
+    if (bodyBuf)
+      req.write(bodyBuf);
+    req.end();
   });
 }
-var init_inbox = __esm(() => {
-  init_connect();
-  init_render();
-  init_styles();
+var IpcError;
+var init_client4 = __esm(() => {
+  init_paths2();
+  init_local_token();
+  IpcError = class IpcError extends Error {
+    status;
+    payload;
+    constructor(status, payload, msg) {
+      super(msg);
+      this.status = status;
+      this.payload = payload;
+    }
+  };
 });
 
-// src/commands/state.ts
-var exports_state = {};
-__export(exports_state, {
-  runStateSet: () => runStateSet,
-  runStateList: () => runStateList,
-  runStateGet: () => runStateGet
+// src/services/bridge/daemon-route.ts
+var exports_daemon_route = {};
+__export(exports_daemon_route, {
+  trySetStateViaDaemon: () => trySetStateViaDaemon,
+  trySendViaDaemon: () => trySendViaDaemon,
+  tryRememberViaDaemon: () => tryRememberViaDaemon,
+  tryRecallViaDaemon: () => tryRecallViaDaemon,
+  tryListStateViaDaemon: () => tryListStateViaDaemon,
+  tryListSkillsViaDaemon: () => tryListSkillsViaDaemon,
+  tryListPeersViaDaemon: () => tryListPeersViaDaemon,
+  tryGetStateViaDaemon: () => tryGetStateViaDaemon,
+  tryGetSkillViaDaemon: () => tryGetSkillViaDaemon,
+  tryForgetViaDaemon: () => tryForgetViaDaemon
 });
-async function runStateGet(flags, key) {
-  await withMesh({ meshSlug: flags.mesh ?? null }, async (client) => {
-    const entry = await client.getState(key);
-    if (!entry) {
-      render.info(dim("(not set)"));
-      return;
-    }
-    if (flags.json) {
-      console.log(JSON.stringify(entry, null, 2));
-      return;
-    }
-    const val = typeof entry.value === "string" ? entry.value : JSON.stringify(entry.value);
-    render.info(val);
-    render.info(dim(`  set by ${entry.updatedBy} at ${new Date(entry.updatedAt).toLocaleString()}`));
-  });
+import { existsSync as existsSync7 } from "node:fs";
+function meshQuery(mesh) {
+  return mesh ? `?mesh=${encodeURIComponent(mesh)}` : "";
 }
-async function runStateSet(flags, key, value) {
-  let parsed;
+async function tryListPeersViaDaemon(mesh) {
+  if (!existsSync7(DAEMON_PATHS.SOCK_FILE))
+    return null;
   try {
-    parsed = JSON.parse(value);
-  } catch {
-    parsed = value;
+    const res = await ipc({ path: `/v1/peers${meshQuery(mesh)}`, timeoutMs: 3000 });
+    if (res.status !== 200)
+      return null;
+    return Array.isArray(res.body.peers) ? res.body.peers : [];
+  } catch (err) {
+    const msg = String(err);
+    if (/ENOENT|ECONNREFUSED|ipc_timeout/.test(msg))
+      return null;
+    return null;
   }
-  await withMesh({ meshSlug: flags.mesh ?? null }, async (client) => {
-    await client.setState(key, parsed);
-    render.ok(`${bold(key)} = ${JSON.stringify(parsed)}`);
-  });
 }
-async function runStateList(flags) {
-  await withMesh({ meshSlug: flags.mesh ?? null }, async (client, mesh) => {
-    const entries = await client.listState();
-    if (flags.json) {
-      console.log(JSON.stringify(entries, null, 2));
-      return;
-    }
-    if (entries.length === 0) {
-      render.info(dim(`No state on mesh "${mesh.slug}".`));
-      return;
-    }
-    render.section(`state (${entries.length})`);
-    for (const e of entries) {
-      const val = typeof e.value === "string" ? e.value : JSON.stringify(e.value);
-      process.stdout.write(`  ${bold(e.key)}: ${val}
-`);
-      process.stdout.write(`    ${dim(e.updatedBy + "  ·  " + new Date(e.updatedAt).toLocaleString())}
-`);
-    }
-  });
+async function tryListSkillsViaDaemon(mesh) {
+  if (!existsSync7(DAEMON_PATHS.SOCK_FILE))
+    return null;
+  try {
+    const res = await ipc({ path: `/v1/skills${meshQuery(mesh)}`, timeoutMs: 3000 });
+    if (res.status !== 200)
+      return null;
+    return Array.isArray(res.body.skills) ? res.body.skills : [];
+  } catch (err) {
+    const msg = String(err);
+    if (/ENOENT|ECONNREFUSED|ipc_timeout/.test(msg))
+      return null;
+    return null;
+  }
 }
-var init_state = __esm(() => {
-  init_connect();
-  init_render();
-  init_styles();
-});
-
-// src/services/api/with-rest-key.ts
-async function withRestKey(opts, fn) {
-  return withMesh({ meshSlug: opts.meshSlug ?? null }, async (client, mesh) => {
-    const result = await client.apiKeyCreate({
-      label: `cli-${opts.purpose ?? "rest"}-${process.pid}`,
-      capabilities: opts.capabilities ?? ["read"],
-      topicScopes: opts.topicScopes ?? undefined,
-      expiresAt: new Date(Date.now() + 5 * 60 * 1000).toISOString()
+async function tryGetSkillViaDaemon(name, mesh) {
+  if (!existsSync7(DAEMON_PATHS.SOCK_FILE))
+    return null;
+  try {
+    const res = await ipc({
+      path: `/v1/skills/${encodeURIComponent(name)}${meshQuery(mesh)}`,
+      timeoutMs: 3000
     });
-    if (!result || !result.secret) {
-      throw new Error("apikey mint failed — broker did not return a secret");
-    }
-    try {
-      return await fn({
-        secret: result.secret,
-        meshId: mesh.meshId,
-        meshSlug: mesh.slug,
-        client,
-        mesh
-      });
-    } finally {
-      try {
-        await client.apiKeyRevoke(result.id);
-      } catch {}
-    }
-  });
+    if (res.status === 404)
+      return null;
+    if (res.status !== 200)
+      return null;
+    return res.body.skill ?? null;
+  } catch {
+    return null;
+  }
+}
+async function tryGetStateViaDaemon(key, mesh) {
+  if (!existsSync7(DAEMON_PATHS.SOCK_FILE))
+    return null;
+  try {
+    const path = `/v1/state?key=${encodeURIComponent(key)}${mesh ? `&mesh=${encodeURIComponent(mesh)}` : ""}`;
+    const res = await ipc({ path, timeoutMs: 3000 });
+    if (res.status === 404)
+      return;
+    if (res.status !== 200)
+      return null;
+    return res.body.state ?? undefined;
+  } catch (err) {
+    const msg = String(err);
+    if (/ENOENT|ECONNREFUSED|ipc_timeout/.test(msg))
+      return null;
+    return null;
+  }
 }
-var init_with_rest_key = __esm(() => {
-  init_connect();
-});
-
-// src/commands/me.ts
-var exports_me = {};
-__export(exports_me, {
-  runMeTopics: () => runMeTopics,
-  runMeTasks: () => runMeTasks,
-  runMeState: () => runMeState,
-  runMeSearch: () => runMeSearch,
-  runMeNotifications: () => runMeNotifications,
-  runMeMemory: () => runMeMemory,
-  runMeActivity: () => runMeActivity,
-  runMe: () => runMe
-});
-function resolveMeshForMint(explicit) {
-  if (explicit)
-    return explicit;
-  const cfg = readConfig();
-  return cfg.meshes[0]?.slug ?? null;
+async function tryListStateViaDaemon(mesh) {
+  if (!existsSync7(DAEMON_PATHS.SOCK_FILE))
+    return null;
+  try {
+    const res = await ipc({ path: `/v1/state${meshQuery(mesh)}`, timeoutMs: 3000 });
+    if (res.status !== 200)
+      return null;
+    return Array.isArray(res.body.entries) ? res.body.entries : [];
+  } catch (err) {
+    const msg = String(err);
+    if (/ENOENT|ECONNREFUSED|ipc_timeout/.test(msg))
+      return null;
+    return null;
+  }
 }
-async function runMe(flags) {
-  return withRestKey({
-    meshSlug: resolveMeshForMint(flags.mesh),
-    purpose: "workspace-overview",
-    capabilities: ["read"]
-  }, async ({ secret }) => {
-    const ws = await request({
-      path: "/api/v1/me/workspace",
-      token: secret
+async function trySetStateViaDaemon(key, value, mesh) {
+  if (!existsSync7(DAEMON_PATHS.SOCK_FILE))
+    return false;
+  try {
+    const res = await ipc({
+      method: "POST",
+      path: "/v1/state",
+      timeoutMs: 3000,
+      body: { key, value, ...mesh ? { mesh } : {} }
     });
-    if (flags.json) {
-      console.log(JSON.stringify(ws, null, 2));
-      return EXIT.SUCCESS;
-    }
-    render.section(`${clay("workspace")} — ${bold(ws.userId.slice(0, 8))}  ${dim(`· ${ws.totals.meshes} mesh${ws.totals.meshes === 1 ? "" : "es"}`)}`);
-    const totalsLine = [
-      `${green(String(ws.totals.online))}/${ws.totals.peers} online`,
-      `${ws.totals.topics} topic${ws.totals.topics === 1 ? "" : "s"}`,
-      ws.totals.unreadMentions > 0 ? yellow(`${ws.totals.unreadMentions} unread @you`) : dim("0 unread @you")
-    ].join(dim(" · "));
-    process.stdout.write("  " + totalsLine + `
-
-`);
-    if (ws.meshes.length === 0) {
-      process.stdout.write(dim("  no meshes joined — run `claudemesh new` or accept an invite\n"));
-      return EXIT.SUCCESS;
-    }
-    const slugWidth = Math.max(...ws.meshes.map((m) => m.slug.length), 8);
-    for (const m of ws.meshes) {
-      const slug = cyan(m.slug.padEnd(slugWidth));
-      const peers = `${m.online}/${m.peers}`;
-      const role = dim(m.myRole);
-      const unread = m.unreadMentions > 0 ? "  " + yellow(`${m.unreadMentions} @you`) : "";
-      process.stdout.write(`  ${slug}  ${peers.padStart(5)} online  ${dim(String(m.topics).padStart(2) + " topics")}  ${role}${unread}
-`);
-    }
-    return EXIT.SUCCESS;
-  });
+    return res.status === 200 && res.body.ok === true;
+  } catch {
+    return false;
+  }
 }
-async function runMeTopics(flags) {
-  return withRestKey({
-    meshSlug: resolveMeshForMint(flags.mesh),
-    purpose: "workspace-topics",
-    capabilities: ["read"]
-  }, async ({ secret }) => {
-    const ws = await request({
-      path: "/api/v1/me/topics",
-      token: secret
+async function tryRememberViaDaemon(content, tags, mesh) {
+  if (!existsSync7(DAEMON_PATHS.SOCK_FILE))
+    return null;
+  try {
+    const res = await ipc({
+      method: "POST",
+      path: "/v1/memory",
+      timeoutMs: 5000,
+      body: { content, ...tags?.length ? { tags } : {}, ...mesh ? { mesh } : {} }
     });
-    const visible = flags.unread ? ws.topics.filter((t) => t.unread > 0) : ws.topics;
-    if (flags.json) {
-      console.log(JSON.stringify({ topics: visible, totals: ws.totals }, null, 2));
-      return EXIT.SUCCESS;
-    }
-    render.section(`${clay("topics")} — ${ws.totals.topics} across all meshes  ${dim(ws.totals.unread > 0 ? `· ${ws.totals.unread} unread` : "· all read")}`);
-    if (visible.length === 0) {
-      process.stdout.write(dim(flags.unread ? `  no unread topics
-` : "  no topics — run `claudemesh topic create #general`\n"));
-      return EXIT.SUCCESS;
-    }
-    const slugWidth = Math.max(...visible.map((t) => t.meshSlug.length), 6);
-    const nameWidth = Math.max(...visible.map((t) => t.name.length), 8);
-    for (const t of visible) {
-      const slug = dim(t.meshSlug.padEnd(slugWidth));
-      const name = cyan(t.name.padEnd(nameWidth));
-      const unread = t.unread > 0 ? yellow(`${t.unread} unread`.padStart(10)) : dim("·".padStart(10));
-      const last = t.lastMessageAt ? dim(formatRelativeTime(t.lastMessageAt)) : dim("never");
-      process.stdout.write(`  ${slug}  ${name}  ${unread}  ${last}
-`);
-    }
-    return EXIT.SUCCESS;
-  });
+    if (res.status !== 200 || !res.body.id)
+      return null;
+    return { id: res.body.id, mesh: res.body.mesh };
+  } catch {
+    return null;
+  }
 }
-async function runMeNotifications(flags) {
-  return withRestKey({
-    meshSlug: resolveMeshForMint(flags.mesh),
-    purpose: "workspace-notifications",
-    capabilities: ["read"]
-  }, async ({ secret }) => {
-    const params = new URLSearchParams;
-    if (flags.all)
-      params.set("include", "all");
-    if (flags.since)
-      params.set("since", flags.since);
-    const path = "/api/v1/me/notifications" + (params.toString() ? `?${params.toString()}` : "");
-    const ws = await request({
-      path,
-      token: secret
-    });
-    if (flags.json) {
-      console.log(JSON.stringify(ws, null, 2));
-      return EXIT.SUCCESS;
-    }
-    const headerLabel = flags.all ? "@-mentions (all)" : "@-mentions (unread)";
-    render.section(`${clay(headerLabel)} — ${ws.totals.total} ${dim(ws.totals.unread > 0 ? `· ${ws.totals.unread} unread` : "· nothing pending")}`);
-    if (ws.notifications.length === 0) {
-      process.stdout.write(dim(flags.all ? `  no @-mentions in window
-` : `  inbox zero — nothing waiting
-`));
-      return EXIT.SUCCESS;
-    }
-    const slugWidth = Math.max(...ws.notifications.map((n) => n.meshSlug.length), 6);
-    for (const n of ws.notifications) {
-      const slug = dim(n.meshSlug.padEnd(slugWidth));
-      const topic = cyan(`#${n.topicName}`);
-      const sender = n.senderName ? `from ${n.senderName}` : "from ?";
-      const ago = formatRelativeTime(n.createdAt);
-      const dot = n.read ? dim("·") : yellow("●");
-      const snippet = n.snippet ?? (n.ciphertext ? dim("[encrypted]") : dim("[empty]"));
-      process.stdout.write(`  ${dot}  ${slug}  ${topic}  ${dim(sender)}  ${dim(ago)}
-` + `     ${snippet.length > 200 ? snippet.slice(0, 200) + "…" : snippet}
-`);
-    }
-    return EXIT.SUCCESS;
-  });
+async function tryRecallViaDaemon(query, mesh) {
+  if (!existsSync7(DAEMON_PATHS.SOCK_FILE))
+    return null;
+  try {
+    const path = `/v1/memory?q=${encodeURIComponent(query)}${mesh ? `&mesh=${encodeURIComponent(mesh)}` : ""}`;
+    const res = await ipc({ path, timeoutMs: 5000 });
+    if (res.status !== 200)
+      return null;
+    return Array.isArray(res.body.matches) ? res.body.matches : [];
+  } catch (err) {
+    const msg = String(err);
+    if (/ENOENT|ECONNREFUSED|ipc_timeout/.test(msg))
+      return null;
+    return null;
+  }
 }
-async function runMeActivity(flags) {
-  return withRestKey({
-    meshSlug: resolveMeshForMint(flags.mesh),
-    purpose: "workspace-activity",
-    capabilities: ["read"]
-  }, async ({ secret }) => {
-    const params = new URLSearchParams;
-    if (flags.since)
-      params.set("since", flags.since);
-    const path = "/api/v1/me/activity" + (params.toString() ? `?${params.toString()}` : "");
-    const ws = await request({
-      path,
-      token: secret
+async function tryForgetViaDaemon(id, mesh) {
+  if (!existsSync7(DAEMON_PATHS.SOCK_FILE))
+    return false;
+  try {
+    const path = `/v1/memory/${encodeURIComponent(id)}${meshQuery(mesh)}`;
+    const res = await ipc({ method: "DELETE", path, timeoutMs: 3000 });
+    return res.status === 200 && res.body.ok === true;
+  } catch {
+    return false;
+  }
+}
+async function trySendViaDaemon(args) {
+  if (!existsSync7(DAEMON_PATHS.SOCK_FILE))
+    return null;
+  try {
+    const res = await ipc({
+      method: "POST",
+      path: "/v1/send",
+      timeoutMs: 3000,
+      body: {
+        to: args.to,
+        message: args.message,
+        priority: args.priority,
+        ...args.idempotencyKey ? { client_message_id: args.idempotencyKey } : {},
+        ...args.expectedMesh ? { mesh: args.expectedMesh } : {}
+      }
     });
-    if (flags.json) {
-      console.log(JSON.stringify(ws, null, 2));
-      return EXIT.SUCCESS;
-    }
-    render.section(`${clay("activity")} — ${ws.totals.events} ${dim(flags.since ? `since ${flags.since}` : "in the last 24h")}`);
-    if (ws.activity.length === 0) {
-      process.stdout.write(dim(`  quiet — no activity in window
-`));
-      return EXIT.SUCCESS;
+    if (res.status === 202 || res.status === 200) {
+      return {
+        ok: true,
+        messageId: res.body.broker_message_id ?? res.body.client_message_id ?? "",
+        duplicate: res.body.duplicate,
+        status: res.body.status
+      };
     }
-    const slugWidth = Math.max(...ws.activity.map((a) => a.meshSlug.length), 6);
-    for (const a of ws.activity) {
-      const slug = dim(a.meshSlug.padEnd(slugWidth));
-      const topic = cyan(`#${a.topicName}`);
-      const sender = a.senderName ?? "?";
-      const ago = formatRelativeTime(a.createdAt);
-      const snippet = a.snippet ?? (a.ciphertext ? dim("[encrypted]") : dim("[empty]"));
-      process.stdout.write(`  ${slug}  ${topic}  ${dim(sender + " ·")} ${dim(ago)}
-` + `     ${snippet.length > 200 ? snippet.slice(0, 200) + "…" : snippet}
-`);
+    return { ok: false, error: res.body.error ?? `daemon http ${res.status}` };
+  } catch (err) {
+    const msg = String(err);
+    if (/ENOENT|ECONNREFUSED|ipc_timeout/.test(msg))
+      return null;
+    return { ok: false, error: msg };
+  }
+}
+var init_daemon_route = __esm(() => {
+  init_client4();
+  init_paths2();
+});
+
+// src/commands/peers.ts
+var exports_peers = {};
+__export(exports_peers, {
+  runPeers: () => runPeers
+});
+function projectFields(record, fields) {
+  const out = {};
+  for (const f of fields) {
+    const sourceKey = FIELD_ALIAS[f] ?? f;
+    out[f] = record[sourceKey];
+  }
+  return out;
+}
+async function listPeersForMesh(slug) {
+  const config = readConfig();
+  const joined = config.meshes.find((m) => m.slug === slug);
+  const selfMemberPubkey = joined?.pubkey ?? null;
+  try {
+    const { tryListPeersViaDaemon: tryListPeersViaDaemon2 } = await Promise.resolve().then(() => (init_daemon_route(), exports_daemon_route));
+    const dr = await tryListPeersViaDaemon2();
+    if (dr !== null) {
+      return dr.map((p) => annotateSelf(p, selfMemberPubkey, null));
     }
-    return EXIT.SUCCESS;
+  } catch {}
+  const bridged = await tryBridge(slug, "peers");
+  if (bridged && bridged.ok) {
+    const peers = bridged.result;
+    return peers.map((p) => annotateSelf(p, selfMemberPubkey, null));
+  }
+  let result = [];
+  await withMesh({ meshSlug: slug }, async (client) => {
+    const all = await client.listPeers();
+    const selfSessionPubkey = client.getSessionPubkey();
+    result = all.map((p) => annotateSelf(p, selfMemberPubkey, selfSessionPubkey));
   });
+  return result;
 }
-async function runMeSearch(flags) {
-  if (!flags.query || flags.query.length < 2) {
-    process.stderr.write(`Usage: claudemesh me search <query> (min 2 chars)
+function annotateSelf(peer, selfMemberPubkey, selfSessionPubkey) {
+  const isSelf = !!(selfMemberPubkey && peer.memberPubkey && peer.memberPubkey === selfMemberPubkey);
+  const isThisSession = !!(isSelf && selfSessionPubkey && peer.pubkey === selfSessionPubkey);
+  return { ...peer, isSelf, isThisSession };
+}
+async function runPeers(flags) {
+  const config = readConfig();
+  const slugs = flags.mesh ? [flags.mesh] : config.meshes.map((m) => m.slug);
+  if (slugs.length === 0) {
+    render.err("No meshes joined.");
+    render.hint("claudemesh <invite-url>    # join + launch");
+    process.exit(1);
+  }
+  const fieldList = typeof flags.json === "string" && flags.json.length > 0 ? flags.json.split(",").map((s) => s.trim()).filter(Boolean) : null;
+  const wantsJson = flags.json !== undefined && flags.json !== false;
+  const allJson = [];
+  for (const slug of slugs) {
+    try {
+      const peers = await listPeersForMesh(slug);
+      if (wantsJson) {
+        const projected = fieldList ? peers.map((p) => projectFields(p, fieldList)) : peers;
+        allJson.push({ mesh: slug, peers: projected });
+        continue;
+      }
+      render.section(`peers on ${slug} (${peers.length})`);
+      if (peers.length === 0) {
+        render.info(dim("  (no peers connected)"));
+        continue;
+      }
+      for (const p of peers) {
+        const groups = p.groups.length ? " [" + p.groups.map((g) => `@${g.name}${g.role ? `:${g.role}` : ""}`).join(", ") + "]" : "";
+        const statusDot = p.status === "working" ? yellow("●") : green("●");
+        const name = bold(p.displayName);
+        const meta = [];
+        if (p.peerType)
+          meta.push(p.peerType);
+        if (p.channel)
+          meta.push(p.channel);
+        if (p.model)
+          meta.push(p.model);
+        const metaStr = meta.length ? dim(` (${meta.join(", ")})`) : "";
+        const summary = p.summary ? dim(`  — ${p.summary}`) : "";
+        const pubkeyTag = dim(` · ${p.pubkey.slice(0, 16)}…`);
+        const selfTag = p.isThisSession ? dim(" ") + yellow("(this session)") : p.isSelf ? dim(" ") + yellow("(your other session)") : "";
+        render.info(`${statusDot} ${name}${selfTag}${groups}${metaStr}${pubkeyTag}${summary}`);
+        if (p.cwd)
+          render.info(dim(`   cwd: ${p.cwd}`));
+      }
+    } catch (e) {
+      render.err(`${slug}: ${e instanceof Error ? e.message : String(e)}`);
+    }
+  }
+  if (wantsJson) {
+    process.stdout.write(JSON.stringify(slugs.length === 1 ? allJson[0]?.peers : allJson, null, 2) + `
 `);
-    return EXIT.INVALID_ARGS;
   }
-  return withRestKey({
-    meshSlug: resolveMeshForMint(flags.mesh),
-    purpose: "workspace-search",
-    capabilities: ["read"]
-  }, async ({ secret }) => {
-    const params = new URLSearchParams({ q: flags.query });
-    const ws = await request({
-      path: `/api/v1/me/search?${params.toString()}`,
-      token: secret
-    });
-    if (flags.json) {
-      console.log(JSON.stringify(ws, null, 2));
-      return EXIT.SUCCESS;
+}
+var FIELD_ALIAS;
+var init_peers = __esm(() => {
+  init_connect();
+  init_facade();
+  init_client3();
+  init_render();
+  init_styles();
+  FIELD_ALIAS = {
+    name: "displayName"
+  };
+});
+
+// src/commands/send.ts
+var exports_send = {};
+__export(exports_send, {
+  runSend: () => runSend
+});
+async function runSend(flags, to, message) {
+  if (!to || !message) {
+    render.err("Usage: claudemesh send <to> <message>");
+    process.exit(1);
+  }
+  const priority = flags.priority === "now" ? "now" : flags.priority === "low" ? "low" : "next";
+  const config = readConfig();
+  const meshSlug = flags.mesh ?? (config.meshes.length === 1 ? config.meshes[0].slug : null);
+  if (!flags.self && meshSlug) {
+    const joined = config.meshes.find((m) => m.slug === meshSlug);
+    if (joined && /^[0-9a-f]{64}$/i.test(to) && to.toLowerCase() === joined.pubkey.toLowerCase()) {
+      render.err(`Target "${to.slice(0, 16)}…" is your own member pubkey on mesh "${meshSlug}".`);
+      render.hint("Pass --self to message a sibling session of your own member, or pick a different peer's pubkey.");
+      process.exit(1);
     }
-    render.section(`${clay("search")} — "${flags.query}"  ${dim(`${ws.totals.topics} topic${ws.totals.topics === 1 ? "" : "s"}, ` + `${ws.totals.messages} message${ws.totals.messages === 1 ? "" : "s"}`)}`);
-    if (ws.topics.length === 0 && ws.messages.length === 0) {
-      process.stdout.write(dim(`  no matches
-`));
-      return EXIT.SUCCESS;
+  }
+  {
+    const dr = await trySendViaDaemon({ to, message, priority, expectedMesh: meshSlug ?? undefined });
+    if (dr !== null) {
+      if (dr.ok) {
+        if (flags.json)
+          console.log(JSON.stringify({ ok: true, messageId: dr.messageId, target: to, via: "daemon", duplicate: !!dr.duplicate }));
+        else
+          render.ok(`sent to ${to} (daemon)`, dr.messageId ? dim(dr.messageId.slice(0, 8)) : undefined);
+        return;
+      }
+      if (flags.json)
+        console.log(JSON.stringify({ ok: false, error: dr.error, via: "daemon" }));
+      else
+        render.err(`send failed (daemon): ${dr.error}`);
+      process.exit(1);
     }
-    if (ws.topics.length > 0) {
-      process.stdout.write(dim(`
-  topics
-`));
-      const slugWidth = Math.max(...ws.topics.map((t) => t.meshSlug.length), 6);
-      for (const t of ws.topics) {
-        const slug = dim(t.meshSlug.padEnd(slugWidth));
-        const name = cyan(`#${t.name}`);
-        const desc = t.description ? dim(` — ${t.description}`) : "";
-        process.stdout.write(`  ${slug}  ${name}${desc}
-`);
+  }
+  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);
     }
-    if (ws.messages.length > 0) {
-      process.stdout.write(dim(`
-  messages
-`));
-      const slugWidth = Math.max(...ws.messages.map((m) => m.meshSlug.length), 6);
-      for (const m of ws.messages) {
-        const slug = dim(m.meshSlug.padEnd(slugWidth));
-        const topic = cyan(`#${m.topicName}`);
-        const sender = m.senderName;
-        const ago = formatRelativeTime(m.createdAt);
-        const snippet = m.snippet ?? (m.bodyVersion === 2 ? dim("[encrypted — open the topic to decrypt]") : dim("[empty]"));
-        const highlighted = m.snippet ? highlightMatch(snippet, flags.query) : snippet;
-        process.stdout.write(`  ${slug}  ${topic}  ${dim(sender + " ·")} ${dim(ago)}
-` + `     ${highlighted}
-`);
+  }
+  await withMesh({ meshSlug: flags.mesh ?? null }, async (client) => {
+    let targetSpec = to;
+    if (to.startsWith("#") && !/^#[0-9a-z_-]{20,}$/i.test(to)) {
+      const name = to.slice(1);
+      const topics = await client.topicList();
+      const match = topics.find((t) => t.name === name);
+      if (!match) {
+        const names = topics.map((t) => "#" + t.name).join(", ");
+        render.err(`Topic "${to}" not found.`, `topics: ${names || "(none)"}`);
+        process.exit(1);
       }
+      targetSpec = "#" + match.id;
+    } else if (!to.startsWith("@") && !to.startsWith("#") && to !== "*" && !/^[0-9a-f]{64}$/i.test(to)) {
+      const peers = await client.listPeers();
+      const match = peers.find((p) => p.displayName.toLowerCase() === to.toLowerCase());
+      if (!match) {
+        const names = peers.map((p) => p.displayName).join(", ");
+        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) {
+      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 {
+      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);
     }
-    return EXIT.SUCCESS;
   });
 }
-function highlightMatch(text, query) {
-  if (!query)
-    return text;
-  const idx = text.toLowerCase().indexOf(query.toLowerCase());
-  if (idx === -1)
-    return text;
-  const before = text.slice(0, idx);
-  const match = text.slice(idx, idx + query.length);
-  const after = text.slice(idx + query.length);
-  return `${before}${yellow(match)}${after}`;
+var init_send = __esm(() => {
+  init_connect();
+  init_facade();
+  init_client3();
+  init_daemon_route();
+  init_render();
+  init_styles();
+});
+
+// src/commands/inbox.ts
+var exports_inbox = {};
+__export(exports_inbox, {
+  runInbox: () => runInbox
+});
+function formatMessage(msg) {
+  const text = msg.plaintext ?? `[encrypted: ${msg.ciphertext.slice(0, 32)}…]`;
+  const from = msg.senderPubkey.slice(0, 8);
+  const time = new Date(msg.createdAt).toLocaleTimeString();
+  const kindTag = msg.kind === "direct" ? "→ direct" : msg.kind;
+  return `  ${bold(from)} ${dim(`[${kindTag}] ${time}`)}
+  ${text}`;
 }
-async function runMeTasks(flags) {
-  return withRestKey({
-    meshSlug: resolveMeshForMint(flags.mesh),
-    purpose: "workspace-tasks",
-    capabilities: ["read"]
-  }, async ({ secret }) => {
-    const params = new URLSearchParams;
-    if (flags.status)
-      params.set("status", flags.status);
-    const path = "/api/v1/me/tasks" + (params.toString() ? `?${params.toString()}` : "");
-    const ws = await request({
-      path,
-      token: secret
-    });
+async function runInbox(flags) {
+  const waitMs = (flags.wait ?? 1) * 1000;
+  await withMesh({ meshSlug: flags.mesh ?? null }, async (client, mesh) => {
+    await new Promise((resolve) => setTimeout(resolve, waitMs));
+    const messages = client.drainPushBuffer();
     if (flags.json) {
-      console.log(JSON.stringify(ws, null, 2));
-      return EXIT.SUCCESS;
+      process.stdout.write(JSON.stringify(messages, null, 2) + `
+`);
+      return;
     }
-    render.section(`${clay("tasks")} — ${dim(`${ws.totals.open} open · ${ws.totals.claimed} in-flight · ${ws.totals.completed} done`)}`);
-    if (ws.tasks.length === 0) {
-      process.stdout.write(dim(`  no tasks in window
-`));
-      return EXIT.SUCCESS;
+    if (messages.length === 0) {
+      render.info(dim(`No messages on mesh "${mesh.slug}".`));
+      return;
     }
-    const slugWidth = Math.max(...ws.tasks.map((t) => t.meshSlug.length), 6);
-    for (const t of ws.tasks) {
-      const slug = dim(t.meshSlug.padEnd(slugWidth));
-      const status = t.status === "open" ? yellow("open    ") : t.status === "claimed" ? cyan("working ") : green("done    ");
-      const prio = t.priority === "urgent" ? yellow("!") : t.priority === "low" ? dim("·") : " ";
-      const claimer = t.claimedByName ? dim(` ← ${t.claimedByName}`) : "";
-      process.stdout.write(`  ${slug} ${prio} ${status}  ${t.title}${claimer}
+    render.section(`inbox — ${mesh.slug} (${messages.length} message${messages.length === 1 ? "" : "s"})`);
+    for (const msg of messages) {
+      process.stdout.write(formatMessage(msg) + `
+
 `);
     }
-    return EXIT.SUCCESS;
   });
 }
-async function runMeState(flags) {
-  return withRestKey({
-    meshSlug: resolveMeshForMint(flags.mesh),
-    purpose: "workspace-state",
-    capabilities: ["read"]
-  }, async ({ secret }) => {
-    const params = new URLSearchParams;
-    if (flags.key)
-      params.set("key", flags.key);
-    const path = "/api/v1/me/state" + (params.toString() ? `?${params.toString()}` : "");
-    const ws = await request({
-      path,
-      token: secret
-    });
+var init_inbox = __esm(() => {
+  init_connect();
+  init_render();
+  init_styles();
+});
+
+// src/commands/state.ts
+var exports_state = {};
+__export(exports_state, {
+  runStateSet: () => runStateSet,
+  runStateList: () => runStateList,
+  runStateGet: () => runStateGet
+});
+async function runStateGet(flags, key) {
+  const daemonEntry = await tryGetStateViaDaemon(key, flags.mesh);
+  if (daemonEntry !== null) {
+    if (!daemonEntry) {
+      render.info(dim("(not set)"));
+      return;
+    }
     if (flags.json) {
-      console.log(JSON.stringify(ws, null, 2));
-      return EXIT.SUCCESS;
+      console.log(JSON.stringify(daemonEntry, null, 2));
+      return;
     }
-    render.section(`${clay("state")} — ${ws.totals.entries} entr${ws.totals.entries === 1 ? "y" : "ies"} ${dim(`across ${ws.totals.meshes} mesh${ws.totals.meshes === 1 ? "" : "es"}`)}`);
-    if (ws.entries.length === 0) {
-      process.stdout.write(dim(`  no state entries
-`));
-      return EXIT.SUCCESS;
+    const val = typeof daemonEntry.value === "string" ? daemonEntry.value : JSON.stringify(daemonEntry.value);
+    render.info(val);
+    render.info(dim(`  set by ${daemonEntry.updatedBy} at ${new Date(daemonEntry.updatedAt).toLocaleString()}`));
+    return;
+  }
+  await withMesh({ meshSlug: flags.mesh ?? null }, async (client) => {
+    const entry = await client.getState(key);
+    if (!entry) {
+      render.info(dim("(not set)"));
+      return;
     }
-    const slugWidth = Math.max(...ws.entries.map((e) => e.meshSlug.length), 6);
-    const keyWidth = Math.max(...ws.entries.map((e) => e.key.length), 8);
-    for (const e of ws.entries) {
-      const slug = dim(e.meshSlug.padEnd(slugWidth));
-      const key = cyan(e.key.padEnd(keyWidth));
-      const valueStr = typeof e.value === "string" ? e.value : JSON.stringify(e.value);
-      const trimmed = valueStr.length > 80 ? valueStr.slice(0, 80) + "…" : valueStr;
-      const ago = dim(formatRelativeTime(e.updatedAt));
-      process.stdout.write(`  ${slug}  ${key}  ${trimmed}  ${ago}
-`);
+    if (flags.json) {
+      console.log(JSON.stringify(entry, null, 2));
+      return;
     }
-    return EXIT.SUCCESS;
+    const val = typeof entry.value === "string" ? entry.value : JSON.stringify(entry.value);
+    render.info(val);
+    render.info(dim(`  set by ${entry.updatedBy} at ${new Date(entry.updatedAt).toLocaleString()}`));
   });
 }
-async function runMeMemory(flags) {
-  return withRestKey({
-    meshSlug: resolveMeshForMint(flags.mesh),
-    purpose: "workspace-memory",
-    capabilities: ["read"]
-  }, async ({ secret }) => {
-    const params = new URLSearchParams;
-    if (flags.query)
-      params.set("q", flags.query);
-    const path = "/api/v1/me/memory" + (params.toString() ? `?${params.toString()}` : "");
-    const ws = await request({
-      path,
-      token: secret
-    });
+async function runStateSet(flags, key, value) {
+  let parsed;
+  try {
+    parsed = JSON.parse(value);
+  } catch {
+    parsed = value;
+  }
+  const daemonOk = await trySetStateViaDaemon(key, parsed, flags.mesh);
+  if (daemonOk) {
+    render.ok(`${bold(key)} = ${JSON.stringify(parsed)}`);
+    return;
+  }
+  await withMesh({ meshSlug: flags.mesh ?? null }, async (client) => {
+    await client.setState(key, parsed);
+    render.ok(`${bold(key)} = ${JSON.stringify(parsed)}`);
+  });
+}
+async function runStateList(flags) {
+  const daemonRows = await tryListStateViaDaemon(flags.mesh);
+  if (daemonRows !== null) {
     if (flags.json) {
-      console.log(JSON.stringify(ws, null, 2));
-      return EXIT.SUCCESS;
+      console.log(JSON.stringify(daemonRows, null, 2));
+      return;
     }
-    const headerLabel = flags.query ? `recall — "${flags.query}"` : "recall — last 30 days";
-    render.section(`${clay(headerLabel)}  ${dim(`${ws.totals.entries} match${ws.totals.entries === 1 ? "" : "es"}`)}`);
-    if (ws.memories.length === 0) {
-      process.stdout.write(dim(`  no memories
-`));
-      return EXIT.SUCCESS;
+    if (daemonRows.length === 0) {
+      render.info(dim("(no state)"));
+      return;
     }
-    const slugWidth = Math.max(...ws.memories.map((m) => m.meshSlug.length), 6);
-    for (const m of ws.memories) {
-      const slug = dim(m.meshSlug.padEnd(slugWidth));
-      const ago = dim(formatRelativeTime(m.rememberedAt));
-      const tags = m.tags.length > 0 ? "  " + dim("[" + m.tags.join(", ") + "]") : "";
-      const content = m.content.length > 240 ? m.content.slice(0, 240) + "…" : m.content;
-      process.stdout.write(`  ${slug}  ${ago}${tags}
-     ${content}
+    render.section(`state (${daemonRows.length})`);
+    for (const e of daemonRows) {
+      const val = typeof e.value === "string" ? e.value : JSON.stringify(e.value);
+      process.stdout.write(`  ${bold(e.key)}: ${val}
+`);
+      process.stdout.write(`    ${dim(e.updatedBy + "  ·  " + new Date(e.updatedAt).toLocaleString())}
 `);
     }
-    return EXIT.SUCCESS;
-  });
-}
-function formatRelativeTime(iso) {
-  const then = new Date(iso).getTime();
-  const now = Date.now();
-  const sec = Math.max(0, Math.floor((now - then) / 1000));
-  if (sec < 60)
-    return `${sec}s ago`;
-  if (sec < 3600)
-    return `${Math.floor(sec / 60)}m ago`;
-  if (sec < 86400)
-    return `${Math.floor(sec / 3600)}h ago`;
-  if (sec < 86400 * 30)
-    return `${Math.floor(sec / 86400)}d ago`;
-  if (sec < 86400 * 365)
-    return `${Math.floor(sec / (86400 * 30))}mo ago`;
-  return `${Math.floor(sec / (86400 * 365))}y ago`;
-}
-var init_me = __esm(() => {
-  init_with_rest_key();
-  init_client();
-  init_facade();
-  init_render();
-  init_styles();
-  init_exit_codes();
-});
-
-// src/commands/info.ts
-var exports_info = {};
-__export(exports_info, {
-  runInfo: () => runInfo
-});
-async function runInfo(flags) {
-  const config = readConfig();
+    return;
+  }
   await withMesh({ meshSlug: flags.mesh ?? null }, async (client, mesh) => {
-    const [brokerInfo, peers, state] = await Promise.all([
-      client.meshInfo(),
-      client.listPeers(),
-      client.listState()
-    ]);
-    const output = {
-      slug: mesh.slug,
-      meshId: mesh.meshId,
-      memberId: mesh.memberId,
-      brokerUrl: mesh.brokerUrl,
-      displayName: config.displayName ?? null,
-      peerCount: peers.length,
-      stateCount: state.length,
-      ...brokerInfo ?? {}
-    };
+    const entries = await client.listState();
     if (flags.json) {
-      process.stdout.write(JSON.stringify(output, null, 2) + `
-`);
+      console.log(JSON.stringify(entries, null, 2));
       return;
     }
-    render.section(`${mesh.slug} · ${mesh.brokerUrl}`);
-    render.kv([
-      ["mesh", mesh.meshId],
-      ["member", mesh.memberId],
-      ["peers", `${peers.length} connected`],
-      ["state", `${state.length} keys`]
-    ]);
-    if (brokerInfo && typeof brokerInfo === "object") {
-      const extras = [];
-      for (const [k, v] of Object.entries(brokerInfo)) {
-        if (["slug", "meshId", "brokerUrl"].includes(k))
-          continue;
-        extras.push([k, JSON.stringify(v)]);
-      }
-      if (extras.length)
-        render.kv(extras);
+    if (entries.length === 0) {
+      render.info(dim(`No state on mesh "${mesh.slug}".`));
+      return;
+    }
+    render.section(`state (${entries.length})`);
+    for (const e of entries) {
+      const val = typeof e.value === "string" ? e.value : JSON.stringify(e.value);
+      process.stdout.write(`  ${bold(e.key)}: ${val}
+`);
+      process.stdout.write(`    ${dim(e.updatedBy + "  ·  " + new Date(e.updatedAt).toLocaleString())}
+`);
     }
   });
 }
-var init_info2 = __esm(() => {
+var init_state = __esm(() => {
   init_connect();
-  init_facade();
+  init_daemon_route();
   init_render();
+  init_styles();
 });
 
 // src/commands/remember.ts
@@ -7757,6 +7900,15 @@ async function remember(content, opts = {}) {
     return EXIT.INVALID_ARGS;
   }
   const tags = opts.tags?.split(",").map((t) => t.trim()).filter(Boolean);
+  const daemonRes = await tryRememberViaDaemon(content, tags, opts.mesh);
+  if (daemonRes) {
+    if (opts.json) {
+      console.log(JSON.stringify({ id: daemonRes.id, content, tags, mesh: daemonRes.mesh }));
+      return EXIT.SUCCESS;
+    }
+    render.ok("remembered", dim(daemonRes.id.slice(0, 8)));
+    return EXIT.SUCCESS;
+  }
   return await withMesh({ meshSlug: opts.mesh ?? null }, async (client) => {
     const id = await client.remember(content, tags);
     if (opts.json) {
@@ -7773,6 +7925,7 @@ async function remember(content, opts = {}) {
 }
 var init_remember = __esm(() => {
   init_connect();
+  init_daemon_route();
   init_render();
   init_styles();
   init_exit_codes();
@@ -7788,6 +7941,29 @@ async function recall(query, opts = {}) {
     render.err("Usage: claudemesh recall <query>");
     return EXIT.INVALID_ARGS;
   }
+  const daemonMatches = await tryRecallViaDaemon(query, opts.mesh);
+  if (daemonMatches !== null) {
+    if (opts.json) {
+      console.log(JSON.stringify(daemonMatches, null, 2));
+      return EXIT.SUCCESS;
+    }
+    if (daemonMatches.length === 0) {
+      render.info(dim("no memories found."));
+      return EXIT.SUCCESS;
+    }
+    render.section(`memories (${daemonMatches.length})`);
+    for (const m of daemonMatches) {
+      const tags = m.tags.length ? dim(` [${m.tags.map((t) => clay(t)).join(dim(", "))}]`) : "";
+      process.stdout.write(`  ${bold(m.id.slice(0, 8))}${tags}
+`);
+      process.stdout.write(`    ${m.content}
+`);
+      process.stdout.write(`    ${dim(m.rememberedBy + "  ·  " + new Date(m.rememberedAt).toLocaleString())}
+
+`);
+    }
+    return EXIT.SUCCESS;
+  }
   return await withMesh({ meshSlug: opts.mesh ?? null }, async (client) => {
     const memories = await client.recall(query);
     if (opts.json) {
@@ -7814,6 +7990,7 @@ async function recall(query, opts = {}) {
 }
 var init_recall = __esm(() => {
   init_connect();
+  init_daemon_route();
   init_render();
   init_styles();
   init_exit_codes();
@@ -8026,6 +8203,14 @@ async function runForget(id, opts) {
     render.err("Usage: claudemesh forget <memory-id>");
     return EXIT.INVALID_ARGS;
   }
+  if (await tryForgetViaDaemon(id, opts.mesh)) {
+    if (opts.json) {
+      console.log(JSON.stringify({ id, forgotten: true }));
+      return EXIT.SUCCESS;
+    }
+    render.ok(`forgot ${dim(id.slice(0, 8))}`);
+    return EXIT.SUCCESS;
+  }
   await withMesh({ meshSlug: opts.mesh ?? null }, async (client) => {
     await client.forget(id);
   });
@@ -8203,6 +8388,7 @@ var init_broker_actions = __esm(() => {
   init_connect();
   init_facade();
   init_client3();
+  init_daemon_route();
   init_render();
   init_styles();
   init_exit_codes();
@@ -8908,10 +9094,9 @@ function startIpcServer(opts) {
     outboxDb: opts.outboxDb,
     inboxDb: opts.inboxDb,
     bus: opts.bus,
-    broker: opts.broker,
-    onPendingInserted: opts.onPendingInserted,
-    meshSecretKey: opts.meshSecretKey,
-    meshSlug: opts.meshSlug
+    brokers: opts.brokers,
+    meshConfigs: opts.meshConfigs,
+    onPendingInserted: opts.onPendingInserted
   });
   if (existsSync9(DAEMON_PATHS.SOCK_FILE)) {
     try {
@@ -9003,7 +9188,7 @@ function makeHandler(opts) {
       respond(res, 200, {
         daemon_version: VERSION,
         ipc_api: "v1",
-        ipc_features: ["version", "health", "send", "inbox", "events", "peers", "profile", "skills"],
+        ipc_features: ["version", "health", "send", "inbox", "events", "peers", "profile", "skills", "state", "memory"],
         schema_version: 1
       });
       return;
@@ -9021,34 +9206,209 @@ function makeHandler(opts) {
       return;
     }
     if (req.method === "GET" && url.pathname === "/v1/peers") {
-      if (!opts.broker) {
+      if (!opts.brokers || opts.brokers.size === 0) {
+        respond(res, 503, { error: "broker not initialised" });
+        return;
+      }
+      const filterMesh = url.searchParams.get("mesh") ?? undefined;
+      try {
+        const all = [];
+        for (const [slug, b] of opts.brokers.entries()) {
+          if (filterMesh && filterMesh !== slug)
+            continue;
+          try {
+            const peers = await b.listPeers();
+            for (const p of peers)
+              all.push({ ...p, mesh: slug });
+          } catch (e) {
+            opts.log("warn", "ipc_peers_broker_failed", { mesh: slug, err: String(e) });
+          }
+        }
+        respond(res, 200, { peers: all });
+      } catch (e) {
+        respond(res, 502, { error: "broker_unreachable", detail: String(e) });
+      }
+      return;
+    }
+    if (req.method === "GET" && url.pathname === "/v1/state") {
+      if (!opts.brokers || opts.brokers.size === 0) {
+        respond(res, 503, { error: "broker not initialised" });
+        return;
+      }
+      const filterMesh = url.searchParams.get("mesh") ?? undefined;
+      const key = url.searchParams.get("key");
+      try {
+        if (key) {
+          for (const [slug, b] of opts.brokers.entries()) {
+            if (filterMesh && filterMesh !== slug)
+              continue;
+            const row = await b.getState(key).catch(() => null);
+            if (row) {
+              respond(res, 200, { state: { ...row, mesh: slug } });
+              return;
+            }
+          }
+          respond(res, 404, { error: "state_not_found", key });
+          return;
+        }
+        const all = [];
+        for (const [slug, b] of opts.brokers.entries()) {
+          if (filterMesh && filterMesh !== slug)
+            continue;
+          const rows = await b.listState().catch(() => []);
+          for (const r of rows)
+            all.push({ ...r, mesh: slug });
+        }
+        respond(res, 200, { entries: all });
+      } catch (e) {
+        respond(res, 502, { error: "broker_unreachable", detail: String(e) });
+      }
+      return;
+    }
+    if (req.method === "POST" && url.pathname === "/v1/state") {
+      if (!opts.brokers || opts.brokers.size === 0) {
+        respond(res, 503, { error: "broker not initialised" });
+        return;
+      }
+      try {
+        const body = await readJsonBody(req, 256 * 1024);
+        if (!body || typeof body.key !== "string") {
+          respond(res, 400, { error: "missing 'key' (string)" });
+          return;
+        }
+        const requested = (typeof body.mesh === "string" ? body.mesh : null) || null;
+        let chosen = requested;
+        if (!chosen && opts.brokers.size === 1)
+          chosen = opts.brokers.keys().next().value;
+        if (!chosen) {
+          respond(res, 400, { error: "mesh_required", attached: [...opts.brokers.keys()] });
+          return;
+        }
+        const broker = opts.brokers.get(chosen);
+        if (!broker) {
+          respond(res, 404, { error: "mesh_not_attached", mesh: chosen });
+          return;
+        }
+        broker.setState(body.key, body.value);
+        respond(res, 200, { ok: true, key: body.key, mesh: chosen });
+      } catch (e) {
+        respond(res, 400, { error: String(e) });
+      }
+      return;
+    }
+    if (req.method === "GET" && url.pathname === "/v1/memory") {
+      if (!opts.brokers || opts.brokers.size === 0) {
         respond(res, 503, { error: "broker not initialised" });
         return;
       }
+      const query = url.searchParams.get("q") ?? "";
+      const filterMesh = url.searchParams.get("mesh") ?? undefined;
       try {
-        const peers = await opts.broker.listPeers();
-        respond(res, 200, { peers });
+        const all = [];
+        for (const [slug, b] of opts.brokers.entries()) {
+          if (filterMesh && filterMesh !== slug)
+            continue;
+          const rows = await b.recall(query).catch(() => []);
+          for (const r of rows)
+            all.push({ ...r, mesh: slug });
+        }
+        respond(res, 200, { matches: all });
       } catch (e) {
         respond(res, 502, { error: "broker_unreachable", detail: String(e) });
       }
       return;
     }
+    if (req.method === "POST" && url.pathname === "/v1/memory") {
+      if (!opts.brokers || opts.brokers.size === 0) {
+        respond(res, 503, { error: "broker not initialised" });
+        return;
+      }
+      try {
+        const body = await readJsonBody(req, 256 * 1024);
+        if (!body || typeof body.content !== "string") {
+          respond(res, 400, { error: "missing 'content' (string)" });
+          return;
+        }
+        const requested = (typeof body.mesh === "string" ? body.mesh : null) || null;
+        let chosen = requested;
+        if (!chosen && opts.brokers.size === 1)
+          chosen = opts.brokers.keys().next().value;
+        if (!chosen) {
+          respond(res, 400, { error: "mesh_required", attached: [...opts.brokers.keys()] });
+          return;
+        }
+        const broker = opts.brokers.get(chosen);
+        if (!broker) {
+          respond(res, 404, { error: "mesh_not_attached", mesh: chosen });
+          return;
+        }
+        const tags = Array.isArray(body.tags) ? body.tags.filter((t) => typeof t === "string") : undefined;
+        const id = await broker.remember(body.content, tags);
+        if (!id) {
+          respond(res, 502, { error: "remember_timeout" });
+          return;
+        }
+        respond(res, 200, { id, mesh: chosen });
+      } catch (e) {
+        respond(res, 400, { error: String(e) });
+      }
+      return;
+    }
+    if (req.method === "DELETE" && url.pathname.startsWith("/v1/memory/")) {
+      if (!opts.brokers || opts.brokers.size === 0) {
+        respond(res, 503, { error: "broker not initialised" });
+        return;
+      }
+      const id = decodeURIComponent(url.pathname.slice("/v1/memory/".length));
+      if (!id) {
+        respond(res, 400, { error: "missing memory id" });
+        return;
+      }
+      const requested = url.searchParams.get("mesh");
+      let chosen = requested;
+      if (!chosen && opts.brokers.size === 1)
+        chosen = opts.brokers.keys().next().value;
+      if (!chosen) {
+        respond(res, 400, { error: "mesh_required", attached: [...opts.brokers.keys()] });
+        return;
+      }
+      const broker = opts.brokers.get(chosen);
+      if (!broker) {
+        respond(res, 404, { error: "mesh_not_attached", mesh: chosen });
+        return;
+      }
+      broker.forget(id);
+      respond(res, 200, { ok: true, id, mesh: chosen });
+      return;
+    }
     if (req.method === "GET" && url.pathname === "/v1/skills") {
-      if (!opts.broker) {
+      if (!opts.brokers || opts.brokers.size === 0) {
         respond(res, 503, { error: "broker not initialised" });
         return;
       }
       const query = url.searchParams.get("query") ?? undefined;
+      const filterMesh = url.searchParams.get("mesh") ?? undefined;
       try {
-        const skills = await opts.broker.listSkills(query);
-        respond(res, 200, { skills });
+        const all = [];
+        for (const [slug, b] of opts.brokers.entries()) {
+          if (filterMesh && filterMesh !== slug)
+            continue;
+          try {
+            const skills = await b.listSkills(query);
+            for (const s of skills)
+              all.push({ ...s, mesh: slug });
+          } catch (e) {
+            opts.log("warn", "ipc_skills_broker_failed", { mesh: slug, err: String(e) });
+          }
+        }
+        respond(res, 200, { skills: all });
       } catch (e) {
         respond(res, 502, { error: "broker_unreachable", detail: String(e) });
       }
       return;
     }
     if (req.method === "GET" && url.pathname.startsWith("/v1/skills/")) {
-      if (!opts.broker) {
+      if (!opts.brokers || opts.brokers.size === 0) {
         respond(res, 503, { error: "broker not initialised" });
         return;
       }
@@ -9057,20 +9417,25 @@ function makeHandler(opts) {
         respond(res, 400, { error: "missing skill name" });
         return;
       }
+      const filterMesh = url.searchParams.get("mesh") ?? undefined;
       try {
-        const skill = await opts.broker.getSkill(name);
-        if (!skill) {
-          respond(res, 404, { error: "skill_not_found", name });
-          return;
+        for (const [slug, b] of opts.brokers.entries()) {
+          if (filterMesh && filterMesh !== slug)
+            continue;
+          const skill = await b.getSkill(name).catch(() => null);
+          if (skill) {
+            respond(res, 200, { skill: { ...skill, mesh: slug } });
+            return;
+          }
         }
-        respond(res, 200, { skill });
+        respond(res, 404, { error: "skill_not_found", name });
       } catch (e) {
         respond(res, 502, { error: "broker_unreachable", detail: String(e) });
       }
       return;
     }
     if (req.method === "POST" && url.pathname === "/v1/profile") {
-      if (!opts.broker) {
+      if (!opts.brokers || opts.brokers.size === 0) {
         respond(res, 503, { error: "broker not initialised" });
         return;
       }
@@ -9080,26 +9445,34 @@ function makeHandler(opts) {
           respond(res, 400, { error: "expected JSON object" });
           return;
         }
+        const requested = (typeof body.mesh === "string" ? body.mesh : url.searchParams.get("mesh")) || null;
+        const targets = requested ? [opts.brokers.get(requested)].filter(Boolean) : [...opts.brokers.values()];
+        if (targets.length === 0) {
+          respond(res, 404, { error: "mesh_not_attached", mesh: requested });
+          return;
+        }
         const updates = {};
-        if (typeof body.summary === "string")
-          opts.broker.setSummary(body.summary);
-        if (body.status === "idle" || body.status === "working" || body.status === "dnd")
-          opts.broker.setStatus(body.status);
-        if (typeof body.visible === "boolean")
-          opts.broker.setVisible(body.visible);
-        const profile = {};
-        if (typeof body.avatar === "string")
-          profile.avatar = body.avatar;
-        if (typeof body.title === "string")
-          profile.title = body.title;
-        if (typeof body.bio === "string")
-          profile.bio = body.bio;
-        if (Array.isArray(body.capabilities))
-          profile.capabilities = body.capabilities.filter((c) => typeof c === "string");
-        if (Object.keys(profile).length > 0)
-          opts.broker.setProfile(profile);
+        for (const b of targets) {
+          if (typeof body.summary === "string")
+            b.setSummary(body.summary);
+          if (body.status === "idle" || body.status === "working" || body.status === "dnd")
+            b.setStatus(body.status);
+          if (typeof body.visible === "boolean")
+            b.setVisible(body.visible);
+          const profile = {};
+          if (typeof body.avatar === "string")
+            profile.avatar = body.avatar;
+          if (typeof body.title === "string")
+            profile.title = body.title;
+          if (typeof body.bio === "string")
+            profile.bio = body.bio;
+          if (Array.isArray(body.capabilities))
+            profile.capabilities = body.capabilities.filter((c) => typeof c === "string");
+          if (Object.keys(profile).length > 0)
+            b.setProfile(profile);
+        }
         Object.assign(updates, body);
-        respond(res, 200, { ok: true, applied: Object.keys(updates) });
+        respond(res, 200, { ok: true, applied: Object.keys(updates), meshes: requested ? [requested] : [...opts.brokers.keys()] });
       } catch (e) {
         respond(res, 400, { error: String(e) });
       }
@@ -9217,9 +9590,27 @@ function makeHandler(opts) {
           respond(res, 400, { error: parsed.error });
           return;
         }
-        if (opts.broker && opts.meshSecretKey) {
+        if (opts.brokers && opts.brokers.size > 0 && opts.meshConfigs) {
+          let chosenSlug = parsed.req.mesh ?? null;
+          if (!chosenSlug && opts.brokers.size === 1) {
+            chosenSlug = opts.brokers.keys().next().value;
+          }
+          if (!chosenSlug) {
+            respond(res, 400, {
+              error: "mesh_required",
+              detail: `daemon attached to ${opts.brokers.size} meshes; pass 'mesh' in request body`,
+              attached: [...opts.brokers.keys()]
+            });
+            return;
+          }
+          const broker = opts.brokers.get(chosenSlug);
+          const meshCfg = opts.meshConfigs.get(chosenSlug);
+          if (!broker || !meshCfg) {
+            respond(res, 404, { error: "mesh_not_attached", mesh: chosenSlug });
+            return;
+          }
           try {
-            const routed = await resolveAndEncrypt(parsed.req, opts.broker, opts.meshSecretKey, opts.meshSlug ?? null);
+            const routed = await resolveAndEncrypt(parsed.req, broker, meshCfg.secretKey, chosenSlug);
             parsed.req.target_spec = routed.target_spec;
             parsed.req.ciphertext = routed.ciphertext;
             parsed.req.nonce = routed.nonce;
@@ -9321,6 +9712,7 @@ function parseSendRequest(body, idempotencyHeader) {
   const headerId = Array.isArray(idempotencyHeader) ? idempotencyHeader[0] : idempotencyHeader;
   const client_message_id = typeof b.client_message_id === "string" && b.client_message_id.trim() ? b.client_message_id.trim() : typeof headerId === "string" && headerId.trim() ? headerId.trim() : undefined;
   const reply_to_id = typeof b.reply_to_id === "string" ? b.reply_to_id : undefined;
+  const mesh = typeof b.mesh === "string" ? b.mesh.trim() : undefined;
   return {
     req: {
       to,
@@ -9330,7 +9722,8 @@ function parseSendRequest(body, idempotencyHeader) {
       reply_to_id,
       client_message_id,
       destination_kind,
-      destination_ref
+      destination_ref,
+      mesh
     }
   };
 }
@@ -9405,6 +9798,10 @@ class DaemonBrokerClient {
   peerListResolvers = new Map;
   skillListResolvers = new Map;
   skillDataResolvers = new Map;
+  stateGetResolvers = new Map;
+  stateListResolvers = new Map;
+  memoryStoreResolvers = new Map;
+  memoryRecallResolvers = new Map;
   sessionPubkey = null;
   sessionSecretKey = null;
   opens = [];
@@ -9545,6 +9942,46 @@ class DaemonBrokerClient {
           }
           return;
         }
+        if (msg.type === "state_value" || msg.type === "state_data") {
+          const reqId = String(msg._reqId ?? "");
+          const pending = this.stateGetResolvers.get(reqId);
+          if (pending) {
+            this.stateGetResolvers.delete(reqId);
+            clearTimeout(pending.timer);
+            pending.resolve(msg.state ?? msg.row ?? null);
+          }
+          return;
+        }
+        if (msg.type === "state_list") {
+          const reqId = String(msg._reqId ?? "");
+          const pending = this.stateListResolvers.get(reqId);
+          if (pending) {
+            this.stateListResolvers.delete(reqId);
+            clearTimeout(pending.timer);
+            pending.resolve(Array.isArray(msg.entries) ? msg.entries : []);
+          }
+          return;
+        }
+        if (msg.type === "memory_stored") {
+          const reqId = String(msg._reqId ?? "");
+          const pending = this.memoryStoreResolvers.get(reqId);
+          if (pending) {
+            this.memoryStoreResolvers.delete(reqId);
+            clearTimeout(pending.timer);
+            pending.resolve(typeof msg.memoryId === "string" ? msg.memoryId : null);
+          }
+          return;
+        }
+        if (msg.type === "memory_recall_result") {
+          const reqId = String(msg._reqId ?? "");
+          const pending = this.memoryRecallResolvers.get(reqId);
+          if (pending) {
+            this.memoryRecallResolvers.delete(reqId);
+            clearTimeout(pending.timer);
+            pending.resolve(Array.isArray(msg.matches) ? msg.matches : []);
+          }
+          return;
+        }
         if (msg.type === "push" || msg.type === "inbound") {
           this.opts.onPush?.(msg);
           return;
@@ -9665,6 +10102,96 @@ class DaemonBrokerClient {
       }
     });
   }
+  async getState(key, timeoutMs = 5000) {
+    if (this._status !== "open" || !this.ws)
+      return null;
+    return new Promise((resolve) => {
+      const reqId = `sg-${++this.reqCounter}`;
+      const timer = setTimeout(() => {
+        if (this.stateGetResolvers.delete(reqId))
+          resolve(null);
+      }, timeoutMs);
+      this.stateGetResolvers.set(reqId, { resolve, timer });
+      try {
+        this.ws.send(JSON.stringify({ type: "get_state", key, _reqId: reqId }));
+      } catch {
+        this.stateGetResolvers.delete(reqId);
+        clearTimeout(timer);
+        resolve(null);
+      }
+    });
+  }
+  async listState(timeoutMs = 5000) {
+    if (this._status !== "open" || !this.ws)
+      return [];
+    return new Promise((resolve) => {
+      const reqId = `sl-${++this.reqCounter}`;
+      const timer = setTimeout(() => {
+        if (this.stateListResolvers.delete(reqId))
+          resolve([]);
+      }, timeoutMs);
+      this.stateListResolvers.set(reqId, { resolve, timer });
+      try {
+        this.ws.send(JSON.stringify({ type: "list_state", _reqId: reqId }));
+      } catch {
+        this.stateListResolvers.delete(reqId);
+        clearTimeout(timer);
+        resolve([]);
+      }
+    });
+  }
+  setState(key, value) {
+    if (this._status !== "open" || !this.ws)
+      return;
+    try {
+      this.ws.send(JSON.stringify({ type: "set_state", key, value }));
+    } catch {}
+  }
+  async remember(content, tags, timeoutMs = 5000) {
+    if (this._status !== "open" || !this.ws)
+      return null;
+    return new Promise((resolve) => {
+      const reqId = `mr-${++this.reqCounter}`;
+      const timer = setTimeout(() => {
+        if (this.memoryStoreResolvers.delete(reqId))
+          resolve(null);
+      }, timeoutMs);
+      this.memoryStoreResolvers.set(reqId, { resolve, timer });
+      try {
+        this.ws.send(JSON.stringify({ type: "remember", content, tags, _reqId: reqId }));
+      } catch {
+        this.memoryStoreResolvers.delete(reqId);
+        clearTimeout(timer);
+        resolve(null);
+      }
+    });
+  }
+  async recall(query, timeoutMs = 5000) {
+    if (this._status !== "open" || !this.ws)
+      return [];
+    return new Promise((resolve) => {
+      const reqId = `mc-${++this.reqCounter}`;
+      const timer = setTimeout(() => {
+        if (this.memoryRecallResolvers.delete(reqId))
+          resolve([]);
+      }, timeoutMs);
+      this.memoryRecallResolvers.set(reqId, { resolve, timer });
+      try {
+        this.ws.send(JSON.stringify({ type: "recall", query, _reqId: reqId }));
+      } catch {
+        this.memoryRecallResolvers.delete(reqId);
+        clearTimeout(timer);
+        resolve([]);
+      }
+    });
+  }
+  forget(memoryId) {
+    if (this._status !== "open" || !this.ws)
+      return;
+    try {
+      this.ws.send(JSON.stringify({ type: "forget", memoryId }));
+    } catch {}
+  }
   setProfile(profile) {
     if (this._status !== "open" || !this.ws)
       return;
@@ -9796,6 +10323,17 @@ async function drainOnce(opts, log2) {
     if (markInflight(opts.db, row.id, now) === 0)
       continue;
     const fpHex = bufferToHex(row.request_fingerprint);
+    let broker;
+    if (row.mesh) {
+      broker = opts.brokers.get(row.mesh);
+    } else if (opts.brokers.size === 1) {
+      broker = opts.brokers.values().next().value;
+    }
+    if (!broker) {
+      log2("warn", "drain_no_broker_for_mesh", { id: row.id, mesh: row.mesh ?? "(null)" });
+      markDead(opts.db, row.id, `no_broker_for_mesh:${row.mesh ?? "null"}`);
+      continue;
+    }
     let targetSpec;
     let nonce;
     let ciphertext;
@@ -9813,7 +10351,7 @@ async function drainOnce(opts, log2) {
     }
     let res;
     try {
-      res = await opts.broker.send({
+      res = await broker.send({
         targetSpec,
         priority,
         nonce,
@@ -10159,10 +10697,10 @@ async function runDaemon(opts = {}) {
   }
   const bus = new EventBus;
   const cfg = readConfig();
-  let mesh = null;
+  let meshes;
   if (opts.mesh) {
-    mesh = cfg.meshes.find((m) => m.slug === opts.mesh) ?? null;
-    if (!mesh) {
+    const found = cfg.meshes.find((m) => m.slug === opts.mesh);
+    if (!found) {
       process.stderr.write(`mesh not found: ${opts.mesh}
 `);
       process.stderr.write(`joined meshes: ${cfg.meshes.map((m) => m.slug).join(", ") || "(none)"}
@@ -10173,8 +10711,7 @@ async function runDaemon(opts = {}) {
       } catch {}
       return 2;
     }
-  } else if (cfg.meshes.length === 1) {
-    mesh = cfg.meshes[0];
+    meshes = [found];
   } else if (cfg.meshes.length === 0) {
     process.stderr.write(`no mesh joined; run \`claudemesh join <invite-url>\` first
 `);
@@ -10184,43 +10721,41 @@ async function runDaemon(opts = {}) {
     } catch {}
     return 2;
   } else {
-    process.stderr.write(`multiple meshes joined; pass --mesh <slug>
-`);
-    process.stderr.write(`available: ${cfg.meshes.map((m) => m.slug).join(", ")}
-`);
-    releaseSingletonLock();
-    try {
-      outboxDb.close();
-    } catch {}
-    return 2;
-  }
-  const broker = new DaemonBrokerClient(mesh, {
-    displayName: opts.displayName,
-    onStatusChange: (s) => {
-      process.stdout.write(JSON.stringify({
-        msg: "broker_status",
-        status: s,
-        mesh: mesh.slug,
-        ts: new Date().toISOString()
-      }) + `
+    meshes = cfg.meshes;
+  }
+  const brokers = new Map;
+  const meshConfigs = new Map;
+  for (const mesh of meshes) {
+    meshConfigs.set(mesh.slug, mesh);
+    const broker = new DaemonBrokerClient(mesh, {
+      displayName: opts.displayName,
+      onStatusChange: (s) => {
+        process.stdout.write(JSON.stringify({
+          msg: "broker_status",
+          status: s,
+          mesh: mesh.slug,
+          ts: new Date().toISOString()
+        }) + `
 `);
-      bus.publish("broker_status", { mesh: mesh.slug, status: s });
-    },
-    onPush: (m) => {
-      const sessionKeys = broker.getSessionKeys();
-      handleBrokerPush(m, {
-        db: inboxDb,
-        bus,
-        meshSlug: mesh.slug,
-        recipientSecretKeyHex: mesh.secretKey,
-        sessionSecretKeyHex: sessionKeys?.sessionSecretKey
-      });
-    }
-  });
-  broker.connect().catch((err) => process.stderr.write(`broker connect failed: ${String(err)}
+        bus.publish("broker_status", { mesh: mesh.slug, status: s });
+      },
+      onPush: (m) => {
+        const sessionKeys = broker.getSessionKeys();
+        handleBrokerPush(m, {
+          db: inboxDb,
+          bus,
+          meshSlug: mesh.slug,
+          recipientSecretKeyHex: mesh.secretKey,
+          sessionSecretKeyHex: sessionKeys?.sessionSecretKey
+        });
+      }
+    });
+    broker.connect().catch((err) => process.stderr.write(`broker connect failed for ${mesh.slug}: ${String(err)}
 `));
+    brokers.set(mesh.slug, broker);
+  }
   let drain = null;
-  drain = startDrainWorker({ db: outboxDb, broker });
+  drain = startDrainWorker({ db: outboxDb, brokers });
   const ipc2 = startIpcServer({
     localToken,
     tcpEnabled,
@@ -10228,10 +10763,9 @@ async function runDaemon(opts = {}) {
     outboxDb,
     inboxDb,
     bus,
-    broker,
-    onPendingInserted: () => drain?.wake(),
-    meshSecretKey: mesh.secretKey,
-    meshSlug: mesh.slug
+    brokers,
+    meshConfigs,
+    onPendingInserted: () => drain?.wake()
   });
   try {
     await ipc2.ready;
@@ -10246,7 +10780,7 @@ async function runDaemon(opts = {}) {
     pid: process.pid,
     sock: DAEMON_PATHS.SOCK_FILE,
     tcp: tcpEnabled ? `127.0.0.1:47823` : null,
-    mesh: mesh.slug,
+    meshes: meshes.map((m) => m.slug),
     ts: new Date().toISOString()
   }) + `
 `);
@@ -10259,7 +10793,11 @@ async function runDaemon(opts = {}) {
 `);
     if (drain)
       await drain.close();
-    await broker.close();
+    for (const b of brokers.values()) {
+      try {
+        await b.close();
+      } catch {}
+    }
     await ipc2.close();
     try {
       outboxDb.close();
@@ -17475,7 +18013,7 @@ USAGE
   claudemesh <invite-url>                     join a mesh, then launch
   claudemesh launch --name <n> --join <url>   join + launch in one step
 
-Mesh
+Mesh  (alias: "workspace" — claudemesh workspace <verb> mirrors each)
   claudemesh create <name>         create a new mesh
   claudemesh join <url>            join a mesh (accepts short /i/ or long /join/ link)
   claudemesh launch [slug]         launch Claude Code on a mesh (alias: connect)
@@ -17749,6 +18287,47 @@ async function main() {
       process.exit(await invite2(positionals[0], { mesh: flags.mesh, json: !!flags.json }));
       break;
     }
+    case "workspace": {
+      const sub = positionals[0];
+      if (!sub || sub === "launch" || sub === "connect" || sub === "open") {
+        const { runLaunch: runLaunch2 } = await Promise.resolve().then(() => (init_launch(), exports_launch));
+        await runLaunch2({
+          mesh: positionals[1] ?? flags.mesh,
+          name: flags.name,
+          join: flags.join,
+          yes: !!flags.y || !!flags.yes,
+          resume: flags.resume
+        }, process.argv.slice(2));
+      } else if (sub === "list" || sub === "ls") {
+        const { runList: runList2 } = await Promise.resolve().then(() => (init_list2(), exports_list));
+        await runList2();
+      } else if (sub === "info") {
+        const { runInfo: runInfo2 } = await Promise.resolve().then(() => (init_info2(), exports_info));
+        await runInfo2({});
+      } else if (sub === "create" || sub === "new") {
+        const { newMesh: newMesh2 } = await Promise.resolve().then(() => (init_new(), exports_new));
+        process.exit(await newMesh2(positionals[1] ?? "", { json: !!flags.json }));
+      } else if (sub === "join" || sub === "add") {
+        const { runJoin: runJoin2 } = await Promise.resolve().then(() => (init_join2(), exports_join));
+        await runJoin2(positionals.slice(1));
+      } else if (sub === "delete" || sub === "rm") {
+        const { deleteMesh: deleteMesh2 } = await Promise.resolve().then(() => (init_delete_mesh(), exports_delete_mesh));
+        process.exit(await deleteMesh2(positionals[1] ?? "", { yes: !!flags.y || !!flags.yes }));
+      } else if (sub === "rename") {
+        const { rename: rename2 } = await Promise.resolve().then(() => (init_rename2(), exports_rename));
+        process.exit(await rename2(positionals[1] ?? "", positionals[2] ?? ""));
+      } else if (sub === "share" || sub === "invite") {
+        const { invite: invite2 } = await Promise.resolve().then(() => (init_invite(), exports_invite));
+        process.exit(await invite2(positionals[1], { mesh: flags.mesh, json: !!flags.json }));
+      } else if (sub === "overview") {
+        const { runMe: runMe2 } = await Promise.resolve().then(() => (init_me(), exports_me));
+        process.exit(await runMe2({ mesh: flags.mesh, json: !!flags.json }));
+      } else {
+        console.error("Usage: claudemesh workspace <list|info|create|join|delete|rename|share|launch|overview>");
+        process.exit(EXIT.INVALID_ARGS);
+      }
+      break;
+    }
     case "disconnect": {
       const { runDisconnect: runDisconnect2 } = await Promise.resolve().then(() => (init_kick(), exports_kick));
       process.exit(await runDisconnect2(positionals[0], { mesh: flags.mesh, stale: flags.stale, all: !!flags.all }));
@@ -18594,4 +19173,4 @@ main().catch((err) => {
   process.exit(EXIT.INTERNAL_ERROR);
 });
 
-//# debugId=EC115E4068A7B5F664756E2164756E21
+//# debugId=5CE8252722B33A8D64756E2164756E21