claudemesh-cli 1.2.0 → 1.3.0

package/dist/entrypoints/cli.js

@@ -88,7 +88,7 @@ __export(exports_urls, {
   VERSION: () => VERSION,
   URLS: () => URLS
 });
-var URLS, VERSION = "1.2.0", env;
+var URLS, VERSION = "1.3.0", env;
 var init_urls = __esm(() => {
   URLS = {
     BROKER: process.env.CLAUDEMESH_BROKER_URL ?? "wss://ic.claudemesh.com/ws",
@@ -7570,16 +7570,65 @@ function bunAvailable() {
   const res = platform5() === "win32" ? spawnSync3("where", ["bun"]) : spawnSync3("sh", ["-c", "command -v bun"]);
   return res.status === 0;
 }
+function isBundledFile(p) {
+  return /[/\\]dist[/\\]/.test(p);
+}
 function resolveEntry() {
   const here = fileURLToPath(import.meta.url);
-  if (here.endsWith("/dist/index.js") || here.endsWith("\\dist\\index.js")) {
+  if (isBundledFile(here))
     return here;
-  }
   return resolve(dirname2(here), "..", "index.ts");
 }
+function resolveBundledSkillsDir() {
+  const here = fileURLToPath(import.meta.url);
+  const pkgRoot = resolve(dirname2(here), "..", "..");
+  const skillsDir = join5(pkgRoot, "skills");
+  if (existsSync6(skillsDir))
+    return skillsDir;
+  return null;
+}
+function installSkills() {
+  const src = resolveBundledSkillsDir();
+  if (!src)
+    return [];
+  const fs = __require("node:fs");
+  const installed = [];
+  for (const entry of fs.readdirSync(src, { withFileTypes: true })) {
+    if (!entry.isDirectory())
+      continue;
+    const srcDir = join5(src, entry.name);
+    const dstDir = join5(CLAUDE_SKILLS_ROOT, entry.name);
+    mkdirSync3(dstDir, { recursive: true });
+    for (const file of fs.readdirSync(srcDir, { withFileTypes: true })) {
+      if (!file.isFile())
+        continue;
+      copyFileSync(join5(srcDir, file.name), join5(dstDir, file.name));
+    }
+    installed.push(entry.name);
+  }
+  return installed;
+}
+function uninstallSkills() {
+  const src = resolveBundledSkillsDir();
+  if (!src)
+    return [];
+  const fs = __require("node:fs");
+  const removed = [];
+  for (const entry of fs.readdirSync(src, { withFileTypes: true })) {
+    if (!entry.isDirectory())
+      continue;
+    const dstDir = join5(CLAUDE_SKILLS_ROOT, entry.name);
+    if (existsSync6(dstDir)) {
+      try {
+        fs.rmSync(dstDir, { recursive: true, force: true });
+        removed.push(entry.name);
+      } catch {}
+    }
+  }
+  return removed;
+}
 function buildMcpEntry(entryPath) {
-  const isBundled = entryPath.endsWith("/dist/index.js") || entryPath.endsWith("\\dist\\index.js");
-  if (isBundled) {
+  if (isBundledFile(entryPath)) {
     return {
       command: "claudemesh",
       args: ["mcp"]
@@ -7696,11 +7745,12 @@ function installStatusLine() {
 }
 function runInstall(args = []) {
   const skipHooks = args.includes("--no-hooks");
+  const skipSkill = args.includes("--no-skill");
   const wantStatusLine = args.includes("--status-line");
   render.section("claudemesh install");
   const entry = resolveEntry();
-  const isBundled = entry.endsWith("/dist/index.js") || entry.endsWith("\\dist\\index.js");
-  if (!isBundled && !bunAvailable()) {
+  const bundled = isBundledFile(entry);
+  if (!bundled && !bunAvailable()) {
     render.err("`bun` is not on PATH.", "Install Bun first: https://bun.com");
     process.exit(1);
   }
@@ -7750,6 +7800,19 @@ function runInstall(args = []) {
   } else {
     render.info(dim("· Hooks skipped (--no-hooks)"));
   }
+  if (!skipSkill) {
+    try {
+      const installed = installSkills();
+      if (installed.length > 0) {
+        render.ok(`Claude skill${installed.length === 1 ? "" : "s"} installed`, installed.join(", "));
+        render.info(dim(`  ${join5(CLAUDE_SKILLS_ROOT, installed[0])}/SKILL.md`));
+      }
+    } catch (e) {
+      render.warn(`skill install failed: ${e instanceof Error ? e.message : String(e)}`);
+    }
+  } else {
+    render.info(dim("· Skill install skipped (--no-skill)"));
+  }
   if (wantStatusLine) {
     try {
       const { installed } = installStatusLine();
@@ -7812,16 +7875,27 @@ function runUninstall() {
   } catch (e) {
     render.warn(`hook removal failed: ${e instanceof Error ? e.message : String(e)}`);
   }
+  try {
+    const removed = uninstallSkills();
+    if (removed.length > 0) {
+      render.ok(`Skill${removed.length === 1 ? "" : "s"} removed`, removed.join(", "));
+    } else {
+      render.info(dim("· No claudemesh skills to remove"));
+    }
+  } catch (e) {
+    render.warn(`skill removal failed: ${e instanceof Error ? e.message : String(e)}`);
+  }
   render.blank();
   render.info("Restart Claude Code to drop the MCP connection + hooks.");
 }
-var MCP_NAME = "claudemesh", CLAUDE_CONFIG, CLAUDE_SETTINGS, HOOK_COMMAND_STOP = "claudemesh hook idle", HOOK_COMMAND_USER_PROMPT = "claudemesh hook working", HOOK_MARKER = "claudemesh hook ", CLAUDEMESH_TOOLS;
+var MCP_NAME = "claudemesh", CLAUDE_CONFIG, CLAUDE_SETTINGS, HOOK_COMMAND_STOP = "claudemesh hook idle", HOOK_COMMAND_USER_PROMPT = "claudemesh hook working", HOOK_MARKER = "claudemesh hook ", CLAUDE_SKILLS_ROOT, CLAUDEMESH_TOOLS;
 var init_install = __esm(() => {
   init_facade();
   init_render();
   init_styles();
   CLAUDE_CONFIG = join5(homedir5(), ".claude.json");
   CLAUDE_SETTINGS = join5(homedir5(), ".claude", "settings.json");
+  CLAUDE_SKILLS_ROOT = join5(homedir5(), ".claude", "skills");
   CLAUDEMESH_TOOLS = [
     "mcp__claudemesh__cancel_scheduled",
     "mcp__claudemesh__check_messages",
@@ -7876,7 +7950,16 @@ var exports_uninstall = {};
 __export(exports_uninstall, {
   uninstall: () => uninstall
 });
-import { readFileSync as readFileSync5, writeFileSync as writeFileSync6, existsSync as existsSync7 } from "node:fs";
+import { readFileSync as readFileSync5, writeFileSync as writeFileSync6, existsSync as existsSync7, rmSync as rmSync2, readdirSync as readdirSync2 } from "node:fs";
+import { join as join6, dirname as dirname3 } from "node:path";
+import { homedir as homedir6 } from "node:os";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+function bundledSkillsDir() {
+  const here = fileURLToPath2(import.meta.url);
+  const pkgRoot = join6(dirname3(here), "..", "..");
+  const skillsDir = join6(pkgRoot, "skills");
+  return existsSync7(skillsDir) ? skillsDir : null;
+}
 async function uninstall() {
   let removed = 0;
   if (existsSync7(PATHS.CLAUDE_JSON)) {
@@ -7924,16 +8007,39 @@ async function uninstall() {
       }
     } catch {}
   }
+  const src = bundledSkillsDir();
+  if (src) {
+    const removedSkills = [];
+    try {
+      for (const entry of readdirSync2(src, { withFileTypes: true })) {
+        if (!entry.isDirectory())
+          continue;
+        const dst = join6(CLAUDE_SKILLS_ROOT2, entry.name);
+        if (existsSync7(dst)) {
+          try {
+            rmSync2(dst, { recursive: true, force: true });
+            removedSkills.push(entry.name);
+          } catch {}
+        }
+      }
+      if (removedSkills.length > 0) {
+        render.ok(`removed Claude skill${removedSkills.length === 1 ? "" : "s"}`, removedSkills.join(", "));
+        removed++;
+      }
+    } catch {}
+  }
   if (removed === 0) {
     render.info(dim("Nothing to remove — claudemesh was not installed."));
   }
   return EXIT.SUCCESS;
 }
+var CLAUDE_SKILLS_ROOT2;
 var init_uninstall = __esm(() => {
   init_paths();
   init_render();
   init_styles();
   init_exit_codes();
+  CLAUDE_SKILLS_ROOT2 = join6(homedir6(), ".claude", "skills");
 });
 
 // src/commands/doctor.ts
@@ -7942,8 +8048,8 @@ __export(exports_doctor, {
   runDoctor: () => runDoctor
 });
 import { existsSync as existsSync8, readFileSync as readFileSync6, statSync as statSync2 } from "node:fs";
-import { homedir as homedir6, platform as platform6 } from "node:os";
-import { join as join6 } from "node:path";
+import { homedir as homedir7, platform as platform6 } from "node:os";
+import { join as join7 } from "node:path";
 import { spawnSync as spawnSync4 } from "node:child_process";
 function checkNode() {
   const major = Number(process.versions.node.split(".")[0]);
@@ -7967,7 +8073,7 @@ function checkClaudeOnPath() {
   };
 }
 function checkMcpRegistered() {
-  const claudeConfig = join6(homedir6(), ".claude.json");
+  const claudeConfig = join7(homedir7(), ".claude.json");
   if (!existsSync8(claudeConfig)) {
     return {
       name: "claudemesh MCP registered in ~/.claude.json",
@@ -7993,7 +8099,7 @@ function checkMcpRegistered() {
   }
 }
 function checkHooksRegistered() {
-  const settings = join6(homedir6(), ".claude", "settings.json");
+  const settings = join7(homedir7(), ".claude", "settings.json");
   if (!existsSync8(settings)) {
     return {
       name: "Status hooks registered in ~/.claude/settings.json",
@@ -8927,18 +9033,18 @@ var exports_url_handler = {};
 __export(exports_url_handler, {
   runUrlHandler: () => runUrlHandler
 });
-import { platform as platform7, homedir as homedir7 } from "node:os";
-import { existsSync as existsSync14, mkdirSync as mkdirSync4, writeFileSync as writeFileSync7, rmSync as rmSync2, chmodSync as chmodSync4 } from "node:fs";
-import { join as join7 } from "node:path";
+import { platform as platform7, homedir as homedir8 } from "node:os";
+import { existsSync as existsSync14, mkdirSync as mkdirSync4, writeFileSync as writeFileSync7, rmSync as rmSync3, chmodSync as chmodSync4 } from "node:fs";
+import { join as join8 } from "node:path";
 import { spawnSync as spawnSync5 } from "node:child_process";
 function resolveClaudemeshBin() {
   return process.argv[1] ?? "claudemesh";
 }
 function installDarwin() {
   const binPath = resolveClaudemeshBin();
-  const appDir = join7(homedir7(), "Library", "Application Support", "claudemesh", "ClaudemeshHandler.app");
-  const contents = join7(appDir, "Contents");
-  const macOS = join7(contents, "MacOS");
+  const appDir = join8(homedir8(), "Library", "Application Support", "claudemesh", "ClaudemeshHandler.app");
+  const contents = join8(appDir, "Contents");
+  const macOS = join8(contents, "MacOS");
   mkdirSync4(macOS, { recursive: true });
   const plist = `<?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
@@ -8962,7 +9068,7 @@ function installDarwin() {
   </array>
 </dict>
 </plist>`;
-  writeFileSync7(join7(contents, "Info.plist"), plist);
+  writeFileSync7(join8(contents, "Info.plist"), plist);
   const shim = `#!/bin/sh
 URL="$1"
 CODE=\${URL#claudemesh://}
@@ -8976,7 +9082,7 @@ tell application "Terminal"
 end tell
 EOF
 `;
-  const shimPath = join7(macOS, "open-url");
+  const shimPath = join8(macOS, "open-url");
   writeFileSync7(shimPath, shim);
   chmodSync4(shimPath, 493);
   const lsreg = spawnSync5("/System/Library/Frameworks/CoreServices.framework/Frameworks/LaunchServices.framework/Support/lsregister", ["-f", appDir], { encoding: "utf-8" });
@@ -8988,7 +9094,7 @@ EOF
 }
 function installLinux() {
   const binPath = resolveClaudemeshBin();
-  const appsDir = join7(homedir7(), ".local", "share", "applications");
+  const appsDir = join8(homedir8(), ".local", "share", "applications");
   mkdirSync4(appsDir, { recursive: true });
   const desktop = `[Desktop Entry]
 Type=Application
@@ -9000,7 +9106,7 @@ Terminal=true
 MimeType=x-scheme-handler/claudemesh;
 NoDisplay=true
 `;
-  const desktopPath = join7(appsDir, "claudemesh.desktop");
+  const desktopPath = join8(appsDir, "claudemesh.desktop");
   writeFileSync7(desktopPath, desktop);
   const xdg1 = spawnSync5("xdg-mime", ["default", "claudemesh.desktop", "x-scheme-handler/claudemesh"], { encoding: "utf-8" });
   if (xdg1.status !== 0) {
@@ -9023,7 +9129,7 @@ function installWindows() {
     `[HKEY_CURRENT_USER\\Software\\Classes\\claudemesh\\shell\\open\\command]`,
     `@="\\"${binPath.replace(/\\/g, "\\\\")}\\" \\"%1\\""`
   ];
-  const regPath = join7(homedir7(), "claudemesh-handler.reg");
+  const regPath = join8(homedir8(), "claudemesh-handler.reg");
   writeFileSync7(regPath, lines.join(`\r
 `));
   const res = spawnSync5("reg.exe", ["import", regPath], { encoding: "utf-8" });
@@ -9035,16 +9141,16 @@ function installWindows() {
   return EXIT.SUCCESS;
 }
 function uninstallDarwin() {
-  const appDir = join7(homedir7(), "Library", "Application Support", "claudemesh", "ClaudemeshHandler.app");
+  const appDir = join8(homedir8(), "Library", "Application Support", "claudemesh", "ClaudemeshHandler.app");
   if (existsSync14(appDir))
-    rmSync2(appDir, { recursive: true, force: true });
+    rmSync3(appDir, { recursive: true, force: true });
   render.ok("removed claudemesh:// handler on macOS");
   return EXIT.SUCCESS;
 }
 function uninstallLinux() {
-  const desktopPath = join7(homedir7(), ".local", "share", "applications", "claudemesh.desktop");
+  const desktopPath = join8(homedir8(), ".local", "share", "applications", "claudemesh.desktop");
   if (existsSync14(desktopPath))
-    rmSync2(desktopPath, { force: true });
+    rmSync3(desktopPath, { force: true });
   render.ok("removed claudemesh:// handler on Linux");
   return EXIT.SUCCESS;
 }
@@ -9089,8 +9195,8 @@ __export(exports_status_line, {
   runStatusLine: () => runStatusLine
 });
 import { existsSync as existsSync15, readFileSync as readFileSync10 } from "node:fs";
-import { join as join8 } from "node:path";
-import { homedir as homedir8 } from "node:os";
+import { join as join9 } from "node:path";
+import { homedir as homedir9 } from "node:os";
 async function runStatusLine() {
   try {
     const config = readConfig();
@@ -9098,7 +9204,7 @@ async function runStatusLine() {
       process.stdout.write("◇ claudemesh (not joined)");
       return EXIT.SUCCESS;
     }
-    const cachePath = join8(homedir8(), ".claudemesh", "peer-cache.json");
+    const cachePath = join9(homedir9(), ".claudemesh", "peer-cache.json");
     let cache = {};
     if (existsSync15(cachePath)) {
       try {
@@ -9258,7 +9364,7 @@ __export(exports_upgrade, {
 });
 import { spawnSync as spawnSync6 } from "node:child_process";
 import { existsSync as existsSync17 } from "node:fs";
-import { dirname as dirname3, join as join9, resolve as resolve2 } from "node:path";
+import { dirname as dirname4, join as join10, resolve as resolve2 } from "node:path";
 async function latestVersion() {
   try {
     const res = await fetch(URLS.NPM_REGISTRY, { signal: AbortSignal.timeout(8000) });
@@ -9271,14 +9377,14 @@ async function latestVersion() {
   }
 }
 function findNpm() {
-  const portable = join9(process.env.HOME ?? "", ".claudemesh", "node", "bin", "npm");
+  const portable = join10(process.env.HOME ?? "", ".claudemesh", "node", "bin", "npm");
   if (existsSync17(portable)) {
-    return { npm: portable, prefix: join9(process.env.HOME ?? "", ".claudemesh") };
+    return { npm: portable, prefix: join10(process.env.HOME ?? "", ".claudemesh") };
   }
   let cur = resolve2(process.argv[1] ?? ".");
   for (let i = 0;i < 6; i++) {
-    cur = dirname3(cur);
-    const candidate = join9(cur, "bin", "npm");
+    cur = dirname4(cur);
+    const candidate = join10(cur, "bin", "npm");
     if (existsSync17(candidate))
       return { npm: candidate };
   }
@@ -9342,8 +9448,8 @@ __export(exports_grants, {
   isAllowed: () => isAllowed
 });
 import { existsSync as existsSync18, mkdirSync as mkdirSync5, readFileSync as readFileSync12, writeFileSync as writeFileSync9 } from "node:fs";
-import { homedir as homedir9 } from "node:os";
-import { join as join10 } from "node:path";
+import { homedir as homedir10 } from "node:os";
+import { join as join11 } from "node:path";
 async function syncToBroker(meshSlug, grants) {
   const auth = getStoredToken();
   if (!auth)
@@ -9370,7 +9476,7 @@ function readGrants() {
   }
 }
 function writeGrants(g) {
-  const dir = join10(homedir9(), ".claudemesh");
+  const dir = join11(homedir10(), ".claudemesh");
   if (!existsSync18(dir))
     mkdirSync5(dir, { recursive: true });
   writeFileSync9(GRANT_FILE, JSON.stringify(g, null, 2), { mode: 384 });
@@ -9457,79 +9563,839 @@ 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/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 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;
+  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 runGrants(opts = {}) {
-  const mesh = pickMesh2(opts.mesh);
-  if (!mesh) {
-    render.err("No matching mesh.");
-    return EXIT.NOT_FOUND;
+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;
   }
-  const store = readGrants();
-  const meshGrants = store[mesh] ?? {};
-  if (opts.json) {
-    console.log(JSON.stringify({ schema_version: "1.0", mesh, grants: meshGrants }, null, 2));
+  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;
   }
-  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(", ") + ")");
+  let args = {};
+  if (argsRaw) {
+    try {
+      args = JSON.parse(argsRaw);
+    } catch {
+      render.err("args must be JSON");
+      return EXIT.INVALID_ARGS;
+    }
+  }
+  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 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;
+  });
+}
+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 = join10(homedir9(), ".claudemesh", "grants.json");
 });
 
 // src/mcp/tools/definitions.ts
@@ -11181,8 +12047,8 @@ ${peerLines.join(`
         try {
           const { writeFileSync: writeFileSync10, mkdirSync: mkdirSync7, existsSync: existsSync20 } = await import("node:fs");
           const { join: joinPath } = await import("node:path");
-          const { homedir: homedir10 } = await import("node:os");
-          const dir = joinPath(homedir10(), ".claudemesh");
+          const { homedir: homedir11 } = await import("node:os");
+          const dir = joinPath(homedir11(), ".claudemesh");
           if (!existsSync20(dir))
             mkdirSync7(dir, { recursive: true });
           writeFileSync10(joinPath(dir, "peer-cache.json"), JSON.stringify(statusCache));
@@ -11437,7 +12303,7 @@ ${lines.join(`
           const { encryptFile: encryptFile2, sealKeyForPeer: sealKeyForPeer2 } = await Promise.resolve().then(() => (init_file_crypto(), exports_file_crypto));
           const { readFileSync: readFileSync13, writeFileSync: writeFileSync10, mkdtempSync: mkdtempSync2, unlinkSync: unlinkSync3, rmdirSync } = await import("node:fs");
           const { tmpdir: tmpdir2 } = await import("node:os");
-          const { join: join11, basename } = await import("node:path");
+          const { join: join12, basename } = await import("node:path");
           const peers = await client.listPeers();
           const targetPeer = peers.find((p) => p.pubkey === fileTo || p.displayName === fileTo);
           if (!targetPeer) {
@@ -11460,8 +12326,8 @@ ${lines.join(`
           combined.set(ciphertext, nonceBytes.length);
           const rawName = fileName ?? basename(filePath);
           const baseName = basename(rawName).replace(/[^a-zA-Z0-9._-]/g, "_").slice(0, 255);
-          const tmpDir = mkdtempSync2(join11(tmpdir2(), "cm-"));
-          const tmpPath = join11(tmpDir, baseName);
+          const tmpDir = mkdtempSync2(join12(tmpdir2(), "cm-"));
+          const tmpPath = join12(tmpDir, baseName);
           writeFileSync10(tmpPath, combined);
           try {
             const fileId = await client.uploadFile(tmpPath, client.meshId, client.meshSlug, {
@@ -11538,8 +12404,8 @@ ${lines.join(`
           if (!plaintext)
             return text(genericErr, true);
           const { writeFileSync: writeFileSync11, mkdirSync: mkdirSync8 } = await import("node:fs");
-          const { dirname: dirname5 } = await import("node:path");
-          mkdirSync8(dirname5(save_to), { recursive: true });
+          const { dirname: dirname6 } = await import("node:path");
+          mkdirSync8(dirname6(save_to), { recursive: true });
           writeFileSync11(save_to, plaintext);
           return text(`Downloaded and decrypted: ${result.name} → ${save_to}`);
         }
@@ -11551,8 +12417,8 @@ ${lines.join(`
         if (!res.ok)
           return text(`get_file: download failed (${res.status})`, true);
         const { writeFileSync: writeFileSync10, mkdirSync: mkdirSync7 } = await import("node:fs");
-        const { dirname: dirname4 } = await import("node:path");
-        mkdirSync7(dirname4(save_to), { recursive: true });
+        const { dirname: dirname5 } = await import("node:path");
+        mkdirSync7(dirname5(save_to), { recursive: true });
         writeFileSync10(save_to, Buffer.from(await res.arrayBuffer()));
         return text(`Downloaded: ${result.name} → ${save_to}`);
       }
@@ -13225,9 +14091,25 @@ Identity / presence
   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
@@ -13467,11 +14349,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 }));
@@ -13482,20 +14359,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());
@@ -13607,6 +14470,234 @@ async function main() {
       process.exit(await runGrants2({ mesh: flags.mesh, json: !!flags.json }));
       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();
@@ -13634,4 +14725,4 @@ main().catch((err) => {
   process.exit(EXIT.INTERNAL_ERROR);
 });
 
-//# debugId=25926A42D1A4B83764756E2164756E21
+//# debugId=B4AA59318D3B1FB264756E2164756E21