claudemesh-cli 1.2.1 → 1.4.0

package/dist/entrypoints/cli.js

@@ -88,7 +88,7 @@ __export(exports_urls, {
   VERSION: () => VERSION,
   URLS: () => URLS
 });
-var URLS, VERSION = "1.2.1", env;
+var URLS, VERSION = "1.4.0", env;
 var init_urls = __esm(() => {
   URLS = {
     BROKER: process.env.CLAUDEMESH_BROKER_URL ?? "wss://ic.claudemesh.com/ws",
@@ -6817,26 +6817,27 @@ __export(exports_remember, {
   remember: () => remember
 });
 async function remember(content, opts = {}) {
-  const client = allClients()[0];
-  if (!client) {
-    render.err("Not connected to any mesh.");
-    return EXIT.NETWORK_ERROR;
+  if (!content) {
+    render.err("Usage: claudemesh remember <text>");
+    return EXIT.INVALID_ARGS;
   }
   const tags = opts.tags?.split(",").map((t) => t.trim()).filter(Boolean);
-  const id = await client.remember(content, tags);
-  if (opts.json) {
-    console.log(JSON.stringify({ id, content, tags }));
-    return EXIT.SUCCESS;
-  }
-  if (id) {
-    render.ok("remembered", dim(id.slice(0, 8)));
-    return EXIT.SUCCESS;
-  }
-  render.err("failed to store memory");
-  return EXIT.INTERNAL_ERROR;
+  return await withMesh({ meshSlug: opts.mesh ?? null }, async (client) => {
+    const id = await client.remember(content, tags);
+    if (opts.json) {
+      console.log(JSON.stringify({ id, content, tags }));
+      return EXIT.SUCCESS;
+    }
+    if (id) {
+      render.ok("remembered", dim(id.slice(0, 8)));
+      return EXIT.SUCCESS;
+    }
+    render.err("failed to store memory");
+    return EXIT.INTERNAL_ERROR;
+  });
 }
 var init_remember = __esm(() => {
-  init_facade8();
+  init_connect();
   init_render();
   init_styles();
   init_exit_codes();
@@ -6848,35 +6849,36 @@ __export(exports_recall, {
   recall: () => recall
 });
 async function recall(query, opts = {}) {
-  const client = allClients()[0];
-  if (!client) {
-    render.err("Not connected to any mesh.");
-    return EXIT.NETWORK_ERROR;
-  }
-  const memories = await client.recall(query);
-  if (opts.json) {
-    console.log(JSON.stringify(memories, null, 2));
-    return EXIT.SUCCESS;
-  }
-  if (memories.length === 0) {
-    render.info(dim("no memories found."));
-    return EXIT.SUCCESS;
+  if (!query) {
+    render.err("Usage: claudemesh recall <query>");
+    return EXIT.INVALID_ARGS;
   }
-  render.section(`memories (${memories.length})`);
-  for (const m of memories) {
-    const tags = m.tags.length ? dim(` [${m.tags.map((t) => clay(t)).join(dim(", "))}]`) : "";
-    process.stdout.write(`  ${bold(m.id.slice(0, 8))}${tags}
+  return await withMesh({ meshSlug: opts.mesh ?? null }, async (client) => {
+    const memories = await client.recall(query);
+    if (opts.json) {
+      console.log(JSON.stringify(memories, null, 2));
+      return EXIT.SUCCESS;
+    }
+    if (memories.length === 0) {
+      render.info(dim("no memories found."));
+      return EXIT.SUCCESS;
+    }
+    render.section(`memories (${memories.length})`);
+    for (const m of memories) {
+      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(`    ${m.content}
 `);
-    process.stdout.write(`    ${dim(m.rememberedBy + "  ·  " + new Date(m.rememberedAt).toLocaleString())}
+      process.stdout.write(`    ${dim(m.rememberedBy + "  ·  " + new Date(m.rememberedAt).toLocaleString())}
 
 `);
-  }
-  return EXIT.SUCCESS;
+    }
+    return EXIT.SUCCESS;
+  });
 }
 var init_recall = __esm(() => {
-  init_facade8();
+  init_connect();
   init_render();
   init_styles();
   init_exit_codes();
@@ -7330,92 +7332,6 @@ var init_remind = __esm(() => {
   init_styles();
 });
 
-// src/commands/profile.ts
-var exports_profile = {};
-__export(exports_profile, {
-  runProfile: () => runProfile
-});
-async function runProfile(flags) {
-  const useColor = !process.env.NO_COLOR && process.env.TERM !== "dumb" && process.stdout.isTTY;
-  const dim2 = (s) => useColor ? `\x1B[2m${s}\x1B[22m` : s;
-  const green3 = (s) => useColor ? `\x1B[32m${s}\x1B[39m` : s;
-  const config = readConfig();
-  if (config.meshes.length === 0) {
-    console.error("No meshes joined. Run `claudemesh join <url>` first.");
-    process.exit(1);
-  }
-  const mesh = flags.mesh ? config.meshes.find((m) => m.slug === flags.mesh) : config.meshes[0];
-  if (!mesh) {
-    console.error(`Mesh "${flags.mesh}" not found. Joined: ${config.meshes.map((m) => m.slug).join(", ")}`);
-    process.exit(1);
-  }
-  const brokerUrl = mesh.brokerUrl.replace("wss://", "https://").replace("ws://", "http://").replace(/\/ws\/?$/, "");
-  const hasEdits = flags["role-tag"] !== undefined || flags.groups !== undefined || flags["message-mode"] !== undefined || flags.name !== undefined;
-  if (hasEdits) {
-    const targetMemberId = flags.member ?? mesh.memberId;
-    const body = {};
-    if (flags.name !== undefined)
-      body.displayName = flags.name;
-    if (flags["role-tag"] !== undefined)
-      body.roleTag = flags["role-tag"];
-    if (flags.groups !== undefined) {
-      body.groups = flags.groups.split(",").map((s) => {
-        const [name, role] = s.trim().split(":");
-        return role ? { name, role } : { name };
-      });
-    }
-    if (flags["message-mode"] !== undefined)
-      body.messageMode = flags["message-mode"];
-    const res = await fetch(`${brokerUrl}/mesh/${mesh.meshId}/member/${targetMemberId}`, {
-      method: "PATCH",
-      headers: {
-        "Content-Type": "application/json",
-        "X-Member-Id": mesh.memberId
-      },
-      body: JSON.stringify(body)
-    });
-    const result = await res.json();
-    if (flags.json) {
-      console.log(JSON.stringify(result, null, 2));
-    } else if (result.ok) {
-      console.log(green3("✓ Profile updated"));
-      const member = result.member;
-      printProfile(member, dim2);
-    } else {
-      console.error(`Error: ${result.error}`);
-      process.exit(1);
-    }
-  } else {
-    const res = await fetch(`${brokerUrl}/mesh/${mesh.meshId}/members`);
-    const result = await res.json();
-    if (!result.ok) {
-      console.error(`Error: ${result.error}`);
-      process.exit(1);
-    }
-    const me = result.members?.find((m) => m.id === mesh.memberId);
-    if (flags.json) {
-      console.log(JSON.stringify(me ?? {}, null, 2));
-    } else if (me) {
-      printProfile(me, dim2);
-    } else {
-      console.log("Member not found in mesh.");
-    }
-  }
-}
-function printProfile(member, dim2) {
-  const groups = member.groups;
-  const groupStr = groups?.length ? groups.map((g) => g.role ? `${g.name} (${g.role})` : g.name).join(", ") : dim2("(none)");
-  console.log(`  Name:     ${member.displayName ?? dim2("(not set)")}`);
-  console.log(`  Role:     ${member.roleTag ?? dim2("(not set)")}`);
-  console.log(`  Groups:   ${groupStr}`);
-  console.log(`  Messages: ${member.messageMode ?? "push"}`);
-  console.log(`  Access:   ${member.permission ?? "member"}`);
-  console.log(`  Mesh:     ${dim2(String(member.id ?? ""))}`);
-}
-var init_profile = __esm(() => {
-  init_facade();
-});
-
 // src/commands/register.ts
 var exports_register = {};
 __export(exports_register, {
@@ -9563,79 +9479,925 @@ async function runRevoke(peer, caps, opts = {}) {
   render.kv([["now", after.length ? after.join(", ") : "(none)"]]);
   return EXIT.SUCCESS;
 }
-async function runBlock(peer, opts = {}) {
-  if (!peer) {
-    render.err("Usage: claudemesh block <peer>");
+async function runBlock(peer, opts = {}) {
+  if (!peer) {
+    render.err("Usage: claudemesh block <peer>");
+    return EXIT.INVALID_ARGS;
+  }
+  const mesh = pickMesh2(opts.mesh);
+  if (!mesh) {
+    render.err("No matching mesh.");
+    return EXIT.NOT_FOUND;
+  }
+  const resolved = await resolvePeer(mesh, peer);
+  if (!resolved) {
+    render.err(`Peer "${peer}" not found on ${mesh}.`);
+    return EXIT.NOT_FOUND;
+  }
+  const store = readGrants();
+  const meshGrants = store[mesh] ?? {};
+  meshGrants[resolved.pubkey] = [];
+  store[mesh] = meshGrants;
+  writeGrants(store);
+  await syncToBroker(mesh, { [resolved.pubkey]: [] });
+  render.ok(`Blocked ${resolved.displayName} on ${mesh} (all capabilities revoked).`);
+  render.hint(`Undo with: claudemesh grant ${resolved.displayName} all --mesh ${mesh}`);
+  return EXIT.SUCCESS;
+}
+async function runGrants(opts = {}) {
+  const mesh = pickMesh2(opts.mesh);
+  if (!mesh) {
+    render.err("No matching mesh.");
+    return EXIT.NOT_FOUND;
+  }
+  const store = readGrants();
+  const meshGrants = store[mesh] ?? {};
+  if (opts.json) {
+    console.log(JSON.stringify({ schema_version: "1.0", mesh, grants: meshGrants }, null, 2));
+    return EXIT.SUCCESS;
+  }
+  render.section(`grants on ${mesh}`);
+  const peerPubkeys = Object.keys(meshGrants);
+  if (peerPubkeys.length === 0) {
+    render.info("(no overrides — all peers use default caps: " + DEFAULT_CAPS.join(", ") + ")");
+    return EXIT.SUCCESS;
+  }
+  await withMesh({ meshSlug: mesh }, async (client) => {
+    const peers = await client.listPeers();
+    const byPk = new Map(peers.map((p) => [p.pubkey, p.displayName]));
+    for (const [pk, caps] of Object.entries(meshGrants)) {
+      const name = byPk.get(pk) ?? `${pk.slice(0, 10)}…`;
+      render.kv([[name, caps.length ? caps.join(", ") : "(blocked)"]]);
+    }
+  });
+  return EXIT.SUCCESS;
+}
+function isAllowed(meshSlug, peerPubkey, cap) {
+  const store = readGrants();
+  const entry = store[meshSlug]?.[peerPubkey];
+  if (entry === undefined)
+    return DEFAULT_CAPS.includes(cap);
+  return entry.includes(cap);
+}
+var BROKER_HTTP7, ALL_CAPS, DEFAULT_CAPS, GRANT_FILE;
+var init_grants = __esm(() => {
+  init_facade();
+  init_connect();
+  init_render();
+  init_exit_codes();
+  init_facade6();
+  init_facade3();
+  init_urls();
+  BROKER_HTTP7 = URLS.BROKER.replace("wss://", "https://").replace("ws://", "http://").replace("/ws", "");
+  ALL_CAPS = ["read", "dm", "broadcast", "state-read", "state-write", "file-read"];
+  DEFAULT_CAPS = ["read", "dm", "broadcast", "state-read"];
+  GRANT_FILE = join11(homedir10(), ".claudemesh", "grants.json");
+});
+
+// src/commands/profile.ts
+var exports_profile = {};
+__export(exports_profile, {
+  runProfile: () => runProfile
+});
+async function runProfile(flags) {
+  const useColor = !process.env.NO_COLOR && process.env.TERM !== "dumb" && process.stdout.isTTY;
+  const dim2 = (s) => useColor ? `\x1B[2m${s}\x1B[22m` : s;
+  const green3 = (s) => useColor ? `\x1B[32m${s}\x1B[39m` : s;
+  const config = readConfig();
+  if (config.meshes.length === 0) {
+    console.error("No meshes joined. Run `claudemesh join <url>` first.");
+    process.exit(1);
+  }
+  const mesh = flags.mesh ? config.meshes.find((m) => m.slug === flags.mesh) : config.meshes[0];
+  if (!mesh) {
+    console.error(`Mesh "${flags.mesh}" not found. Joined: ${config.meshes.map((m) => m.slug).join(", ")}`);
+    process.exit(1);
+  }
+  const brokerUrl = mesh.brokerUrl.replace("wss://", "https://").replace("ws://", "http://").replace(/\/ws\/?$/, "");
+  const hasEdits = flags["role-tag"] !== undefined || flags.groups !== undefined || flags["message-mode"] !== undefined || flags.name !== undefined;
+  if (hasEdits) {
+    const targetMemberId = flags.member ?? mesh.memberId;
+    const body = {};
+    if (flags.name !== undefined)
+      body.displayName = flags.name;
+    if (flags["role-tag"] !== undefined)
+      body.roleTag = flags["role-tag"];
+    if (flags.groups !== undefined) {
+      body.groups = flags.groups.split(",").map((s) => {
+        const [name, role] = s.trim().split(":");
+        return role ? { name, role } : { name };
+      });
+    }
+    if (flags["message-mode"] !== undefined)
+      body.messageMode = flags["message-mode"];
+    const res = await fetch(`${brokerUrl}/mesh/${mesh.meshId}/member/${targetMemberId}`, {
+      method: "PATCH",
+      headers: {
+        "Content-Type": "application/json",
+        "X-Member-Id": mesh.memberId
+      },
+      body: JSON.stringify(body)
+    });
+    const result = await res.json();
+    if (flags.json) {
+      console.log(JSON.stringify(result, null, 2));
+    } else if (result.ok) {
+      console.log(green3("✓ Profile updated"));
+      const member = result.member;
+      printProfile(member, dim2);
+    } else {
+      console.error(`Error: ${result.error}`);
+      process.exit(1);
+    }
+  } else {
+    const res = await fetch(`${brokerUrl}/mesh/${mesh.meshId}/members`);
+    const result = await res.json();
+    if (!result.ok) {
+      console.error(`Error: ${result.error}`);
+      process.exit(1);
+    }
+    const me = result.members?.find((m) => m.id === mesh.memberId);
+    if (flags.json) {
+      console.log(JSON.stringify(me ?? {}, null, 2));
+    } else if (me) {
+      printProfile(me, dim2);
+    } else {
+      console.log("Member not found in mesh.");
+    }
+  }
+}
+function printProfile(member, dim2) {
+  const groups = member.groups;
+  const groupStr = groups?.length ? groups.map((g) => g.role ? `${g.name} (${g.role})` : g.name).join(", ") : dim2("(none)");
+  console.log(`  Name:     ${member.displayName ?? dim2("(not set)")}`);
+  console.log(`  Role:     ${member.roleTag ?? dim2("(not set)")}`);
+  console.log(`  Groups:   ${groupStr}`);
+  console.log(`  Messages: ${member.messageMode ?? "push"}`);
+  console.log(`  Access:   ${member.permission ?? "member"}`);
+  console.log(`  Mesh:     ${dim2(String(member.id ?? ""))}`);
+}
+var init_profile = __esm(() => {
+  init_facade();
+});
+
+// src/commands/platform-actions.ts
+var exports_platform_actions = {};
+__export(exports_platform_actions, {
+  runWebhookList: () => runWebhookList,
+  runWebhookDelete: () => runWebhookDelete,
+  runWatchList: () => runWatchList,
+  runVectorStore: () => runVectorStore,
+  runVectorSearch: () => runVectorSearch,
+  runVectorDelete: () => runVectorDelete,
+  runVectorCollections: () => runVectorCollections,
+  runVaultList: () => runVaultList,
+  runVaultDelete: () => runVaultDelete,
+  runUnwatch: () => runUnwatch,
+  runTaskList: () => runTaskList,
+  runTaskCreate: () => runTaskCreate,
+  runStreamPublish: () => runStreamPublish,
+  runStreamList: () => runStreamList,
+  runStreamCreate: () => runStreamCreate,
+  runSqlSchema: () => runSqlSchema,
+  runSqlQuery: () => runSqlQuery,
+  runSqlExecute: () => runSqlExecute,
+  runSkillRemove: () => runSkillRemove,
+  runSkillList: () => runSkillList,
+  runSkillGet: () => runSkillGet,
+  runMeshMcpList: () => runMeshMcpList,
+  runMeshMcpCatalog: () => runMeshMcpCatalog,
+  runMeshMcpCall: () => runMeshMcpCall,
+  runGraphQuery: () => runGraphQuery,
+  runGraphExecute: () => runGraphExecute,
+  runFileStatus: () => runFileStatus,
+  runFileList: () => runFileList,
+  runFileDelete: () => runFileDelete,
+  runContextShare: () => runContextShare,
+  runContextList: () => runContextList,
+  runContextGet: () => runContextGet,
+  runClockSet: () => runClockSet,
+  runClockResume: () => runClockResume,
+  runClockPause: () => runClockPause
+});
+function emitJson(data) {
+  console.log(JSON.stringify(data, null, 2));
+}
+async function runVectorStore(collection, text, opts) {
+  if (!collection || !text) {
+    render.err("Usage: claudemesh vector store <collection> <text> [--metadata <json>]");
+    return EXIT.INVALID_ARGS;
+  }
+  let metadata;
+  if (opts.metadata) {
+    try {
+      metadata = JSON.parse(opts.metadata);
+    } catch {
+      render.err("--metadata must be JSON");
+      return EXIT.INVALID_ARGS;
+    }
+  }
+  return await withMesh({ meshSlug: opts.mesh ?? null }, async (client) => {
+    const id = await client.vectorStore(collection, text, metadata);
+    if (!id) {
+      render.err("store failed");
+      return EXIT.INTERNAL_ERROR;
+    }
+    if (opts.json)
+      emitJson({ id, collection });
+    else
+      render.ok(`stored in ${clay(collection)}`, dim(id));
+    return EXIT.SUCCESS;
+  });
+}
+async function runVectorSearch(collection, query, opts) {
+  if (!collection || !query) {
+    render.err("Usage: claudemesh vector search <collection> <query> [--limit N]");
+    return EXIT.INVALID_ARGS;
+  }
+  const limit = opts.limit ? parseInt(opts.limit, 10) : undefined;
+  return await withMesh({ meshSlug: opts.mesh ?? null }, async (client) => {
+    const hits = await client.vectorSearch(collection, query, limit);
+    if (opts.json) {
+      emitJson(hits);
+      return EXIT.SUCCESS;
+    }
+    if (hits.length === 0) {
+      render.info(dim("(no matches)"));
+      return EXIT.SUCCESS;
+    }
+    render.section(`${hits.length} match${hits.length === 1 ? "" : "es"} in ${clay(collection)}`);
+    for (const h of hits) {
+      process.stdout.write(`  ${bold(h.score.toFixed(3))}  ${dim(h.id.slice(0, 8))}  ${h.text}
+`);
+    }
+    return EXIT.SUCCESS;
+  });
+}
+async function runVectorDelete(collection, id, opts) {
+  if (!collection || !id) {
+    render.err("Usage: claudemesh vector delete <collection> <id>");
+    return EXIT.INVALID_ARGS;
+  }
+  return await withMesh({ meshSlug: opts.mesh ?? null }, async (client) => {
+    await client.vectorDelete(collection, id);
+    if (opts.json)
+      emitJson({ id, deleted: true });
+    else
+      render.ok(`deleted ${dim(id.slice(0, 8))}`);
+    return EXIT.SUCCESS;
+  });
+}
+async function runVectorCollections(opts) {
+  return await withMesh({ meshSlug: opts.mesh ?? null }, async (client) => {
+    const cols = await client.listCollections();
+    if (opts.json) {
+      emitJson(cols);
+      return EXIT.SUCCESS;
+    }
+    if (cols.length === 0) {
+      render.info(dim("(no collections)"));
+      return EXIT.SUCCESS;
+    }
+    render.section(`vector collections (${cols.length})`);
+    for (const c of cols)
+      process.stdout.write(`  ${clay(c)}
+`);
+    return EXIT.SUCCESS;
+  });
+}
+async function runGraphQuery(cypher, opts) {
+  if (!cypher) {
+    render.err('Usage: claudemesh graph query "<cypher>"');
+    return EXIT.INVALID_ARGS;
+  }
+  return await withMesh({ meshSlug: opts.mesh ?? null }, async (client) => {
+    const rows = await client.graphQuery(cypher);
+    if (opts.json) {
+      emitJson(rows);
+      return EXIT.SUCCESS;
+    }
+    if (rows.length === 0) {
+      render.info(dim("(no rows)"));
+      return EXIT.SUCCESS;
+    }
+    render.section(`${rows.length} row${rows.length === 1 ? "" : "s"}`);
+    for (const r of rows)
+      process.stdout.write(`  ${JSON.stringify(r)}
+`);
+    return EXIT.SUCCESS;
+  });
+}
+async function runGraphExecute(cypher, opts) {
+  if (!cypher) {
+    render.err('Usage: claudemesh graph execute "<cypher>"');
+    return EXIT.INVALID_ARGS;
+  }
+  return await withMesh({ meshSlug: opts.mesh ?? null }, async (client) => {
+    const rows = await client.graphExecute(cypher);
+    if (opts.json) {
+      emitJson(rows);
+      return EXIT.SUCCESS;
+    }
+    render.ok("executed", `${rows.length} row${rows.length === 1 ? "" : "s"} affected`);
+    return EXIT.SUCCESS;
+  });
+}
+async function runContextShare(summary, opts) {
+  if (!summary) {
+    render.err('Usage: claudemesh context share "<summary>" [--files a,b] [--findings x,y] [--tags t1,t2]');
+    return EXIT.INVALID_ARGS;
+  }
+  const files = opts.files?.split(",").map((s) => s.trim()).filter(Boolean);
+  const findings = opts.findings?.split(",").map((s) => s.trim()).filter(Boolean);
+  const tags = opts.tags?.split(",").map((s) => s.trim()).filter(Boolean);
+  return await withMesh({ meshSlug: opts.mesh ?? null }, async (client) => {
+    await client.shareContext(summary, files, findings, tags);
+    if (opts.json)
+      emitJson({ shared: true, summary });
+    else
+      render.ok("context shared");
+    return EXIT.SUCCESS;
+  });
+}
+async function runContextGet(query, opts) {
+  if (!query) {
+    render.err('Usage: claudemesh context get "<query>"');
+    return EXIT.INVALID_ARGS;
+  }
+  return await withMesh({ meshSlug: opts.mesh ?? null }, async (client) => {
+    const ctxs = await client.getContext(query);
+    if (opts.json) {
+      emitJson(ctxs);
+      return EXIT.SUCCESS;
+    }
+    if (ctxs.length === 0) {
+      render.info(dim("(no matches)"));
+      return EXIT.SUCCESS;
+    }
+    render.section(`${ctxs.length} context${ctxs.length === 1 ? "" : "s"}`);
+    for (const c of ctxs) {
+      process.stdout.write(`  ${bold(c.peerName)} ${dim("·")} ${c.updatedAt}
+`);
+      process.stdout.write(`    ${c.summary}
+`);
+      if (c.tags.length)
+        process.stdout.write(`    ${dim("tags: " + c.tags.join(", "))}
+`);
+    }
+    return EXIT.SUCCESS;
+  });
+}
+async function runContextList(opts) {
+  return await withMesh({ meshSlug: opts.mesh ?? null }, async (client) => {
+    const ctxs = await client.listContexts();
+    if (opts.json) {
+      emitJson(ctxs);
+      return EXIT.SUCCESS;
+    }
+    if (ctxs.length === 0) {
+      render.info(dim("(no contexts)"));
+      return EXIT.SUCCESS;
+    }
+    render.section(`shared contexts (${ctxs.length})`);
+    for (const c of ctxs) {
+      process.stdout.write(`  ${bold(c.peerName)} ${dim("·")} ${c.updatedAt}
+`);
+      process.stdout.write(`    ${c.summary}
+`);
+    }
+    return EXIT.SUCCESS;
+  });
+}
+async function runStreamCreate(name, opts) {
+  if (!name) {
+    render.err("Usage: claudemesh stream create <name>");
+    return EXIT.INVALID_ARGS;
+  }
+  return await withMesh({ meshSlug: opts.mesh ?? null }, async (client) => {
+    const id = await client.createStream(name);
+    if (!id) {
+      render.err("create failed");
+      return EXIT.INTERNAL_ERROR;
+    }
+    if (opts.json)
+      emitJson({ id, name });
+    else
+      render.ok(`created ${clay(name)}`, dim(id));
+    return EXIT.SUCCESS;
+  });
+}
+async function runStreamPublish(name, dataRaw, opts) {
+  if (!name || dataRaw === undefined) {
+    render.err("Usage: claudemesh stream publish <name> <json-or-text>");
+    return EXIT.INVALID_ARGS;
+  }
+  let data;
+  try {
+    data = JSON.parse(dataRaw);
+  } catch {
+    data = dataRaw;
+  }
+  return await withMesh({ meshSlug: opts.mesh ?? null }, async (client) => {
+    await client.publish(name, data);
+    if (opts.json)
+      emitJson({ published: true, name });
+    else
+      render.ok(`published to ${clay(name)}`);
+    return EXIT.SUCCESS;
+  });
+}
+async function runStreamList(opts) {
+  return await withMesh({ meshSlug: opts.mesh ?? null }, async (client) => {
+    const streams = await client.listStreams();
+    if (opts.json) {
+      emitJson(streams);
+      return EXIT.SUCCESS;
+    }
+    if (streams.length === 0) {
+      render.info(dim("(no streams)"));
+      return EXIT.SUCCESS;
+    }
+    render.section(`streams (${streams.length})`);
+    for (const s of streams) {
+      process.stdout.write(`  ${clay(s.name)} ${dim(`· ${s.subscriberCount} subscriber${s.subscriberCount === 1 ? "" : "s"} · by ${s.createdBy}`)}
+`);
+    }
+    return EXIT.SUCCESS;
+  });
+}
+async function runSqlQuery(sql, opts) {
+  if (!sql) {
+    render.err('Usage: claudemesh sql query "<select>"');
+    return EXIT.INVALID_ARGS;
+  }
+  return await withMesh({ meshSlug: opts.mesh ?? null }, async (client) => {
+    const result = await client.meshQuery(sql);
+    if (!result) {
+      render.err("query timed out");
+      return EXIT.INTERNAL_ERROR;
+    }
+    if (opts.json) {
+      emitJson(result);
+      return EXIT.SUCCESS;
+    }
+    render.section(`${result.rowCount} row${result.rowCount === 1 ? "" : "s"}`);
+    if (result.columns.length > 0) {
+      process.stdout.write(`  ${dim(result.columns.join("  "))}
+`);
+      for (const row of result.rows) {
+        process.stdout.write(`  ${result.columns.map((c) => String(row[c] ?? "")).join("  ")}
+`);
+      }
+    }
+    return EXIT.SUCCESS;
+  });
+}
+async function runSqlExecute(sql, opts) {
+  if (!sql) {
+    render.err('Usage: claudemesh sql execute "<statement>"');
+    return EXIT.INVALID_ARGS;
+  }
+  return await withMesh({ meshSlug: opts.mesh ?? null }, async (client) => {
+    await client.meshExecute(sql);
+    if (opts.json)
+      emitJson({ executed: true });
+    else
+      render.ok("executed");
+    return EXIT.SUCCESS;
+  });
+}
+async function runSqlSchema(opts) {
+  return await withMesh({ meshSlug: opts.mesh ?? null }, async (client) => {
+    const tables = await client.meshSchema();
+    if (opts.json) {
+      emitJson(tables);
+      return EXIT.SUCCESS;
+    }
+    if (tables.length === 0) {
+      render.info(dim("(no tables)"));
+      return EXIT.SUCCESS;
+    }
+    render.section(`mesh tables (${tables.length})`);
+    for (const t of tables) {
+      process.stdout.write(`  ${bold(t.name)}
+`);
+      for (const c of t.columns) {
+        const nullable = c.nullable ? "" : " not null";
+        process.stdout.write(`    ${c.name} ${dim(c.type + nullable)}
+`);
+      }
+    }
+    return EXIT.SUCCESS;
+  });
+}
+async function runSkillList(opts) {
+  return await withMesh({ meshSlug: opts.mesh ?? null }, async (client) => {
+    const skills = await client.listSkills(opts.query);
+    if (opts.json) {
+      emitJson(skills);
+      return EXIT.SUCCESS;
+    }
+    if (skills.length === 0) {
+      render.info(dim("(no skills)"));
+      return EXIT.SUCCESS;
+    }
+    render.section(`mesh skills (${skills.length})`);
+    for (const s of skills) {
+      process.stdout.write(`  ${bold(s.name)} ${dim("· by " + s.author)}
+`);
+      process.stdout.write(`    ${s.description}
+`);
+      if (s.tags.length)
+        process.stdout.write(`    ${dim("tags: " + s.tags.join(", "))}
+`);
+    }
+    return EXIT.SUCCESS;
+  });
+}
+async function runSkillGet(name, opts) {
+  if (!name) {
+    render.err("Usage: claudemesh skill get <name>");
+    return EXIT.INVALID_ARGS;
+  }
+  return await withMesh({ meshSlug: opts.mesh ?? null }, async (client) => {
+    const skill = await client.getSkill(name);
+    if (!skill) {
+      render.err(`skill "${name}" not found`);
+      return EXIT.NOT_FOUND;
+    }
+    if (opts.json) {
+      emitJson(skill);
+      return EXIT.SUCCESS;
+    }
+    render.section(skill.name);
+    render.kv([
+      ["author", skill.author],
+      ["created", skill.createdAt],
+      ["tags", skill.tags.join(", ") || dim("(none)")]
+    ]);
+    render.blank();
+    render.info(skill.description);
+    render.blank();
+    process.stdout.write(skill.instructions + `
+`);
+    return EXIT.SUCCESS;
+  });
+}
+async function runSkillRemove(name, opts) {
+  if (!name) {
+    render.err("Usage: claudemesh skill remove <name>");
+    return EXIT.INVALID_ARGS;
+  }
+  return await withMesh({ meshSlug: opts.mesh ?? null }, async (client) => {
+    const removed = await client.removeSkill(name);
+    if (opts.json)
+      emitJson({ name, removed });
+    else if (removed)
+      render.ok(`removed ${bold(name)}`);
+    else
+      render.err(`skill "${name}" not found`);
+    return removed ? EXIT.SUCCESS : EXIT.NOT_FOUND;
+  });
+}
+async function runVaultList(opts) {
+  return await withMesh({ meshSlug: opts.mesh ?? null }, async (client) => {
+    const entries = await client.vaultList();
+    if (opts.json) {
+      emitJson(entries);
+      return EXIT.SUCCESS;
+    }
+    if (!entries || entries.length === 0) {
+      render.info(dim("(vault empty)"));
+      return EXIT.SUCCESS;
+    }
+    render.section(`vault (${entries.length})`);
+    for (const e of entries) {
+      const k = String(e?.key ?? "?");
+      const t = String(e?.entry_type ?? "");
+      process.stdout.write(`  ${bold(k)} ${dim(t)}
+`);
+    }
+    return EXIT.SUCCESS;
+  });
+}
+async function runVaultDelete(key, opts) {
+  if (!key) {
+    render.err("Usage: claudemesh vault delete <key>");
+    return EXIT.INVALID_ARGS;
+  }
+  return await withMesh({ meshSlug: opts.mesh ?? null }, async (client) => {
+    const ok = await client.vaultDelete(key);
+    if (opts.json)
+      emitJson({ key, deleted: ok });
+    else if (ok)
+      render.ok(`deleted ${bold(key)}`);
+    else
+      render.err(`vault key "${key}" not found`);
+    return ok ? EXIT.SUCCESS : EXIT.NOT_FOUND;
+  });
+}
+async function runWatchList(opts) {
+  return await withMesh({ meshSlug: opts.mesh ?? null }, async (client) => {
+    const watches = await client.watchList();
+    if (opts.json) {
+      emitJson(watches);
+      return EXIT.SUCCESS;
+    }
+    if (!watches || watches.length === 0) {
+      render.info(dim("(no watches)"));
+      return EXIT.SUCCESS;
+    }
+    render.section(`url watches (${watches.length})`);
+    for (const w of watches) {
+      const id = String(w.id ?? "?");
+      const url = String(w.url ?? "");
+      const label = w.label ? ` ${dim("(" + w.label + ")")}` : "";
+      process.stdout.write(`  ${dim(id.slice(0, 8))}  ${clay(url)}${label}
+`);
+    }
+    return EXIT.SUCCESS;
+  });
+}
+async function runUnwatch(id, opts) {
+  if (!id) {
+    render.err("Usage: claudemesh watch remove <id>");
+    return EXIT.INVALID_ARGS;
+  }
+  return await withMesh({ meshSlug: opts.mesh ?? null }, async (client) => {
+    const ok = await client.unwatch(id);
+    if (opts.json)
+      emitJson({ id, removed: ok });
+    else if (ok)
+      render.ok(`unwatched ${dim(id.slice(0, 8))}`);
+    else
+      render.err(`watch "${id}" not found`);
+    return ok ? EXIT.SUCCESS : EXIT.NOT_FOUND;
+  });
+}
+async function runWebhookList(opts) {
+  return await withMesh({ meshSlug: opts.mesh ?? null }, async (client) => {
+    const hooks = await client.listWebhooks();
+    if (opts.json) {
+      emitJson(hooks);
+      return EXIT.SUCCESS;
+    }
+    if (hooks.length === 0) {
+      render.info(dim("(no webhooks)"));
+      return EXIT.SUCCESS;
+    }
+    render.section(`webhooks (${hooks.length})`);
+    for (const h of hooks) {
+      const dot = h.active ? "●" : dim("○");
+      process.stdout.write(`  ${dot} ${bold(h.name)} ${dim("· " + h.url)}
+`);
+    }
+    return EXIT.SUCCESS;
+  });
+}
+async function runWebhookDelete(name, opts) {
+  if (!name) {
+    render.err("Usage: claudemesh webhook delete <name>");
+    return EXIT.INVALID_ARGS;
+  }
+  return await withMesh({ meshSlug: opts.mesh ?? null }, async (client) => {
+    const ok = await client.deleteWebhook(name);
+    if (opts.json)
+      emitJson({ name, deleted: ok });
+    else if (ok)
+      render.ok(`deleted ${bold(name)}`);
+    else
+      render.err(`webhook "${name}" not found`);
+    return ok ? EXIT.SUCCESS : EXIT.NOT_FOUND;
+  });
+}
+async function runTaskList(opts) {
+  return await withMesh({ meshSlug: opts.mesh ?? null }, async (client) => {
+    const tasks = await client.listTasks(opts.status, opts.assignee);
+    if (opts.json) {
+      emitJson(tasks);
+      return EXIT.SUCCESS;
+    }
+    if (tasks.length === 0) {
+      render.info(dim("(no tasks)"));
+      return EXIT.SUCCESS;
+    }
+    render.section(`tasks (${tasks.length})`);
+    for (const t of tasks) {
+      const dot = t.status === "done" ? "●" : t.status === "claimed" ? clay("●") : dim("○");
+      const assignee = t.assignee ? dim(` → ${t.assignee}`) : "";
+      process.stdout.write(`  ${dot} ${dim(t.id.slice(0, 8))} ${bold(t.title)}${assignee}
+`);
+    }
+    return EXIT.SUCCESS;
+  });
+}
+async function runTaskCreate(title, opts) {
+  if (!title) {
+    render.err("Usage: claudemesh task create <title> [--assignee X] [--priority P]");
+    return EXIT.INVALID_ARGS;
+  }
+  const tags = opts.tags?.split(",").map((s) => s.trim()).filter(Boolean);
+  return await withMesh({ meshSlug: opts.mesh ?? null }, async (client) => {
+    const id = await client.createTask(title, opts.assignee, opts.priority, tags);
+    if (!id) {
+      render.err("create failed");
+      return EXIT.INTERNAL_ERROR;
+    }
+    if (opts.json)
+      emitJson({ id, title });
+    else
+      render.ok(`created ${dim(id.slice(0, 8))}`, title);
+    return EXIT.SUCCESS;
+  });
+}
+async function runClockSet(speed, opts) {
+  const s = parseFloat(speed);
+  if (!Number.isFinite(s) || s < 0) {
+    render.err("Usage: claudemesh clock set <speed>", "speed is a non-negative number, e.g. 1.0 = realtime, 0 = paused, 60 = 60× faster");
+    return EXIT.INVALID_ARGS;
+  }
+  return await withMesh({ meshSlug: opts.mesh ?? null }, async (client) => {
+    const r = await client.setClock(s);
+    if (!r) {
+      render.err("clock set failed");
+      return EXIT.INTERNAL_ERROR;
+    }
+    if (opts.json)
+      emitJson(r);
+    else
+      render.ok(`clock set to ${bold("x" + r.speed)}`);
+    return EXIT.SUCCESS;
+  });
+}
+async function runClockPause(opts) {
+  return await withMesh({ meshSlug: opts.mesh ?? null }, async (client) => {
+    const r = await client.pauseClock();
+    if (!r) {
+      render.err("pause failed");
+      return EXIT.INTERNAL_ERROR;
+    }
+    if (opts.json)
+      emitJson(r);
+    else
+      render.ok("clock paused");
+    return EXIT.SUCCESS;
+  });
+}
+async function runClockResume(opts) {
+  return await withMesh({ meshSlug: opts.mesh ?? null }, async (client) => {
+    const r = await client.resumeClock();
+    if (!r) {
+      render.err("resume failed");
+      return EXIT.INTERNAL_ERROR;
+    }
+    if (opts.json)
+      emitJson(r);
+    else
+      render.ok("clock resumed");
+    return EXIT.SUCCESS;
+  });
+}
+async function runMeshMcpList(opts) {
+  return await withMesh({ meshSlug: opts.mesh ?? null }, async (client) => {
+    const servers = await client.mcpList();
+    if (opts.json) {
+      emitJson(servers);
+      return EXIT.SUCCESS;
+    }
+    if (servers.length === 0) {
+      render.info(dim("(no mesh-MCP servers)"));
+      return EXIT.SUCCESS;
+    }
+    render.section(`mesh-MCP servers (${servers.length})`);
+    for (const s of servers) {
+      process.stdout.write(`  ${bold(s.name)} ${dim("· hosted by " + s.hostedBy)}
+`);
+      process.stdout.write(`    ${s.description}
+`);
+      if (s.tools.length)
+        process.stdout.write(`    ${dim("tools: " + s.tools.map((t) => t.name).join(", "))}
+`);
+    }
+    return EXIT.SUCCESS;
+  });
+}
+async function runMeshMcpCall(serverName, toolName, argsRaw, opts) {
+  if (!serverName || !toolName) {
+    render.err("Usage: claudemesh mesh-mcp call <server> <tool> [json-args]");
     return EXIT.INVALID_ARGS;
   }
-  const mesh = pickMesh2(opts.mesh);
-  if (!mesh) {
-    render.err("No matching mesh.");
-    return EXIT.NOT_FOUND;
-  }
-  const resolved = await resolvePeer(mesh, peer);
-  if (!resolved) {
-    render.err(`Peer "${peer}" not found on ${mesh}.`);
-    return EXIT.NOT_FOUND;
+  let args = {};
+  if (argsRaw) {
+    try {
+      args = JSON.parse(argsRaw);
+    } catch {
+      render.err("args must be JSON");
+      return EXIT.INVALID_ARGS;
+    }
   }
-  const store = readGrants();
-  const meshGrants = store[mesh] ?? {};
-  meshGrants[resolved.pubkey] = [];
-  store[mesh] = meshGrants;
-  writeGrants(store);
-  await syncToBroker(mesh, { [resolved.pubkey]: [] });
-  render.ok(`Blocked ${resolved.displayName} on ${mesh} (all capabilities revoked).`);
-  render.hint(`Undo with: claudemesh grant ${resolved.displayName} all --mesh ${mesh}`);
-  return EXIT.SUCCESS;
+  return await withMesh({ meshSlug: opts.mesh ?? null }, async (client) => {
+    const r = await client.mcpCall(serverName, toolName, args);
+    if (r.error) {
+      if (opts.json)
+        emitJson({ ok: false, error: r.error });
+      else
+        render.err(r.error);
+      return EXIT.INTERNAL_ERROR;
+    }
+    if (opts.json)
+      emitJson({ ok: true, result: r.result });
+    else
+      process.stdout.write(JSON.stringify(r.result, null, 2) + `
+`);
+    return EXIT.SUCCESS;
+  });
 }
-async function runGrants(opts = {}) {
-  const mesh = pickMesh2(opts.mesh);
-  if (!mesh) {
-    render.err("No matching mesh.");
-    return EXIT.NOT_FOUND;
-  }
-  const store = readGrants();
-  const meshGrants = store[mesh] ?? {};
-  if (opts.json) {
-    console.log(JSON.stringify({ schema_version: "1.0", mesh, grants: meshGrants }, null, 2));
+async function runMeshMcpCatalog(opts) {
+  return await withMesh({ meshSlug: opts.mesh ?? null }, async (client) => {
+    const cat = await client.mcpCatalog();
+    if (opts.json) {
+      emitJson(cat);
+      return EXIT.SUCCESS;
+    }
+    if (!cat || cat.length === 0) {
+      render.info(dim("(catalog empty)"));
+      return EXIT.SUCCESS;
+    }
+    render.section(`mesh-MCP catalog (${cat.length})`);
+    for (const c of cat) {
+      process.stdout.write(`  ${bold(String(c.name ?? "?"))} ${dim(String(c.status ?? ""))}
+`);
+      if (c.description)
+        process.stdout.write(`    ${String(c.description)}
+`);
+    }
     return EXIT.SUCCESS;
-  }
-  render.section(`grants on ${mesh}`);
-  const peerPubkeys = Object.keys(meshGrants);
-  if (peerPubkeys.length === 0) {
-    render.info("(no overrides — all peers use default caps: " + DEFAULT_CAPS.join(", ") + ")");
+  });
+}
+async function runFileList(opts) {
+  return await withMesh({ meshSlug: opts.mesh ?? null }, async (client) => {
+    const files = await client.listFiles(opts.query);
+    if (opts.json) {
+      emitJson(files);
+      return EXIT.SUCCESS;
+    }
+    if (files.length === 0) {
+      render.info(dim("(no files)"));
+      return EXIT.SUCCESS;
+    }
+    render.section(`mesh files (${files.length})`);
+    for (const f of files) {
+      const sizeKb = (f.size / 1024).toFixed(1);
+      process.stdout.write(`  ${bold(f.name)} ${dim(`· ${sizeKb} KB · by ${f.uploadedBy}`)}
+`);
+      if (f.tags.length)
+        process.stdout.write(`    ${dim("tags: " + f.tags.join(", "))}
+`);
+    }
     return EXIT.SUCCESS;
+  });
+}
+async function runFileStatus(id, opts) {
+  if (!id) {
+    render.err("Usage: claudemesh file status <file-id>");
+    return EXIT.INVALID_ARGS;
   }
-  await withMesh({ meshSlug: mesh }, async (client) => {
-    const peers = await client.listPeers();
-    const byPk = new Map(peers.map((p) => [p.pubkey, p.displayName]));
-    for (const [pk, caps] of Object.entries(meshGrants)) {
-      const name = byPk.get(pk) ?? `${pk.slice(0, 10)}…`;
-      render.kv([[name, caps.length ? caps.join(", ") : "(blocked)"]]);
+  return await withMesh({ meshSlug: opts.mesh ?? null }, async (client) => {
+    const accessors = await client.fileStatus(id);
+    if (opts.json) {
+      emitJson(accessors);
+      return EXIT.SUCCESS;
+    }
+    if (accessors.length === 0) {
+      render.info(dim("(no accesses recorded)"));
+      return EXIT.SUCCESS;
     }
+    render.section(`accesses for ${id.slice(0, 8)}`);
+    for (const a of accessors)
+      process.stdout.write(`  ${bold(a.peerName)} ${dim("· " + a.accessedAt)}
+`);
+    return EXIT.SUCCESS;
   });
-  return EXIT.SUCCESS;
 }
-function isAllowed(meshSlug, peerPubkey, cap) {
-  const store = readGrants();
-  const entry = store[meshSlug]?.[peerPubkey];
-  if (entry === undefined)
-    return DEFAULT_CAPS.includes(cap);
-  return entry.includes(cap);
+async function runFileDelete(id, opts) {
+  if (!id) {
+    render.err("Usage: claudemesh file delete <file-id>");
+    return EXIT.INVALID_ARGS;
+  }
+  return await withMesh({ meshSlug: opts.mesh ?? null }, async (client) => {
+    await client.deleteFile(id);
+    if (opts.json)
+      emitJson({ id, deleted: true });
+    else
+      render.ok(`deleted ${dim(id.slice(0, 8))}`);
+    return EXIT.SUCCESS;
+  });
 }
-var BROKER_HTTP7, ALL_CAPS, DEFAULT_CAPS, GRANT_FILE;
-var init_grants = __esm(() => {
-  init_facade();
+var init_platform_actions = __esm(() => {
   init_connect();
   init_render();
+  init_styles();
   init_exit_codes();
-  init_facade6();
-  init_facade3();
-  init_urls();
-  BROKER_HTTP7 = URLS.BROKER.replace("wss://", "https://").replace("ws://", "http://").replace("/ws", "");
-  ALL_CAPS = ["read", "dm", "broadcast", "state-read", "state-write", "file-read"];
-  DEFAULT_CAPS = ["read", "dm", "broadcast", "state-read"];
-  GRANT_FILE = join11(homedir10(), ".claudemesh", "grants.json");
 });
 
 // src/mcp/tools/definitions.ts
@@ -13299,41 +14061,65 @@ Mesh
   claudemesh delete [slug]         delete a mesh (alias: rm)
   claudemesh rename <slug> <name>  rename a mesh
   claudemesh share [email]         share mesh (invite link / send email)
-  claudemesh disconnect <peer>     soft disconnect (peer auto-reconnects)
-  claudemesh kick <peer>           end session (peer must manually rejoin)
-  claudemesh kick --stale 30m      kick peers idle > duration
-  claudemesh kick --all            kick everyone except yourself
-  claudemesh ban <peer>            kick + permanently revoke (can't rejoin)
-  claudemesh unban <peer>          lift a ban
-  claudemesh bans                  list banned members
-
-Messaging
-  claudemesh peers                 see who's online
-  claudemesh send <to> <msg>       send a message
-  claudemesh inbox                 drain pending messages
-  claudemesh msg-status <id>       check delivery status
+
+Peer (resource form, recommended)
+  claudemesh peer list             see who's online           (alias: peers)
+  claudemesh peer kick <p>         end session                (alias: kick)
+  claudemesh peer disconnect <p>   soft disconnect            (alias: disconnect)
+  claudemesh peer ban <p>          ban + revoke               (alias: ban)
+  claudemesh peer unban <p>        lift a ban                 (alias: unban)
+  claudemesh peer bans             list banned members        (alias: bans)
+  claudemesh peer verify [p]       safety numbers             (alias: verify)
+
+Message  (resource form)
+  claudemesh message send <to> <m> send a message            (alias: send)
+  claudemesh message inbox         drain pending              (alias: inbox)
+  claudemesh message status <id>   delivery status            (alias: msg-status)
+
+Memory  (resource form)
+  claudemesh memory remember <txt> store a memory            (alias: remember)
+  claudemesh memory recall <q>     search memories            (alias: recall)
+  claudemesh memory forget <id>    remove a memory            (alias: forget)
+
+Profile / presence  (resource form)
+  claudemesh profile               view or edit profile
+  claudemesh profile summary <txt> broadcast summary          (alias: summary)
+  claudemesh profile visible y|n   toggle visibility          (alias: visible)
+  claudemesh profile status set X  set status idle/working/dnd  (alias: status set)
+  claudemesh group join @<name>    join a group (--role X)
+  claudemesh group leave @<name>   leave a group
+
+Schedule  (resource form)
+  claudemesh schedule msg <m>      one-shot or recurring     (alias: remind)
+  claudemesh schedule list         list pending
+  claudemesh schedule cancel <id>  remove a scheduled item
+
+State / mesh introspection
   claudemesh state get|set|list    shared state
-  claudemesh remember <text>       store a memory
-  claudemesh recall <query>        search memories
-  claudemesh forget <id>           remove a memory
-  claudemesh remind ...            schedule a reminder
-  claudemesh profile               view or edit your profile
   claudemesh info                  mesh overview
   claudemesh stats                 per-peer activity counters
-  claudemesh clock                 mesh logical clock state
   claudemesh ping                  diagnostic round-trip
 
-Identity / presence
-  claudemesh status set <state>    set peer status (idle | working | dnd)
-  claudemesh summary <text>        broadcast 1-2 sentence work summary
-  claudemesh visible <true|false>  toggle peer visibility
-  claudemesh group join @<name>    join a group (--role X optional)
-  claudemesh group leave @<name>   leave a group
-
 Tasks
+  claudemesh task create <title>   create a new task [--assignee --priority --tags]
+  claudemesh task list             list tasks [--status --assignee]
   claudemesh task claim <id>       claim an unclaimed task
   claudemesh task complete <id>    mark task done [result]
 
+Platform
+  claudemesh vector store|search|delete|collections    embedding store
+  claudemesh graph query|execute "<cypher>"            graph operations
+  claudemesh context share|get|list                    work-context summaries
+  claudemesh stream create|publish|list                pub/sub event bus
+  claudemesh sql query|execute|schema                  per-mesh SQL
+  claudemesh skill list|get|remove                     mesh-published skills
+  claudemesh vault list|delete                         encrypted secrets
+  claudemesh watch list|remove                         URL change watchers
+  claudemesh webhook list|delete                       outbound HTTP triggers
+  claudemesh file list|status|delete                   shared mesh files
+  claudemesh mesh-mcp list|call|catalog                deployed mesh-MCP servers
+  claudemesh clock set|pause|resume                    mesh logical clock
+
 Auth
   claudemesh login                 sign in (browser or paste token)
   claudemesh register              create account + sign in
@@ -13521,12 +14307,12 @@ async function main() {
     }
     case "remember": {
       const { remember: remember2 } = await Promise.resolve().then(() => (init_remember(), exports_remember));
-      process.exit(await remember2(positionals.join(" "), { tags: flags.tags, json: !!flags.json }));
+      process.exit(await remember2(positionals.join(" "), { mesh: flags.mesh, tags: flags.tags, json: !!flags.json }));
       break;
     }
     case "recall": {
       const { recall: recall2 } = await Promise.resolve().then(() => (init_recall(), exports_recall));
-      process.exit(await recall2(positionals.join(" "), { json: !!flags.json }));
+      process.exit(await recall2(positionals.join(" "), { mesh: flags.mesh, json: !!flags.json }));
       break;
     }
     case "forget": {
@@ -13539,11 +14325,6 @@ async function main() {
       await runRemind2({ mesh: flags.mesh }, positionals);
       break;
     }
-    case "profile": {
-      const { runProfile: runProfile2 } = await Promise.resolve().then(() => (init_profile(), exports_profile));
-      await runProfile2(flags);
-      break;
-    }
     case "summary": {
       const { runSummary: runSummary2 } = await Promise.resolve().then(() => (init_broker_actions(), exports_broker_actions));
       process.exit(await runSummary2(positionals.join(" "), { mesh: flags.mesh, json: !!flags.json }));
@@ -13573,11 +14354,6 @@ async function main() {
       process.exit(await runMsgStatus2(positionals[0], { mesh: flags.mesh, json: !!flags.json }));
       break;
     }
-    case "clock": {
-      const { runClock: runClock2 } = await Promise.resolve().then(() => (init_broker_actions(), exports_broker_actions));
-      process.exit(await runClock2({ mesh: flags.mesh, json: !!flags.json }));
-      break;
-    }
     case "stats": {
       const { runStats: runStats2 } = await Promise.resolve().then(() => (init_broker_actions(), exports_broker_actions));
       process.exit(await runStats2({ mesh: flags.mesh, json: !!flags.json }));
@@ -13588,20 +14364,6 @@ async function main() {
       process.exit(await runPing2({ mesh: flags.mesh, json: !!flags.json }));
       break;
     }
-    case "task": {
-      const sub = positionals[0];
-      if (sub === "claim") {
-        const { runTaskClaim: runTaskClaim2 } = await Promise.resolve().then(() => (init_broker_actions(), exports_broker_actions));
-        process.exit(await runTaskClaim2(positionals[1], { mesh: flags.mesh, json: !!flags.json }));
-      } else if (sub === "complete") {
-        const { runTaskComplete: runTaskComplete2 } = await Promise.resolve().then(() => (init_broker_actions(), exports_broker_actions));
-        process.exit(await runTaskComplete2(positionals[1], positionals.slice(2).join(" ") || undefined, { mesh: flags.mesh, json: !!flags.json }));
-      } else {
-        console.error("Usage: claudemesh task <claim|complete> <id> [result]");
-        process.exit(EXIT.INVALID_ARGS);
-      }
-      break;
-    }
     case "login": {
       const { login: login2 } = await Promise.resolve().then(() => (init_login(), exports_login));
       process.exit(await login2());
@@ -13713,6 +14475,340 @@ async function main() {
       process.exit(await runGrants2({ mesh: flags.mesh, json: !!flags.json }));
       break;
     }
+    case "peer": {
+      const sub = positionals[0];
+      const f = { mesh: flags.mesh, json: flags.json };
+      const id = positionals[1] ?? "";
+      if (sub === "list") {
+        const { runPeers: runPeers2 } = await Promise.resolve().then(() => (init_peers(), exports_peers));
+        await runPeers2(f);
+      } else if (sub === "kick") {
+        const { runKick: runKick2 } = await Promise.resolve().then(() => (init_kick(), exports_kick));
+        process.exit(await runKick2(id, { mesh: flags.mesh, stale: flags.stale, all: !!flags.all }));
+      } else if (sub === "disconnect") {
+        const { runDisconnect: runDisconnect2 } = await Promise.resolve().then(() => (init_kick(), exports_kick));
+        process.exit(await runDisconnect2(id, { mesh: flags.mesh, stale: flags.stale, all: !!flags.all }));
+      } else if (sub === "ban") {
+        const { runBan: runBan2 } = await Promise.resolve().then(() => (init_ban(), exports_ban));
+        process.exit(await runBan2(id, { mesh: flags.mesh }));
+      } else if (sub === "unban") {
+        const { runUnban: runUnban2 } = await Promise.resolve().then(() => (init_ban(), exports_ban));
+        process.exit(await runUnban2(id, { mesh: flags.mesh }));
+      } else if (sub === "bans") {
+        const { runBans: runBans2 } = await Promise.resolve().then(() => (init_ban(), exports_ban));
+        process.exit(await runBans2({ mesh: flags.mesh, json: !!flags.json }));
+      } else if (sub === "verify") {
+        const { runVerify: runVerify2 } = await Promise.resolve().then(() => (init_verify(), exports_verify));
+        process.exit(await runVerify2(id || undefined, { mesh: flags.mesh, json: !!flags.json }));
+      } else {
+        console.error("Usage: claudemesh peer <list|kick|disconnect|ban|unban|bans|verify>");
+        process.exit(EXIT.INVALID_ARGS);
+      }
+      break;
+    }
+    case "message": {
+      const sub = positionals[0];
+      if (sub === "send") {
+        const { runSend: runSend2 } = await Promise.resolve().then(() => (init_send(), exports_send));
+        await runSend2({ mesh: flags.mesh, priority: flags.priority, json: !!flags.json }, positionals[1] ?? "", positionals.slice(2).join(" "));
+      } else if (sub === "inbox") {
+        const { runInbox: runInbox2 } = await Promise.resolve().then(() => (init_inbox(), exports_inbox));
+        await runInbox2({ json: !!flags.json });
+      } else if (sub === "status") {
+        const { runMsgStatus: runMsgStatus2 } = await Promise.resolve().then(() => (init_broker_actions(), exports_broker_actions));
+        process.exit(await runMsgStatus2(positionals[1], { mesh: flags.mesh, json: !!flags.json }));
+      } else {
+        console.error("Usage: claudemesh message <send|inbox|status>");
+        process.exit(EXIT.INVALID_ARGS);
+      }
+      break;
+    }
+    case "memory": {
+      const sub = positionals[0];
+      const f = { mesh: flags.mesh, json: !!flags.json };
+      if (sub === "remember") {
+        const { remember: remember2 } = await Promise.resolve().then(() => (init_remember(), exports_remember));
+        process.exit(await remember2(positionals.slice(1).join(" "), { ...f, tags: flags.tags }));
+      } else if (sub === "recall") {
+        const { recall: recall2 } = await Promise.resolve().then(() => (init_recall(), exports_recall));
+        process.exit(await recall2(positionals.slice(1).join(" "), f));
+      } else if (sub === "forget") {
+        const { runForget: runForget2 } = await Promise.resolve().then(() => (init_broker_actions(), exports_broker_actions));
+        process.exit(await runForget2(positionals[1], f));
+      } else {
+        console.error("Usage: claudemesh memory <remember|recall|forget>");
+        process.exit(EXIT.INVALID_ARGS);
+      }
+      break;
+    }
+    case "profile": {
+      const sub = positionals[0];
+      if (!sub) {
+        const { runProfile: runProfile2 } = await Promise.resolve().then(() => (init_profile(), exports_profile));
+        await runProfile2(flags);
+      } else if (sub === "summary") {
+        const { runSummary: runSummary2 } = await Promise.resolve().then(() => (init_broker_actions(), exports_broker_actions));
+        process.exit(await runSummary2(positionals.slice(1).join(" "), { mesh: flags.mesh, json: !!flags.json }));
+      } else if (sub === "visible") {
+        const { runVisible: runVisible2 } = await Promise.resolve().then(() => (init_broker_actions(), exports_broker_actions));
+        process.exit(await runVisible2(positionals[1], { mesh: flags.mesh, json: !!flags.json }));
+      } else if (sub === "status") {
+        if (positionals[1] === "set") {
+          const { runStatusSet: runStatusSet2 } = await Promise.resolve().then(() => (init_broker_actions(), exports_broker_actions));
+          process.exit(await runStatusSet2(positionals[2] ?? "", { mesh: flags.mesh, json: !!flags.json }));
+        } else {
+          const { runStatus: runStatus2 } = await Promise.resolve().then(() => (init_status(), exports_status));
+          await runStatus2();
+        }
+      } else {
+        console.error("Usage: claudemesh profile [summary|visible|status]");
+        process.exit(EXIT.INVALID_ARGS);
+      }
+      break;
+    }
+    case "schedule": {
+      const sub = positionals[0];
+      if (sub === "msg" || sub === "remind" || sub === undefined || sub === "list" || sub === "cancel") {
+        const { runRemind: runRemind2 } = await Promise.resolve().then(() => (init_remind(), exports_remind));
+        const remindPositionals = sub === "msg" ? positionals.slice(1) : sub === "remind" ? positionals.slice(1) : positionals;
+        await runRemind2({ mesh: flags.mesh, in: flags.in, at: flags.at, cron: flags.cron, to: flags.to, json: !!flags.json }, remindPositionals);
+      } else if (sub === "webhook" || sub === "tool") {
+        console.error(`  schedule ${sub} arrives in a later release — broker primitive not yet shipped`);
+        process.exit(EXIT.INVALID_ARGS);
+      } else {
+        console.error("Usage: claudemesh schedule <msg|list|cancel>");
+        process.exit(EXIT.INVALID_ARGS);
+      }
+      break;
+    }
+    case "vector": {
+      const sub = positionals[0];
+      const f = { mesh: flags.mesh, json: !!flags.json };
+      if (sub === "store") {
+        const { runVectorStore: runVectorStore2 } = await Promise.resolve().then(() => (init_platform_actions(), exports_platform_actions));
+        process.exit(await runVectorStore2(positionals[1] ?? "", positionals.slice(2).join(" "), { ...f, metadata: flags.metadata }));
+      } else if (sub === "search") {
+        const { runVectorSearch: runVectorSearch2 } = await Promise.resolve().then(() => (init_platform_actions(), exports_platform_actions));
+        process.exit(await runVectorSearch2(positionals[1] ?? "", positionals.slice(2).join(" "), { ...f, limit: flags.limit }));
+      } else if (sub === "delete") {
+        const { runVectorDelete: runVectorDelete2 } = await Promise.resolve().then(() => (init_platform_actions(), exports_platform_actions));
+        process.exit(await runVectorDelete2(positionals[1] ?? "", positionals[2] ?? "", f));
+      } else if (sub === "collections") {
+        const { runVectorCollections: runVectorCollections2 } = await Promise.resolve().then(() => (init_platform_actions(), exports_platform_actions));
+        process.exit(await runVectorCollections2(f));
+      } else {
+        console.error("Usage: claudemesh vector <store|search|delete|collections>");
+        process.exit(EXIT.INVALID_ARGS);
+      }
+      break;
+    }
+    case "graph": {
+      const sub = positionals[0];
+      const f = { mesh: flags.mesh, json: !!flags.json };
+      if (sub === "query") {
+        const { runGraphQuery: runGraphQuery2 } = await Promise.resolve().then(() => (init_platform_actions(), exports_platform_actions));
+        process.exit(await runGraphQuery2(positionals.slice(1).join(" "), f));
+      } else if (sub === "execute") {
+        const { runGraphExecute: runGraphExecute2 } = await Promise.resolve().then(() => (init_platform_actions(), exports_platform_actions));
+        process.exit(await runGraphExecute2(positionals.slice(1).join(" "), f));
+      } else {
+        console.error('Usage: claudemesh graph <query|execute> "<cypher>"');
+        process.exit(EXIT.INVALID_ARGS);
+      }
+      break;
+    }
+    case "context": {
+      const sub = positionals[0];
+      const f = { mesh: flags.mesh, json: !!flags.json };
+      if (sub === "share") {
+        const { runContextShare: runContextShare2 } = await Promise.resolve().then(() => (init_platform_actions(), exports_platform_actions));
+        process.exit(await runContextShare2(positionals.slice(1).join(" "), { ...f, files: flags.files, findings: flags.findings, tags: flags.tags }));
+      } else if (sub === "get") {
+        const { runContextGet: runContextGet2 } = await Promise.resolve().then(() => (init_platform_actions(), exports_platform_actions));
+        process.exit(await runContextGet2(positionals.slice(1).join(" "), f));
+      } else if (sub === "list") {
+        const { runContextList: runContextList2 } = await Promise.resolve().then(() => (init_platform_actions(), exports_platform_actions));
+        process.exit(await runContextList2(f));
+      } else {
+        console.error("Usage: claudemesh context <share|get|list>");
+        process.exit(EXIT.INVALID_ARGS);
+      }
+      break;
+    }
+    case "stream": {
+      const sub = positionals[0];
+      const f = { mesh: flags.mesh, json: !!flags.json };
+      if (sub === "create") {
+        const { runStreamCreate: runStreamCreate2 } = await Promise.resolve().then(() => (init_platform_actions(), exports_platform_actions));
+        process.exit(await runStreamCreate2(positionals[1] ?? "", f));
+      } else if (sub === "publish") {
+        const { runStreamPublish: runStreamPublish2 } = await Promise.resolve().then(() => (init_platform_actions(), exports_platform_actions));
+        process.exit(await runStreamPublish2(positionals[1] ?? "", positionals.slice(2).join(" "), f));
+      } else if (sub === "list") {
+        const { runStreamList: runStreamList2 } = await Promise.resolve().then(() => (init_platform_actions(), exports_platform_actions));
+        process.exit(await runStreamList2(f));
+      } else {
+        console.error("Usage: claudemesh stream <create|publish|list>");
+        process.exit(EXIT.INVALID_ARGS);
+      }
+      break;
+    }
+    case "sql": {
+      const sub = positionals[0];
+      const f = { mesh: flags.mesh, json: !!flags.json };
+      if (sub === "query") {
+        const { runSqlQuery: runSqlQuery2 } = await Promise.resolve().then(() => (init_platform_actions(), exports_platform_actions));
+        process.exit(await runSqlQuery2(positionals.slice(1).join(" "), f));
+      } else if (sub === "execute") {
+        const { runSqlExecute: runSqlExecute2 } = await Promise.resolve().then(() => (init_platform_actions(), exports_platform_actions));
+        process.exit(await runSqlExecute2(positionals.slice(1).join(" "), f));
+      } else if (sub === "schema") {
+        const { runSqlSchema: runSqlSchema2 } = await Promise.resolve().then(() => (init_platform_actions(), exports_platform_actions));
+        process.exit(await runSqlSchema2(f));
+      } else {
+        console.error("Usage: claudemesh sql <query|execute|schema>");
+        process.exit(EXIT.INVALID_ARGS);
+      }
+      break;
+    }
+    case "skill": {
+      const sub = positionals[0];
+      const f = { mesh: flags.mesh, json: !!flags.json };
+      if (sub === "list") {
+        const { runSkillList: runSkillList2 } = await Promise.resolve().then(() => (init_platform_actions(), exports_platform_actions));
+        process.exit(await runSkillList2({ ...f, query: positionals[1] }));
+      } else if (sub === "get") {
+        const { runSkillGet: runSkillGet2 } = await Promise.resolve().then(() => (init_platform_actions(), exports_platform_actions));
+        process.exit(await runSkillGet2(positionals[1] ?? "", f));
+      } else if (sub === "remove") {
+        const { runSkillRemove: runSkillRemove2 } = await Promise.resolve().then(() => (init_platform_actions(), exports_platform_actions));
+        process.exit(await runSkillRemove2(positionals[1] ?? "", f));
+      } else {
+        console.error("Usage: claudemesh skill <list|get|remove>");
+        process.exit(EXIT.INVALID_ARGS);
+      }
+      break;
+    }
+    case "vault": {
+      const sub = positionals[0];
+      const f = { mesh: flags.mesh, json: !!flags.json };
+      if (sub === "list") {
+        const { runVaultList: runVaultList2 } = await Promise.resolve().then(() => (init_platform_actions(), exports_platform_actions));
+        process.exit(await runVaultList2(f));
+      } else if (sub === "delete") {
+        const { runVaultDelete: runVaultDelete2 } = await Promise.resolve().then(() => (init_platform_actions(), exports_platform_actions));
+        process.exit(await runVaultDelete2(positionals[1] ?? "", f));
+      } else {
+        console.error("Usage: claudemesh vault <list|delete>  (set/get currently via MCP — needs crypto)");
+        process.exit(EXIT.INVALID_ARGS);
+      }
+      break;
+    }
+    case "watch": {
+      const sub = positionals[0];
+      const f = { mesh: flags.mesh, json: !!flags.json };
+      if (sub === "list") {
+        const { runWatchList: runWatchList2 } = await Promise.resolve().then(() => (init_platform_actions(), exports_platform_actions));
+        process.exit(await runWatchList2(f));
+      } else if (sub === "remove") {
+        const { runUnwatch: runUnwatch2 } = await Promise.resolve().then(() => (init_platform_actions(), exports_platform_actions));
+        process.exit(await runUnwatch2(positionals[1] ?? "", f));
+      } else {
+        console.error("Usage: claudemesh watch <list|remove>");
+        process.exit(EXIT.INVALID_ARGS);
+      }
+      break;
+    }
+    case "webhook": {
+      const sub = positionals[0];
+      const f = { mesh: flags.mesh, json: !!flags.json };
+      if (sub === "list") {
+        const { runWebhookList: runWebhookList2 } = await Promise.resolve().then(() => (init_platform_actions(), exports_platform_actions));
+        process.exit(await runWebhookList2(f));
+      } else if (sub === "delete") {
+        const { runWebhookDelete: runWebhookDelete2 } = await Promise.resolve().then(() => (init_platform_actions(), exports_platform_actions));
+        process.exit(await runWebhookDelete2(positionals[1] ?? "", f));
+      } else {
+        console.error("Usage: claudemesh webhook <list|delete>");
+        process.exit(EXIT.INVALID_ARGS);
+      }
+      break;
+    }
+    case "file": {
+      const sub = positionals[0];
+      const f = { mesh: flags.mesh, json: !!flags.json };
+      if (sub === "list") {
+        const { runFileList: runFileList2 } = await Promise.resolve().then(() => (init_platform_actions(), exports_platform_actions));
+        process.exit(await runFileList2({ ...f, query: positionals[1] }));
+      } else if (sub === "status") {
+        const { runFileStatus: runFileStatus2 } = await Promise.resolve().then(() => (init_platform_actions(), exports_platform_actions));
+        process.exit(await runFileStatus2(positionals[1] ?? "", f));
+      } else if (sub === "delete") {
+        const { runFileDelete: runFileDelete2 } = await Promise.resolve().then(() => (init_platform_actions(), exports_platform_actions));
+        process.exit(await runFileDelete2(positionals[1] ?? "", f));
+      } else {
+        console.error("Usage: claudemesh file <list|status|delete>");
+        process.exit(EXIT.INVALID_ARGS);
+      }
+      break;
+    }
+    case "mesh-mcp": {
+      const sub = positionals[0];
+      const f = { mesh: flags.mesh, json: !!flags.json };
+      if (sub === "list") {
+        const { runMeshMcpList: runMeshMcpList2 } = await Promise.resolve().then(() => (init_platform_actions(), exports_platform_actions));
+        process.exit(await runMeshMcpList2(f));
+      } else if (sub === "call") {
+        const { runMeshMcpCall: runMeshMcpCall2 } = await Promise.resolve().then(() => (init_platform_actions(), exports_platform_actions));
+        process.exit(await runMeshMcpCall2(positionals[1] ?? "", positionals[2] ?? "", positionals.slice(3).join(" "), f));
+      } else if (sub === "catalog") {
+        const { runMeshMcpCatalog: runMeshMcpCatalog2 } = await Promise.resolve().then(() => (init_platform_actions(), exports_platform_actions));
+        process.exit(await runMeshMcpCatalog2(f));
+      } else {
+        console.error("Usage: claudemesh mesh-mcp <list|call|catalog>");
+        process.exit(EXIT.INVALID_ARGS);
+      }
+      break;
+    }
+    case "clock": {
+      const sub = positionals[0];
+      const f = { mesh: flags.mesh, json: !!flags.json };
+      if (sub === "set") {
+        const { runClockSet: runClockSet2 } = await Promise.resolve().then(() => (init_platform_actions(), exports_platform_actions));
+        process.exit(await runClockSet2(positionals[1] ?? "", f));
+      } else if (sub === "pause") {
+        const { runClockPause: runClockPause2 } = await Promise.resolve().then(() => (init_platform_actions(), exports_platform_actions));
+        process.exit(await runClockPause2(f));
+      } else if (sub === "resume") {
+        const { runClockResume: runClockResume2 } = await Promise.resolve().then(() => (init_platform_actions(), exports_platform_actions));
+        process.exit(await runClockResume2(f));
+      } else {
+        const { runClock: runClock2 } = await Promise.resolve().then(() => (init_broker_actions(), exports_broker_actions));
+        process.exit(await runClock2(f));
+      }
+      break;
+    }
+    case "task": {
+      const sub = positionals[0];
+      const f = { mesh: flags.mesh, json: !!flags.json };
+      if (sub === "claim") {
+        const { runTaskClaim: runTaskClaim2 } = await Promise.resolve().then(() => (init_broker_actions(), exports_broker_actions));
+        process.exit(await runTaskClaim2(positionals[1], f));
+      } else if (sub === "complete") {
+        const { runTaskComplete: runTaskComplete2 } = await Promise.resolve().then(() => (init_broker_actions(), exports_broker_actions));
+        process.exit(await runTaskComplete2(positionals[1], positionals.slice(2).join(" ") || undefined, f));
+      } else if (sub === "list") {
+        const { runTaskList: runTaskList2 } = await Promise.resolve().then(() => (init_platform_actions(), exports_platform_actions));
+        process.exit(await runTaskList2({ ...f, status: flags.status, assignee: flags.assignee }));
+      } else if (sub === "create") {
+        const { runTaskCreate: runTaskCreate2 } = await Promise.resolve().then(() => (init_platform_actions(), exports_platform_actions));
+        process.exit(await runTaskCreate2(positionals.slice(1).join(" "), { ...f, assignee: flags.assignee, priority: flags.priority, tags: flags.tags }));
+      } else {
+        console.error("Usage: claudemesh task <create|list|claim|complete>");
+        process.exit(EXIT.INVALID_ARGS);
+      }
+      break;
+    }
     case "mcp": {
       const { runMcp: runMcp2 } = await Promise.resolve().then(() => (init_mcp(), exports_mcp));
       await runMcp2();
@@ -13740,4 +14836,4 @@ main().catch((err) => {
   process.exit(EXIT.INTERNAL_ERROR);
 });
 
-//# debugId=E126BD4968D2FCDF64756E2164756E21
+//# debugId=4E4265490A3D56F164756E2164756E21