claudemesh-cli 0.6.8 → 0.7.0

package/dist/index.js

@@ -46941,6 +46941,46 @@ var TOOLS = [
       required: ["status"]
     }
   },
+  {
+    name: "set_visible",
+    description: "Control your visibility in the mesh. When hidden, you won't appear in list_peers and won't receive broadcasts — but direct messages still reach you.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        visible: {
+          type: "boolean",
+          description: "true to be visible (default), false to hide"
+        }
+      },
+      required: ["visible"]
+    }
+  },
+  {
+    name: "set_profile",
+    description: "Set your public profile — what other peers see about you. Avatar (emoji), title, bio, and capabilities list.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        avatar: {
+          type: "string",
+          description: "Emoji or URL for your avatar"
+        },
+        title: {
+          type: "string",
+          description: "Short role label (e.g. 'Frontend Lead', 'DevOps')"
+        },
+        bio: {
+          type: "string",
+          description: "One-liner about yourself"
+        },
+        capabilities: {
+          type: "array",
+          items: { type: "string" },
+          description: "What you can help with"
+        }
+      }
+    }
+  },
   {
     name: "join_group",
     description: "Join a group with an optional role. Other peers see your group membership in list_peers.",
@@ -47376,13 +47416,14 @@ var TOOLS = [
   },
   {
     name: "schedule_reminder",
-    description: "Schedule a message for future delivery. Without `to`, it fires back to yourself (a self-reminder). With `to`, it delivers to a peer, @group, or * broadcast. The broker holds it and delivers when the time arrives. Receivers see `subtype: reminder` in the push envelope.",
+    description: "Schedule a one-shot or recurring message. Without `to`, it fires back to yourself (a self-reminder). With `to`, it delivers to a peer, @group, or * broadcast. For one-shot, provide `deliver_at` or `in_seconds`. For recurring, provide `cron` (standard 5-field expression). The broker persists schedules to the database — they survive restarts. Receivers see `subtype: reminder` in the push envelope.",
     inputSchema: {
       type: "object",
       properties: {
         message: { type: "string", description: "Message or reminder text" },
-        deliver_at: { type: "number", description: "Unix timestamp (ms) when to deliver" },
-        in_seconds: { type: "number", description: "Alternative to deliver_at: fire after N seconds" },
+        deliver_at: { type: "number", description: "Unix timestamp (ms) when to deliver (one-shot)" },
+        in_seconds: { type: "number", description: "Alternative to deliver_at: fire after N seconds (one-shot)" },
+        cron: { type: "string", description: "Cron expression for recurring reminders (e.g. '0 */2 * * *' for every 2 hours, '30 9 * * 1-5' for 9:30 weekdays)" },
         to: {
           type: "string",
           description: "Recipient: display name, pubkey hex, @group, or * (omit for self-reminder)"
@@ -47412,6 +47453,144 @@ var TOOLS = [
     description: "Get a complete overview of the mesh: peers, groups, state, memory, files, tasks, streams, tables. Call on session start for full situational awareness.",
     inputSchema: { type: "object", properties: {} }
   },
+  {
+    name: "mesh_stats",
+    description: "View resource usage stats for all peers: messages sent/received, tool calls, uptime, errors.",
+    inputSchema: { type: "object", properties: {} }
+  },
+  {
+    name: "mesh_mcp_register",
+    description: "Register an MCP server with the mesh. Other peers can invoke its tools through the mesh without restarting their sessions. Provide the server name, description, and full tool definitions.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        server_name: { type: "string", description: "Unique name for the MCP server (e.g. 'github', 'jira')" },
+        description: { type: "string", description: "What this MCP server does" },
+        tools: {
+          type: "array",
+          items: {
+            type: "object",
+            properties: {
+              name: { type: "string" },
+              description: { type: "string" },
+              inputSchema: { type: "object", description: "JSON Schema for tool arguments" }
+            },
+            required: ["name", "description", "inputSchema"]
+          },
+          description: "Tool definitions to expose"
+        }
+      },
+      required: ["server_name", "description", "tools"]
+    }
+  },
+  {
+    name: "mesh_mcp_list",
+    description: "List MCP servers available in the mesh with their tools. Shows which peer hosts each server.",
+    inputSchema: { type: "object", properties: {} }
+  },
+  {
+    name: "mesh_tool_call",
+    description: "Call a tool on a mesh-registered MCP server. Route: you -> broker -> hosting peer -> execute -> result back. Timeout: 30s.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        server_name: { type: "string", description: "Name of the MCP server" },
+        tool_name: { type: "string", description: "Name of the tool to call" },
+        args: { type: "object", description: "Tool arguments (JSON object)" }
+      },
+      required: ["server_name", "tool_name"]
+    }
+  },
+  {
+    name: "mesh_mcp_remove",
+    description: "Unregister an MCP server you previously registered with the mesh.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        server_name: { type: "string", description: "Name of the MCP server to remove" }
+      },
+      required: ["server_name"]
+    }
+  },
+  {
+    name: "mesh_set_clock",
+    description: "Set the simulation clock speed. x1 = real-time, x10 = 10x faster, x100 = 100x. Peers receive heartbeat ticks at the simulated rate.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        speed: {
+          type: "number",
+          description: "Speed multiplier (1-100). x1 = tick every 60s, x10 = tick every 6s, x100 = tick every 600ms."
+        }
+      },
+      required: ["speed"]
+    }
+  },
+  {
+    name: "mesh_pause_clock",
+    description: "Pause the simulation clock. Ticks stop until resumed.",
+    inputSchema: { type: "object", properties: {} }
+  },
+  {
+    name: "mesh_resume_clock",
+    description: "Resume a paused simulation clock.",
+    inputSchema: { type: "object", properties: {} }
+  },
+  {
+    name: "mesh_clock",
+    description: "Get current simulation clock status: speed, tick count, simulated time.",
+    inputSchema: { type: "object", properties: {} }
+  },
+  {
+    name: "share_skill",
+    description: "Publish a reusable skill to the mesh. Other peers can discover and load it. If a skill with the same name exists, it is updated.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        name: { type: "string", description: "Unique skill name (e.g. 'code-review', 'deploy-checklist')" },
+        description: { type: "string", description: "Short description of what the skill does" },
+        instructions: { type: "string", description: "Full instructions/prompt that a peer loads to acquire this capability" },
+        tags: {
+          type: "array",
+          items: { type: "string" },
+          description: "Tags for discoverability"
+        }
+      },
+      required: ["name", "description", "instructions"]
+    }
+  },
+  {
+    name: "get_skill",
+    description: "Load a skill's full instructions by name. Use to acquire capabilities shared by other peers.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        name: { type: "string", description: "Skill name to load" }
+      },
+      required: ["name"]
+    }
+  },
+  {
+    name: "list_skills",
+    description: "Browse available skills in the mesh. Optionally filter by keyword across name, description, and tags.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        query: { type: "string", description: "Search keyword (optional)" }
+      }
+    }
+  },
+  {
+    name: "remove_skill",
+    description: "Remove a skill you published from the mesh.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        name: { type: "string", description: "Skill name to remove" }
+      },
+      required: ["name"]
+    }
+  },
   {
     name: "ping_mesh",
     description: "Send test messages through the full pipeline and measure round-trip timing per priority. Diagnoses push delivery issues.",
@@ -47425,6 +47604,61 @@ var TOOLS = [
         }
       }
     }
+  },
+  {
+    name: "read_peer_file",
+    description: "Read a file from another peer's project. Specify the peer (by name) and the file path relative to their working directory. The peer must be online and sharing files. Max file size: 1MB.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        peer: { type: "string", description: "Peer display name or pubkey" },
+        path: { type: "string", description: "File path relative to peer's working directory" }
+      },
+      required: ["peer", "path"]
+    }
+  },
+  {
+    name: "list_peer_files",
+    description: "List files in a peer's shared directory. Returns a tree of file names (not contents). The peer must be online and sharing files.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        peer: { type: "string", description: "Peer display name or pubkey" },
+        path: { type: "string", description: "Directory path relative to peer's cwd (default: root)" },
+        pattern: { type: "string", description: "Glob-like filter pattern (e.g. '*.ts', 'src/*')" }
+      },
+      required: ["peer"]
+    }
+  },
+  {
+    name: "create_webhook",
+    description: "Create an inbound webhook. Returns a URL that external services (GitHub, CI/CD, monitoring) can POST to — the payload becomes a mesh message to all peers.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        name: {
+          type: "string",
+          description: "Webhook name (e.g. 'github-ci', 'datadog-alerts')"
+        }
+      },
+      required: ["name"]
+    }
+  },
+  {
+    name: "list_webhooks",
+    description: "List active webhooks for this mesh.",
+    inputSchema: { type: "object", properties: {} }
+  },
+  {
+    name: "delete_webhook",
+    description: "Deactivate a webhook.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        name: { type: "string", description: "Webhook name to deactivate" }
+      },
+      required: ["name"]
+    }
   }
 ];
 
@@ -47510,10 +47744,21 @@ class BrokerClient {
   sessionPubkey = null;
   sessionSecretKey = null;
   grantFileAccessResolvers = new Map;
+  peerFileResponseResolvers = new Map;
+  peerDirResponseResolvers = new Map;
+  sharedDirs = [process.cwd()];
   closed = false;
   reconnectAttempt = 0;
   helloTimer = null;
   reconnectTimer = null;
+  _statsCounters = {
+    messagesIn: 0,
+    messagesOut: 0,
+    toolCalls: 0,
+    errors: 0
+  };
+  _sessionStartedAt = Date.now();
+  _statsReportTimer = null;
   constructor(mesh, opts = {}) {
     this.mesh = mesh;
     this.opts = opts;
@@ -47565,6 +47810,9 @@ class BrokerClient {
             sessionId: `${process.pid}-${Date.now()}`,
             pid: process.pid,
             cwd: process.cwd(),
+            peerType: "ai",
+            channel: "claude-code",
+            model: process.env.CLAUDE_MODEL || undefined,
             timestamp,
             signature
           }));
@@ -47592,6 +47840,7 @@ class BrokerClient {
           this.setConnStatus("open");
           this.reconnectAttempt = 0;
           this.flushOutbound();
+          this.startStatsReporting();
           resolve();
           return;
         }
@@ -47631,6 +47880,7 @@ class BrokerClient {
       nonce = randomNonce();
       ciphertext = Buffer.from(message, "utf-8").toString("base64");
     }
+    this._statsCounters.messagesOut++;
     return new Promise((resolve) => {
       if (this.pendingSends.size >= MAX_QUEUED) {
         resolve({ ok: false, error: "outbound queue full" });
@@ -47688,6 +47938,16 @@ class BrokerClient {
       return;
     this.ws.send(JSON.stringify({ type: "set_status", status }));
   }
+  async setVisible(visible) {
+    if (!this.ws || this.ws.readyState !== this.ws.OPEN)
+      return;
+    this.ws.send(JSON.stringify({ type: "set_visible", visible }));
+  }
+  async setProfile(profile) {
+    if (!this.ws || this.ws.readyState !== this.ws.OPEN)
+      return;
+    this.ws.send(JSON.stringify({ type: "set_profile", ...profile }));
+  }
   async listPeers() {
     if (!this.ws || this.ws.readyState !== this.ws.OPEN)
       return [];
@@ -47705,6 +47965,34 @@ class BrokerClient {
       return;
     this.ws.send(JSON.stringify({ type: "set_summary", summary }));
   }
+  setStats(stats) {
+    if (!this.ws || this.ws.readyState !== this.ws.OPEN)
+      return;
+    const payload = stats ?? {
+      ...this._statsCounters,
+      uptime: Math.round((Date.now() - this._sessionStartedAt) / 1000)
+    };
+    this.ws.send(JSON.stringify({ type: "set_stats", stats: payload }));
+  }
+  incrementToolCalls() {
+    this._statsCounters.toolCalls++;
+  }
+  incrementErrors() {
+    this._statsCounters.errors++;
+  }
+  startStatsReporting() {
+    if (this._statsReportTimer)
+      return;
+    this._statsReportTimer = setInterval(() => {
+      this.setStats();
+    }, 60000);
+  }
+  stopStatsReporting() {
+    if (this._statsReportTimer) {
+      clearInterval(this._statsReportTimer);
+      this._statsReportTimer = null;
+    }
+  }
   async joinGroup(name, role) {
     if (!this.ws || this.ws.readyState !== this.ws.OPEN)
       return;
@@ -47773,7 +48061,7 @@ class BrokerClient {
       return;
     this.ws.send(JSON.stringify({ type: "forget", memoryId }));
   }
-  async scheduleMessage(to, message, deliverAt, isReminder = false) {
+  async scheduleMessage(to, message, deliverAt, isReminder = false, cron) {
     if (!this.ws || this.ws.readyState !== this.ws.OPEN)
       return null;
     return new Promise((resolve) => {
@@ -47788,6 +48076,7 @@ class BrokerClient {
         message,
         deliverAt,
         ...isReminder ? { subtype: "reminder" } : {},
+        ...cron ? { cron, recurring: true } : {},
         _reqId: reqId
       }));
     });
@@ -47836,6 +48125,10 @@ class BrokerClient {
   scheduledAckResolvers = new Map;
   scheduledListResolvers = new Map;
   cancelScheduledResolvers = new Map;
+  mcpRegisterResolvers = new Map;
+  mcpListResolvers = new Map;
+  mcpCallResolvers = new Map;
+  mcpCallForwardHandler = null;
   async messageStatus(messageId) {
     if (!this.ws || this.ws.readyState !== this.ws.OPEN)
       return null;
@@ -48134,7 +48427,105 @@ class BrokerClient {
     this.stateChangeHandlers.add(handler);
     return () => this.stateChangeHandlers.delete(handler);
   }
+  async mcpRegister(serverName, description, tools) {
+    if (!this.ws || this.ws.readyState !== this.ws.OPEN)
+      return null;
+    return new Promise((resolve) => {
+      const reqId = this.makeReqId();
+      this.mcpRegisterResolvers.set(reqId, { resolve, timer: setTimeout(() => {
+        if (this.mcpRegisterResolvers.delete(reqId))
+          resolve(null);
+      }, 5000) });
+      this.ws.send(JSON.stringify({ type: "mcp_register", serverName, description, tools, _reqId: reqId }));
+    });
+  }
+  async mcpUnregister(serverName) {
+    if (!this.ws || this.ws.readyState !== this.ws.OPEN)
+      return;
+    this.ws.send(JSON.stringify({ type: "mcp_unregister", serverName }));
+  }
+  async mcpList() {
+    if (!this.ws || this.ws.readyState !== this.ws.OPEN)
+      return [];
+    return new Promise((resolve) => {
+      const reqId = this.makeReqId();
+      this.mcpListResolvers.set(reqId, { resolve, timer: setTimeout(() => {
+        if (this.mcpListResolvers.delete(reqId))
+          resolve([]);
+      }, 5000) });
+      this.ws.send(JSON.stringify({ type: "mcp_list", _reqId: reqId }));
+    });
+  }
+  async mcpCall(serverName, toolName, args) {
+    if (!this.ws || this.ws.readyState !== this.ws.OPEN)
+      return { error: "not connected" };
+    return new Promise((resolve) => {
+      const reqId = this.makeReqId();
+      this.mcpCallResolvers.set(reqId, { resolve, timer: setTimeout(() => {
+        if (this.mcpCallResolvers.delete(reqId))
+          resolve({ error: "MCP call timed out (30s)" });
+      }, 30000) });
+      this.ws.send(JSON.stringify({ type: "mcp_call", serverName, toolName, args, _reqId: reqId }));
+    });
+  }
+  onMcpCallForward(handler) {
+    this.mcpCallForwardHandler = handler;
+  }
+  sendMcpCallResponse(callId, result, error2) {
+    if (!this.ws || this.ws.readyState !== this.ws.OPEN)
+      return;
+    this.ws.send(JSON.stringify({ type: "mcp_call_response", callId, result, error: error2 }));
+  }
   meshInfoResolvers = new Map;
+  clockStatusResolvers = new Map;
+  async setClock(speed) {
+    if (!this.ws || this.ws.readyState !== this.ws.OPEN)
+      return null;
+    return new Promise((resolve) => {
+      const reqId = this.makeReqId();
+      this.clockStatusResolvers.set(reqId, { resolve, timer: setTimeout(() => {
+        if (this.clockStatusResolvers.delete(reqId))
+          resolve(null);
+      }, 5000) });
+      this.ws.send(JSON.stringify({ type: "set_clock", speed, _reqId: reqId }));
+    });
+  }
+  async pauseClock() {
+    if (!this.ws || this.ws.readyState !== this.ws.OPEN)
+      return null;
+    return new Promise((resolve) => {
+      const reqId = this.makeReqId();
+      this.clockStatusResolvers.set(reqId, { resolve, timer: setTimeout(() => {
+        if (this.clockStatusResolvers.delete(reqId))
+          resolve(null);
+      }, 5000) });
+      this.ws.send(JSON.stringify({ type: "pause_clock", _reqId: reqId }));
+    });
+  }
+  async resumeClock() {
+    if (!this.ws || this.ws.readyState !== this.ws.OPEN)
+      return null;
+    return new Promise((resolve) => {
+      const reqId = this.makeReqId();
+      this.clockStatusResolvers.set(reqId, { resolve, timer: setTimeout(() => {
+        if (this.clockStatusResolvers.delete(reqId))
+          resolve(null);
+      }, 5000) });
+      this.ws.send(JSON.stringify({ type: "resume_clock", _reqId: reqId }));
+    });
+  }
+  async getClock() {
+    if (!this.ws || this.ws.readyState !== this.ws.OPEN)
+      return null;
+    return new Promise((resolve) => {
+      const reqId = this.makeReqId();
+      this.clockStatusResolvers.set(reqId, { resolve, timer: setTimeout(() => {
+        if (this.clockStatusResolvers.delete(reqId))
+          resolve(null);
+      }, 5000) });
+      this.ws.send(JSON.stringify({ type: "get_clock", _reqId: reqId }));
+    });
+  }
   async meshInfo() {
     if (!this.ws || this.ws.readyState !== this.ws.OPEN)
       return null;
@@ -48147,8 +48538,132 @@ class BrokerClient {
       this.ws.send(JSON.stringify({ type: "mesh_info", _reqId: reqId }));
     });
   }
+  skillAckResolvers = new Map;
+  skillDataResolvers = new Map;
+  skillListResolvers = new Map;
+  async shareSkill(name, description, instructions, tags) {
+    if (!this.ws || this.ws.readyState !== this.ws.OPEN)
+      return null;
+    return new Promise((resolve) => {
+      const reqId = this.makeReqId();
+      this.skillAckResolvers.set(reqId, { resolve: (result) => {
+        resolve(result ? { ok: true, action: result.action } : null);
+      }, timer: setTimeout(() => {
+        if (this.skillAckResolvers.delete(reqId))
+          resolve(null);
+      }, 5000) });
+      this.ws.send(JSON.stringify({ type: "share_skill", name, description, instructions, tags, _reqId: reqId }));
+    });
+  }
+  async getSkill(name) {
+    if (!this.ws || this.ws.readyState !== this.ws.OPEN)
+      return null;
+    return new Promise((resolve) => {
+      const reqId = this.makeReqId();
+      this.skillDataResolvers.set(reqId, { resolve, timer: setTimeout(() => {
+        if (this.skillDataResolvers.delete(reqId))
+          resolve(null);
+      }, 5000) });
+      this.ws.send(JSON.stringify({ type: "get_skill", name, _reqId: reqId }));
+    });
+  }
+  async listSkills(query) {
+    if (!this.ws || this.ws.readyState !== this.ws.OPEN)
+      return [];
+    return new Promise((resolve) => {
+      const reqId = this.makeReqId();
+      this.skillListResolvers.set(reqId, { resolve, timer: setTimeout(() => {
+        if (this.skillListResolvers.delete(reqId))
+          resolve([]);
+      }, 5000) });
+      this.ws.send(JSON.stringify({ type: "list_skills", query, _reqId: reqId }));
+    });
+  }
+  async removeSkill(name) {
+    if (!this.ws || this.ws.readyState !== this.ws.OPEN)
+      return false;
+    return new Promise((resolve) => {
+      const reqId = this.makeReqId();
+      this.skillAckResolvers.set(reqId, { resolve: (result) => {
+        resolve(result?.action === "removed");
+      }, timer: setTimeout(() => {
+        if (this.skillAckResolvers.delete(reqId))
+          resolve(false);
+      }, 5000) });
+      this.ws.send(JSON.stringify({ type: "remove_skill", name, _reqId: reqId }));
+    });
+  }
+  webhookAckResolvers = new Map;
+  webhookListResolvers = new Map;
+  async createWebhook(name) {
+    if (!this.ws || this.ws.readyState !== this.ws.OPEN)
+      return null;
+    return new Promise((resolve) => {
+      const reqId = this.makeReqId();
+      this.webhookAckResolvers.set(reqId, { resolve, timer: setTimeout(() => {
+        if (this.webhookAckResolvers.delete(reqId))
+          resolve(null);
+      }, 5000) });
+      this.ws.send(JSON.stringify({ type: "create_webhook", name, _reqId: reqId }));
+    });
+  }
+  async listWebhooks() {
+    if (!this.ws || this.ws.readyState !== this.ws.OPEN)
+      return [];
+    return new Promise((resolve) => {
+      const reqId = this.makeReqId();
+      this.webhookListResolvers.set(reqId, { resolve, timer: setTimeout(() => {
+        if (this.webhookListResolvers.delete(reqId))
+          resolve([]);
+      }, 5000) });
+      this.ws.send(JSON.stringify({ type: "list_webhooks", _reqId: reqId }));
+    });
+  }
+  async deleteWebhook(name) {
+    if (!this.ws || this.ws.readyState !== this.ws.OPEN)
+      return false;
+    return new Promise((resolve) => {
+      const reqId = this.makeReqId();
+      this.webhookAckResolvers.set(reqId, { resolve: () => resolve(true), timer: setTimeout(() => {
+        if (this.webhookAckResolvers.delete(reqId))
+          resolve(false);
+      }, 5000) });
+      this.ws.send(JSON.stringify({ type: "delete_webhook", name, _reqId: reqId }));
+    });
+  }
+  setSharedDirs(dirs) {
+    this.sharedDirs = dirs.map((d) => {
+      const { resolve } = __require("node:path");
+      return resolve(d);
+    });
+  }
+  async requestFile(targetPubkey, filePath) {
+    if (!this.ws || this.ws.readyState !== this.ws.OPEN)
+      return { error: "not connected" };
+    return new Promise((resolve) => {
+      const reqId = this.makeReqId();
+      this.peerFileResponseResolvers.set(reqId, { resolve, timer: setTimeout(() => {
+        if (this.peerFileResponseResolvers.delete(reqId))
+          resolve({ error: "timeout waiting for peer response" });
+      }, 15000) });
+      this.ws.send(JSON.stringify({ type: "peer_file_request", targetPubkey, filePath, _reqId: reqId }));
+    });
+  }
+  async requestDir(targetPubkey, dirPath, pattern) {
+    if (!this.ws || this.ws.readyState !== this.ws.OPEN)
+      return { error: "not connected" };
+    return new Promise((resolve) => {
+      const reqId = this.makeReqId();
+      this.peerDirResponseResolvers.set(reqId, { resolve, timer: setTimeout(() => {
+        if (this.peerDirResponseResolvers.delete(reqId))
+          resolve({ error: "timeout waiting for peer response" });
+      }, 15000) });
+      this.ws.send(JSON.stringify({ type: "peer_dir_request", targetPubkey, dirPath, ...pattern ? { pattern } : {}, _reqId: reqId }));
+    });
+  }
   close() {
     this.closed = true;
+    this.stopStatsReporting();
     if (this.helloTimer)
       clearTimeout(this.helloTimer);
     if (this.reconnectTimer)
@@ -48160,6 +48675,141 @@ class BrokerClient {
     }
     this.setConnStatus("closed");
   }
+  static MAX_FILE_SIZE = 1048576;
+  async handlePeerFileRequest(msg) {
+    const { resolve, join: join2, normalize } = await import("node:path");
+    const { readFileSync: readFileSync2, statSync } = await import("node:fs");
+    const reqId = msg._reqId;
+    const sendResponse = (content, error2) => {
+      if (!this.ws || this.ws.readyState !== this.ws.OPEN)
+        return;
+      this.ws.send(JSON.stringify({
+        type: "peer_file_response",
+        requesterPubkey: msg.requesterPubkey,
+        filePath: msg.filePath,
+        ...content !== undefined ? { content } : {},
+        ...error2 ? { error: error2 } : {},
+        ...reqId ? { _reqId: reqId } : {}
+      }));
+    };
+    if (msg.filePath.includes("..")) {
+      sendResponse(undefined, "path traversal not allowed");
+      return;
+    }
+    let resolvedPath = null;
+    for (const dir of this.sharedDirs) {
+      const candidate = resolve(join2(dir, msg.filePath));
+      const normalizedCandidate = normalize(candidate);
+      const normalizedDir = normalize(dir);
+      if (normalizedCandidate.startsWith(normalizedDir + "/") || normalizedCandidate === normalizedDir) {
+        resolvedPath = candidate;
+        break;
+      }
+    }
+    if (!resolvedPath) {
+      sendResponse(undefined, "file outside shared directories");
+      return;
+    }
+    try {
+      const stat = statSync(resolvedPath);
+      if (!stat.isFile()) {
+        sendResponse(undefined, "not a file");
+        return;
+      }
+      if (stat.size > BrokerClient.MAX_FILE_SIZE) {
+        sendResponse(undefined, `file too large (${stat.size} bytes, max ${BrokerClient.MAX_FILE_SIZE})`);
+        return;
+      }
+      const content = readFileSync2(resolvedPath);
+      sendResponse(content.toString("base64"));
+    } catch (e) {
+      const errMsg = e instanceof Error ? e.message : String(e);
+      if (errMsg.includes("ENOENT")) {
+        sendResponse(undefined, "file not found");
+      } else {
+        sendResponse(undefined, `read error: ${errMsg}`);
+      }
+    }
+  }
+  async handlePeerDirRequest(msg) {
+    const { resolve, join: join2, normalize, relative } = await import("node:path");
+    const { readdirSync, statSync } = await import("node:fs");
+    const reqId = msg._reqId;
+    const sendResponse = (entries, error2) => {
+      if (!this.ws || this.ws.readyState !== this.ws.OPEN)
+        return;
+      this.ws.send(JSON.stringify({
+        type: "peer_dir_response",
+        requesterPubkey: msg.requesterPubkey,
+        dirPath: msg.dirPath,
+        ...entries ? { entries } : {},
+        ...error2 ? { error: error2 } : {},
+        ...reqId ? { _reqId: reqId } : {}
+      }));
+    };
+    const dirPath = msg.dirPath || ".";
+    if (dirPath.includes("..")) {
+      sendResponse(undefined, "path traversal not allowed");
+      return;
+    }
+    let resolvedPath = null;
+    for (const dir of this.sharedDirs) {
+      const candidate = resolve(join2(dir, dirPath));
+      const normalizedCandidate = normalize(candidate);
+      const normalizedDir = normalize(dir);
+      if (normalizedCandidate.startsWith(normalizedDir + "/") || normalizedCandidate === normalizedDir) {
+        resolvedPath = candidate;
+        break;
+      }
+    }
+    if (!resolvedPath) {
+      sendResponse(undefined, "directory outside shared directories");
+      return;
+    }
+    try {
+      const stat = statSync(resolvedPath);
+      if (!stat.isDirectory()) {
+        sendResponse(undefined, "not a directory");
+        return;
+      }
+      const entries = [];
+      const MAX_ENTRIES = 500;
+      const MAX_DEPTH = 2;
+      const pattern = msg.pattern ? new RegExp(msg.pattern.replace(/\*/g, ".*").replace(/\?/g, "."), "i") : null;
+      const walk = (dir, depth) => {
+        if (entries.length >= MAX_ENTRIES || depth > MAX_DEPTH)
+          return;
+        try {
+          const items = readdirSync(dir, { withFileTypes: true });
+          for (const item of items) {
+            if (entries.length >= MAX_ENTRIES)
+              break;
+            if (item.name.startsWith("."))
+              continue;
+            const relPath = relative(resolvedPath, join2(dir, item.name));
+            const label = item.isDirectory() ? relPath + "/" : relPath;
+            if (pattern && !pattern.test(item.name)) {
+              if (item.isDirectory())
+                walk(join2(dir, item.name), depth + 1);
+              continue;
+            }
+            entries.push(label);
+            if (item.isDirectory())
+              walk(join2(dir, item.name), depth + 1);
+          }
+        } catch {}
+      };
+      walk(resolvedPath, 0);
+      sendResponse(entries.sort());
+    } catch (e) {
+      const errMsg = e instanceof Error ? e.message : String(e);
+      if (errMsg.includes("ENOENT")) {
+        sendResponse(undefined, "directory not found");
+      } else {
+        sendResponse(undefined, `read error: ${errMsg}`);
+      }
+    }
+  }
   resolveFromMap(map2, reqId, value) {
     let entry = reqId ? map2.get(reqId) : undefined;
     if (!entry) {
@@ -48197,6 +48847,7 @@ class BrokerClient {
       return;
     }
     if (msg.type === "push") {
+      this._statsCounters.messagesIn++;
       const nonce = String(msg.nonce ?? "");
       const ciphertext = String(msg.ciphertext ?? "");
       const senderPubkey = String(msg.senderPubkey ?? "");
@@ -48234,7 +48885,9 @@ class BrokerClient {
           receivedAt: new Date().toISOString(),
           plaintext,
           kind,
-          ...msg.subtype ? { subtype: msg.subtype } : {}
+          ...msg.subtype ? { subtype: msg.subtype } : {},
+          ...msg.event ? { event: String(msg.event) } : {},
+          ...msg.eventData ? { eventData: msg.eventData } : {}
         };
         this.pushBuffer.push(push);
         if (this.pushBuffer.length > 500)
@@ -48388,31 +49041,125 @@ class BrokerClient {
         data: msg.data,
         publishedBy: String(msg.publishedBy ?? "")
       };
-      for (const h of this.streamDataHandlers) {
-        try {
-          h(evt);
-        } catch {}
+      for (const h of this.streamDataHandlers) {
+        try {
+          h(evt);
+        } catch {}
+      }
+      return;
+    }
+    if (msg.type === "clock_status") {
+      this.resolveFromMap(this.clockStatusResolvers, msgReqId, {
+        speed: Number(msg.speed ?? 0),
+        paused: Boolean(msg.paused),
+        tick: Number(msg.tick ?? 0),
+        simTime: String(msg.simTime ?? ""),
+        startedAt: String(msg.startedAt ?? "")
+      });
+      return;
+    }
+    if (msg.type === "mesh_info_result") {
+      this.resolveFromMap(this.meshInfoResolvers, msgReqId, msg);
+      return;
+    }
+    if (msg.type === "skill_ack") {
+      this.resolveFromMap(this.skillAckResolvers, msgReqId, { name: String(msg.name ?? ""), action: String(msg.action ?? "") });
+      return;
+    }
+    if (msg.type === "skill_data") {
+      const skill = msg.skill;
+      this.resolveFromMap(this.skillDataResolvers, msgReqId, skill ?? null);
+      return;
+    }
+    if (msg.type === "skill_list") {
+      const skills = msg.skills ?? [];
+      this.resolveFromMap(this.skillListResolvers, msgReqId, skills);
+      return;
+    }
+    if (msg.type === "scheduled_ack") {
+      this.resolveFromMap(this.scheduledAckResolvers, msgReqId, {
+        scheduledId: String(msg.scheduledId ?? ""),
+        deliverAt: Number(msg.deliverAt ?? 0),
+        ...msg.cron ? { cron: String(msg.cron) } : {}
+      });
+      return;
+    }
+    if (msg.type === "scheduled_list") {
+      const messages = msg.messages ?? [];
+      this.resolveFromMap(this.scheduledListResolvers, msgReqId, messages);
+      return;
+    }
+    if (msg.type === "cancel_scheduled_ack") {
+      this.resolveFromMap(this.cancelScheduledResolvers, msgReqId, Boolean(msg.ok));
+      return;
+    }
+    if (msg.type === "mcp_register_ack") {
+      this.resolveFromMap(this.mcpRegisterResolvers, msgReqId, {
+        serverName: String(msg.serverName ?? ""),
+        toolCount: Number(msg.toolCount ?? 0)
+      });
+      return;
+    }
+    if (msg.type === "mcp_list_result") {
+      const servers = msg.servers ?? [];
+      this.resolveFromMap(this.mcpListResolvers, msgReqId, servers);
+      return;
+    }
+    if (msg.type === "mcp_call_result") {
+      this.resolveFromMap(this.mcpCallResolvers, msgReqId, {
+        ...msg.result !== undefined ? { result: msg.result } : {},
+        ...msg.error ? { error: String(msg.error) } : {}
+      });
+      return;
+    }
+    if (msg.type === "mcp_call_forward") {
+      const forward = {
+        callId: String(msg.callId ?? ""),
+        serverName: String(msg.serverName ?? ""),
+        toolName: String(msg.toolName ?? ""),
+        args: msg.args ?? {},
+        callerName: String(msg.callerName ?? "")
+      };
+      if (this.mcpCallForwardHandler) {
+        this.mcpCallForwardHandler(forward).then((res) => this.sendMcpCallResponse(forward.callId, res.result, res.error)).catch((e) => this.sendMcpCallResponse(forward.callId, undefined, e instanceof Error ? e.message : String(e)));
+      } else {
+        this.sendMcpCallResponse(forward.callId, undefined, "No MCP call handler registered on this peer");
       }
       return;
     }
-    if (msg.type === "mesh_info_result") {
-      this.resolveFromMap(this.meshInfoResolvers, msgReqId, msg);
+    if (msg.type === "peer_file_request_forward") {
+      this.handlePeerFileRequest(msg);
       return;
     }
-    if (msg.type === "scheduled_ack") {
-      this.resolveFromMap(this.scheduledAckResolvers, msgReqId, {
-        scheduledId: String(msg.scheduledId ?? ""),
-        deliverAt: Number(msg.deliverAt ?? 0)
+    if (msg.type === "peer_file_response_forward") {
+      this.resolveFromMap(this.peerFileResponseResolvers, msgReqId, {
+        content: msg.content ? String(msg.content) : undefined,
+        error: msg.error ? String(msg.error) : undefined
       });
       return;
     }
-    if (msg.type === "scheduled_list") {
-      const messages = msg.messages ?? [];
-      this.resolveFromMap(this.scheduledListResolvers, msgReqId, messages);
+    if (msg.type === "peer_dir_request_forward") {
+      this.handlePeerDirRequest(msg);
       return;
     }
-    if (msg.type === "cancel_scheduled_ack") {
-      this.resolveFromMap(this.cancelScheduledResolvers, msgReqId, Boolean(msg.ok));
+    if (msg.type === "peer_dir_response_forward") {
+      this.resolveFromMap(this.peerDirResponseResolvers, msgReqId, {
+        entries: msg.entries ?? undefined,
+        error: msg.error ? String(msg.error) : undefined
+      });
+      return;
+    }
+    if (msg.type === "webhook_ack") {
+      this.resolveFromMap(this.webhookAckResolvers, msgReqId, {
+        name: String(msg.name ?? ""),
+        url: String(msg.url ?? ""),
+        secret: String(msg.secret ?? "")
+      });
+      return;
+    }
+    if (msg.type === "webhook_list") {
+      const webhooks = msg.webhooks ?? [];
+      this.resolveFromMap(this.webhookListResolvers, msgReqId, webhooks);
       return;
     }
     if (msg.type === "error") {
@@ -48457,7 +49204,18 @@ class BrokerClient {
           [this.taskCreatedResolvers, null],
           [this.streamCreatedResolvers, null],
           [this.listPeersResolvers, []],
-          [this.meshInfoResolvers, null]
+          [this.meshInfoResolvers, null],
+          [this.clockStatusResolvers, null],
+          [this.mcpRegisterResolvers, null],
+          [this.mcpListResolvers, []],
+          [this.mcpCallResolvers, { error: "broker error" }],
+          [this.skillAckResolvers, null],
+          [this.skillDataResolvers, null],
+          [this.skillListResolvers, []],
+          [this.peerFileResponseResolvers, { error: "broker error" }],
+          [this.peerDirResponseResolvers, { error: "broker error" }],
+          [this.webhookAckResolvers, null],
+          [this.webhookListResolvers, []]
         ];
         for (const [map2, defaultVal] of allMaps) {
           const first = map2.entries().next().value;
@@ -48660,6 +49418,8 @@ If the channel meta contains \`subtype: reminder\`, this is a scheduled reminder
 | check_messages() | Drain buffered inbound messages (auto-pushed in most cases, use as fallback). |
 | set_summary(summary) | Set 1-2 sentence description of your current work, visible to all peers. |
 | set_status(status) | Override status: idle, working, or dnd. |
+| set_visible(visible) | Toggle visibility. Hidden peers skip list_peers and broadcasts; direct messages still arrive. |
+| set_profile(avatar?, title?, bio?, capabilities?) | Set public profile: emoji avatar, short title, bio, capabilities list. |
 | join_group(name, role?) | Join a @group with optional role (lead, member, observer, or any string). |
 | leave_group(name) | Leave a @group. |
 | set_state(key, value) | Write shared state; pushes change to all peers. |
@@ -48696,6 +49456,12 @@ If the channel meta contains \`subtype: reminder\`, this is a scheduled reminder
 | schedule_reminder(message, in_seconds?, deliver_at?, to?) | Schedule a reminder to yourself (no \`to\`) or a delayed message to a peer/group. Delivered as a push with \`subtype: reminder\` in the channel meta. |
 | list_scheduled() | List pending scheduled reminders and messages. |
 | cancel_scheduled(id) | Cancel a pending scheduled item. |
+| read_peer_file(peer, path) | Read a file from another peer's project (max 1MB). |
+| list_peer_files(peer, path?, pattern?) | List files in a peer's shared directory. |
+| mesh_mcp_register(server_name, description, tools) | Register an MCP server with the mesh. Other peers can call its tools. |
+| mesh_mcp_list() | List MCP servers available in the mesh with their tools. |
+| mesh_tool_call(server_name, tool_name, args?) | Call a tool on a mesh-registered MCP server (30s timeout). |
+| mesh_mcp_remove(server_name) | Unregister an MCP server you registered. |
 
 If multiple meshes are joined, prefix \`to\` with \`<mesh-slug>:\` to disambiguate (e.g. \`dev-team:Alice\`).
 
@@ -48759,6 +49525,9 @@ Your message mode is "${messageMode}".
   }));
   server.setRequestHandler(CallToolRequestSchema, async (req) => {
     const { name, arguments: args } = req.params;
+    for (const c of allClients()) {
+      c.incrementToolCalls();
+    }
     if (config2.meshes.length === 0) {
       return text("No meshes joined. Run `claudemesh join https://claudemesh.com/join/<token>` first.", true);
     }
@@ -48805,7 +49574,19 @@ No peers connected.`);
             const peerLines = peers.map((p) => {
               const summary = p.summary ? ` — "${p.summary}"` : "";
               const groupsStr = p.groups?.length ? ` [${p.groups.map((g) => `@${g.name}${g.role ? ":" + g.role : ""}`).join(", ")}]` : "";
-              return `- **${p.displayName}** [${p.status}]${groupsStr} (${p.pubkey.slice(0, 12)}…)${summary}`;
+              const meta2 = [];
+              if (p.peerType)
+                meta2.push(`type:${p.peerType}`);
+              if (p.channel)
+                meta2.push(`channel:${p.channel}`);
+              if (p.model)
+                meta2.push(`model:${p.model}`);
+              const metaStr = meta2.length ? ` {${meta2.join(", ")}}` : "";
+              const cwdStr = p.cwd ? ` cwd:${p.cwd}` : "";
+              const profileAvatar = p.profile?.avatar ? `${p.profile.avatar} ` : "";
+              const profileTitle = p.profile?.title ? ` (${p.profile.title})` : "";
+              const hiddenTag = p.visible === false ? " [hidden]" : "";
+              return `- ${profileAvatar}**${p.displayName}**${profileTitle} [${p.status}]${hiddenTag}${groupsStr}${metaStr} (${p.pubkey.slice(0, 12)}…)${cwdStr}${summary}`;
             });
             sections.push(`${header}
 ${peerLines.join(`
@@ -48872,6 +49653,32 @@ ${drained.join(`
           await c.setStatus(s);
         return text(`Status set to ${s} across ${allClients().length} mesh(es).`);
       }
+      case "set_visible": {
+        const { visible } = args ?? {};
+        if (visible === undefined)
+          return text("set_visible: `visible` required", true);
+        for (const c of allClients())
+          await c.setVisible(visible);
+        return text(visible ? "You are now visible to peers." : "You are now hidden. Direct messages still reach you, but you won't appear in list_peers or receive broadcasts.");
+      }
+      case "set_profile": {
+        const { avatar, title, bio, capabilities } = args ?? {};
+        const profile = { avatar, title, bio, capabilities };
+        for (const c of allClients())
+          await c.setProfile(profile);
+        const parts = [];
+        if (avatar)
+          parts.push(`Avatar: ${avatar}`);
+        if (title)
+          parts.push(`Title: ${title}`);
+        if (bio)
+          parts.push(`Bio: ${bio}`);
+        if (capabilities?.length)
+          parts.push(`Capabilities: ${capabilities.join(", ")}`);
+        return text(parts.length > 0 ? `Profile updated:
+${parts.join(`
+`)}` : "Profile cleared.");
+      }
       case "join_group": {
         const { name: groupName, role } = args ?? {};
         if (!groupName)
@@ -48958,13 +49765,16 @@ ${lines.join(`
         const sArgs = args ?? {};
         if (!sArgs.message)
           return text("schedule_reminder: `message` required", true);
+        const isCron = !!sArgs.cron;
         let deliverAt;
-        if (sArgs.deliver_at) {
+        if (isCron) {
+          deliverAt = 0;
+        } else if (sArgs.deliver_at) {
           deliverAt = Number(sArgs.deliver_at);
         } else if (sArgs.in_seconds) {
           deliverAt = Date.now() + Number(sArgs.in_seconds) * 1000;
         } else {
-          return text("schedule_reminder: provide `deliver_at` (ms timestamp) or `in_seconds`", true);
+          return text("schedule_reminder: provide `deliver_at` (ms timestamp), `in_seconds`, or `cron` expression", true);
         }
         const isSelf = !sArgs.to;
         let targetSpec;
@@ -48984,9 +49794,13 @@ ${lines.join(`
             targetSpec = to;
           }
         }
-        const result = await client.scheduleMessage(targetSpec, sArgs.message, deliverAt, true);
+        const result = await client.scheduleMessage(targetSpec, sArgs.message, deliverAt, true, sArgs.cron);
         if (!result)
           return text("schedule_reminder: broker did not acknowledge — check connection", true);
+        if (isCron) {
+          const nextFire = new Date(result.deliverAt).toISOString();
+          return text(isSelf ? `Recurring self-reminder scheduled (${result.scheduledId.slice(0, 8)}): "${sArgs.message.slice(0, 60)}" — cron: ${sArgs.cron}, next fire: ${nextFire}` : `Recurring reminder to "${sArgs.to}" scheduled (${result.scheduledId.slice(0, 8)}) — cron: ${sArgs.cron}, next fire: ${nextFire}`);
+        }
         const when = new Date(result.deliverAt).toISOString();
         return text(isSelf ? `Self-reminder scheduled (${result.scheduledId.slice(0, 8)}): "${sArgs.message.slice(0, 60)}" at ${when}` : `Reminder to "${sArgs.to}" scheduled (${result.scheduledId.slice(0, 8)}) for ${when}`);
       }
@@ -49398,6 +50212,72 @@ ${rows.join(`
           return text("No active streams.");
         const lines = streams.map((s) => `- **${s.name}** (${s.id.slice(0, 8)}…) by ${s.createdBy}, ${s.subscriberCount} subscriber(s)`);
         return text(lines.join(`
+`));
+      }
+      case "mesh_set_clock": {
+        const { speed } = args ?? {};
+        if (!speed || speed < 1 || speed > 100)
+          return text("mesh_set_clock: speed must be 1-100", true);
+        const client2 = allClients()[0];
+        if (!client2)
+          return text("mesh_set_clock: not connected", true);
+        const result = await client2.setClock(speed);
+        if (!result)
+          return text("mesh_set_clock: timed out", true);
+        return text([
+          `**Clock set to x${result.speed}**`,
+          `Paused: ${result.paused}`,
+          `Tick: ${result.tick}`,
+          `Sim time: ${result.simTime}`,
+          `Started at: ${result.startedAt}`
+        ].join(`
+`));
+      }
+      case "mesh_pause_clock": {
+        const client2 = allClients()[0];
+        if (!client2)
+          return text("mesh_pause_clock: not connected", true);
+        const result = await client2.pauseClock();
+        if (!result)
+          return text("mesh_pause_clock: timed out", true);
+        return text([
+          "**Clock paused**",
+          `Speed: x${result.speed}`,
+          `Tick: ${result.tick}`,
+          `Sim time: ${result.simTime}`
+        ].join(`
+`));
+      }
+      case "mesh_resume_clock": {
+        const client2 = allClients()[0];
+        if (!client2)
+          return text("mesh_resume_clock: not connected", true);
+        const result = await client2.resumeClock();
+        if (!result)
+          return text("mesh_resume_clock: timed out", true);
+        return text([
+          "**Clock resumed**",
+          `Speed: x${result.speed}`,
+          `Tick: ${result.tick}`,
+          `Sim time: ${result.simTime}`
+        ].join(`
+`));
+      }
+      case "mesh_clock": {
+        const client2 = allClients()[0];
+        if (!client2)
+          return text("mesh_clock: not connected", true);
+        const result = await client2.getClock();
+        if (!result)
+          return text("mesh_clock: timed out", true);
+        const statusLabel = result.speed === 0 ? "not started" : result.paused ? "paused" : "running";
+        return text([
+          `**Clock status: ${statusLabel}**`,
+          `Speed: x${result.speed}`,
+          `Tick: ${result.tick}`,
+          `Sim time: ${result.simTime}`,
+          `Started at: ${result.startedAt}`
+        ].join(`
 `));
       }
       case "mesh_info": {
@@ -49423,6 +50303,89 @@ ${rows.join(`
         return text(lines.join(`
 `));
       }
+      case "mesh_stats": {
+        const clients2 = allClients();
+        if (clients2.length === 0)
+          return text("mesh_stats: no joined meshes", true);
+        const sections = [];
+        for (const c of clients2) {
+          const peers = await c.listPeers();
+          const header = `## ${c.meshSlug}`;
+          const rows = peers.map((p) => {
+            const s = p.stats;
+            if (!s)
+              return `| ${p.displayName} | - | - | - | - | - |`;
+            const up = s.uptime != null ? `${Math.floor(s.uptime / 60)}m` : "-";
+            return `| ${p.displayName} | ${s.messagesIn ?? 0} | ${s.messagesOut ?? 0} | ${s.toolCalls ?? 0} | ${up} | ${s.errors ?? 0} |`;
+          });
+          sections.push(`${header}
+| Peer | Msgs In | Msgs Out | Tool Calls | Uptime | Errors |
+|------|---------|----------|------------|--------|--------|
+${rows.join(`
+`)}`);
+        }
+        return text(sections.join(`
+
+`));
+      }
+      case "share_skill": {
+        const { name: skillName, description: skillDesc, instructions: skillInstr, tags: skillTags } = args ?? {};
+        if (!skillName || !skillDesc || !skillInstr)
+          return text("share_skill: `name`, `description`, and `instructions` required", true);
+        const client2 = allClients()[0];
+        if (!client2)
+          return text("share_skill: not connected", true);
+        const result = await client2.shareSkill(skillName, skillDesc, skillInstr, skillTags);
+        if (!result)
+          return text("share_skill: broker did not acknowledge", true);
+        return text(`Skill "${skillName}" published to the mesh.`);
+      }
+      case "get_skill": {
+        const { name: gsName } = args ?? {};
+        if (!gsName)
+          return text("get_skill: `name` required", true);
+        const client2 = allClients()[0];
+        if (!client2)
+          return text("get_skill: not connected", true);
+        const skill = await client2.getSkill(gsName);
+        if (!skill)
+          return text(`Skill "${gsName}" not found in the mesh.`);
+        return text(`# Skill: ${skill.name}
+
+**Description:** ${skill.description}
+**Author:** ${skill.author}
+**Tags:** ${skill.tags.length ? skill.tags.join(", ") : "none"}
+**Created:** ${skill.createdAt}
+
+---
+
+## Instructions
+
+${skill.instructions}`);
+      }
+      case "list_skills": {
+        const { query: skillQuery } = args ?? {};
+        const client2 = allClients()[0];
+        if (!client2)
+          return text("list_skills: not connected", true);
+        const skills = await client2.listSkills(skillQuery);
+        if (skills.length === 0)
+          return text(skillQuery ? `No skills found for "${skillQuery}".` : "No skills in the mesh yet.");
+        const lines = skills.map((s) => `- **${s.name}**: ${s.description}${s.tags.length ? ` [${s.tags.join(", ")}]` : ""} (by ${s.author})`);
+        return text(`${skills.length} skill(s):
+${lines.join(`
+`)}`);
+      }
+      case "remove_skill": {
+        const { name: rsName } = args ?? {};
+        if (!rsName)
+          return text("remove_skill: `name` required", true);
+        const client2 = allClients()[0];
+        if (!client2)
+          return text("remove_skill: not connected", true);
+        const removed = await client2.removeSkill(rsName);
+        return text(removed ? `Skill "${rsName}" removed.` : `Skill "${rsName}" not found.`, !removed);
+      }
       case "ping_mesh": {
         const { priorities: pingPriorities } = args ?? {};
         const toTest = pingPriorities ?? ["now", "next"];
@@ -49459,6 +50422,57 @@ ${rows.join(`
         return text(results.join(`
 `));
       }
+      case "mesh_mcp_register": {
+        const { server_name, description, tools: regTools } = args ?? {};
+        if (!server_name || !description || !regTools?.length)
+          return text("mesh_mcp_register: `server_name`, `description`, and `tools` required", true);
+        const client2 = allClients()[0];
+        if (!client2)
+          return text("mesh_mcp_register: not connected", true);
+        const result = await client2.mcpRegister(server_name, description, regTools);
+        if (!result)
+          return text("mesh_mcp_register: broker did not acknowledge", true);
+        return text(`Registered MCP server "${result.serverName}" with ${result.toolCount} tool(s). Other peers can now call its tools via mesh_tool_call.`);
+      }
+      case "mesh_mcp_list": {
+        const client2 = allClients()[0];
+        if (!client2)
+          return text("mesh_mcp_list: not connected", true);
+        const servers = await client2.mcpList();
+        if (servers.length === 0)
+          return text("No MCP servers registered in the mesh.");
+        const lines = servers.map((s) => {
+          const toolList = s.tools.map((t) => `    - **${t.name}**: ${t.description}`).join(`
+`);
+          return `- **${s.name}** (hosted by ${s.hostedBy}): ${s.description}
+${toolList}`;
+        });
+        return text(`${servers.length} MCP server(s) in mesh:
+${lines.join(`
+`)}`);
+      }
+      case "mesh_tool_call": {
+        const { server_name: callServer, tool_name: callTool, args: callArgs } = args ?? {};
+        if (!callServer || !callTool)
+          return text("mesh_tool_call: `server_name` and `tool_name` required", true);
+        const client2 = allClients()[0];
+        if (!client2)
+          return text("mesh_tool_call: not connected", true);
+        const callResult = await client2.mcpCall(callServer, callTool, callArgs ?? {});
+        if (callResult.error)
+          return text(`mesh_tool_call error: ${callResult.error}`, true);
+        return text(typeof callResult.result === "string" ? callResult.result : JSON.stringify(callResult.result, null, 2));
+      }
+      case "mesh_mcp_remove": {
+        const { server_name: rmServer } = args ?? {};
+        if (!rmServer)
+          return text("mesh_mcp_remove: `server_name` required", true);
+        const client2 = allClients()[0];
+        if (!client2)
+          return text("mesh_mcp_remove: not connected", true);
+        await client2.mcpUnregister(rmServer);
+        return text(`Unregistered MCP server "${rmServer}" from the mesh.`);
+      }
       case "grant_file_access": {
         const { fileId, to: grantTo } = args ?? {};
         if (!fileId || !grantTo)
@@ -49491,6 +50505,117 @@ ${rows.join(`
           return text("grant_file_access: broker did not confirm", true);
         return text(`Access granted: ${targetPeer.displayName} can now download file ${fileId}`);
       }
+      case "read_peer_file": {
+        const { peer: peerName, path: filePath } = args ?? {};
+        if (!peerName || !filePath)
+          return text("read_peer_file: `peer` and `path` required", true);
+        const client2 = allClients()[0];
+        if (!client2)
+          return text("read_peer_file: not connected", true);
+        const peers = await client2.listPeers();
+        const nameLower = peerName.toLowerCase();
+        let targetPubkey = null;
+        if (/^[0-9a-f]{64}$/.test(peerName)) {
+          targetPubkey = peerName;
+        } else {
+          const match = peers.find((p) => p.displayName.toLowerCase() === nameLower);
+          if (!match) {
+            const partials = peers.filter((p) => p.displayName.toLowerCase().includes(nameLower));
+            if (partials.length === 1) {
+              targetPubkey = partials[0].pubkey;
+            } else {
+              const names = peers.map((p) => p.displayName).join(", ");
+              return text(`read_peer_file: peer "${peerName}" not found. Online: ${names || "(none)"}`, true);
+            }
+          } else {
+            targetPubkey = match.pubkey;
+          }
+        }
+        const result = await client2.requestFile(targetPubkey, filePath);
+        if (result.error)
+          return text(`read_peer_file: ${result.error}`, true);
+        if (!result.content)
+          return text("read_peer_file: empty response from peer", true);
+        try {
+          const decoded = Buffer.from(result.content, "base64").toString("utf-8");
+          return text(decoded);
+        } catch {
+          return text("read_peer_file: failed to decode file content (binary file?)", true);
+        }
+      }
+      case "list_peer_files": {
+        const { peer: peerName, path: dirPath, pattern } = args ?? {};
+        if (!peerName)
+          return text("list_peer_files: `peer` required", true);
+        const client2 = allClients()[0];
+        if (!client2)
+          return text("list_peer_files: not connected", true);
+        const peers = await client2.listPeers();
+        const nameLower = peerName.toLowerCase();
+        let targetPubkey = null;
+        if (/^[0-9a-f]{64}$/.test(peerName)) {
+          targetPubkey = peerName;
+        } else {
+          const match = peers.find((p) => p.displayName.toLowerCase() === nameLower);
+          if (!match) {
+            const partials = peers.filter((p) => p.displayName.toLowerCase().includes(nameLower));
+            if (partials.length === 1) {
+              targetPubkey = partials[0].pubkey;
+            } else {
+              const names = peers.map((p) => p.displayName).join(", ");
+              return text(`list_peer_files: peer "${peerName}" not found. Online: ${names || "(none)"}`, true);
+            }
+          } else {
+            targetPubkey = match.pubkey;
+          }
+        }
+        const result = await client2.requestDir(targetPubkey, dirPath ?? ".", pattern);
+        if (result.error)
+          return text(`list_peer_files: ${result.error}`, true);
+        if (!result.entries || result.entries.length === 0)
+          return text("No files found.");
+        return text(result.entries.join(`
+`));
+      }
+      case "create_webhook": {
+        const { name: whName } = args ?? {};
+        if (!whName)
+          return text("create_webhook: `name` required", true);
+        const client2 = allClients()[0];
+        if (!client2)
+          return text("create_webhook: not connected", true);
+        const wh = await client2.createWebhook(whName);
+        if (!wh)
+          return text("create_webhook: broker did not acknowledge — check connection", true);
+        return text(`Webhook **${wh.name}** created.
+
+URL: ${wh.url}
+Secret: ${wh.secret}
+
+External services can POST JSON to this URL. The payload will be pushed to all connected mesh peers.`);
+      }
+      case "list_webhooks": {
+        const client2 = allClients()[0];
+        if (!client2)
+          return text("list_webhooks: not connected", true);
+        const webhooks = await client2.listWebhooks();
+        if (webhooks.length === 0)
+          return text("No active webhooks.");
+        const lines = webhooks.map((w) => `- **${w.name}** — ${w.url} (created ${w.createdAt})`);
+        return text(`${webhooks.length} webhook(s):
+${lines.join(`
+`)}`);
+      }
+      case "delete_webhook": {
+        const { name: delName } = args ?? {};
+        if (!delName)
+          return text("delete_webhook: `name` required", true);
+        const client2 = allClients()[0];
+        if (!client2)
+          return text("delete_webhook: not connected", true);
+        const ok = await client2.deleteWebhook(delName);
+        return text(ok ? `Webhook "${delName}" deactivated.` : `Failed to deactivate webhook "${delName}".`, !ok);
+      }
       default:
         return text(`Unknown tool: ${name}`, true);
     }
@@ -49502,6 +50627,44 @@ ${rows.join(`
     client2.onPush(async (msg) => {
       if (messageMode === "off")
         return;
+      if (msg.subtype === "system" && msg.event) {
+        const eventName = msg.event;
+        const data = msg.eventData ?? {};
+        let content2;
+        if (eventName === "tick") {
+          const tick = data.tick ?? 0;
+          const simTime = String(data.simTime ?? "").replace("T", " ").replace(/\..*/, "");
+          const speed = data.speed ?? 1;
+          content2 = `[heartbeat] tick ${tick} | sim time: ${simTime} | speed: x${speed}`;
+        } else if (eventName === "peer_joined") {
+          content2 = `[system] Peer "${data.name ?? "unknown"}" joined the mesh`;
+        } else if (eventName === "peer_left") {
+          content2 = `[system] Peer "${data.name ?? "unknown"}" left the mesh`;
+        } else {
+          content2 = `[system] ${eventName}: ${JSON.stringify(data)}`;
+        }
+        try {
+          await server.notification({
+            method: "notifications/claude/channel",
+            params: {
+              content: content2,
+              meta: {
+                kind: "system",
+                event: eventName,
+                mesh_slug: client2.meshSlug,
+                mesh_id: client2.meshId,
+                ...Object.keys(data).length > 0 ? { eventData: data } : {}
+              }
+            }
+          });
+          process.stderr.write(`[claudemesh] system: ${content2}
+`);
+        } catch (pushErr) {
+          process.stderr.write(`[claudemesh] system push FAILED: ${pushErr}
+`);
+        }
+        return;
+      }
       const fromPubkey = msg.senderPubkey || "";
       const fromName = fromPubkey ? await resolvePeerName(client2, fromPubkey) : "unknown";
       if (messageMode === "inbox") {
@@ -49600,6 +50763,7 @@ ${rows.join(`
 }
 
 // src/commands/install.ts
+init_config();
 import {
   chmodSync as chmodSync2,
   copyFileSync,
@@ -49725,47 +50889,51 @@ function writeClaudeSettings(obj) {
 `, "utf-8");
 }
 var CLAUDEMESH_TOOLS = [
-  "mcp__claudemesh__send_message",
-  "mcp__claudemesh__list_peers",
+  "mcp__claudemesh__cancel_scheduled",
   "mcp__claudemesh__check_messages",
-  "mcp__claudemesh__set_summary",
-  "mcp__claudemesh__set_status",
-  "mcp__claudemesh__join_group",
-  "mcp__claudemesh__leave_group",
-  "mcp__claudemesh__get_state",
-  "mcp__claudemesh__set_state",
-  "mcp__claudemesh__list_state",
-  "mcp__claudemesh__remember",
-  "mcp__claudemesh__recall",
+  "mcp__claudemesh__claim_task",
+  "mcp__claudemesh__complete_task",
+  "mcp__claudemesh__create_stream",
+  "mcp__claudemesh__create_task",
+  "mcp__claudemesh__delete_file",
+  "mcp__claudemesh__file_status",
   "mcp__claudemesh__forget",
-  "mcp__claudemesh__share_file",
+  "mcp__claudemesh__get_context",
   "mcp__claudemesh__get_file",
-  "mcp__claudemesh__list_files",
-  "mcp__claudemesh__file_status",
-  "mcp__claudemesh__delete_file",
-  "mcp__claudemesh__vector_store",
-  "mcp__claudemesh__vector_search",
-  "mcp__claudemesh__vector_delete",
-  "mcp__claudemesh__list_collections",
-  "mcp__claudemesh__graph_query",
+  "mcp__claudemesh__get_state",
+  "mcp__claudemesh__grant_file_access",
   "mcp__claudemesh__graph_execute",
-  "mcp__claudemesh__mesh_info",
-  "mcp__claudemesh__ping_mesh",
-  "mcp__claudemesh__message_status",
-  "mcp__claudemesh__share_context",
-  "mcp__claudemesh__get_context",
+  "mcp__claudemesh__graph_query",
+  "mcp__claudemesh__join_group",
+  "mcp__claudemesh__leave_group",
+  "mcp__claudemesh__list_collections",
   "mcp__claudemesh__list_contexts",
-  "mcp__claudemesh__create_task",
-  "mcp__claudemesh__claim_task",
-  "mcp__claudemesh__complete_task",
-  "mcp__claudemesh__list_tasks",
-  "mcp__claudemesh__create_stream",
-  "mcp__claudemesh__publish",
-  "mcp__claudemesh__subscribe",
+  "mcp__claudemesh__list_files",
+  "mcp__claudemesh__list_peers",
+  "mcp__claudemesh__list_scheduled",
+  "mcp__claudemesh__list_state",
   "mcp__claudemesh__list_streams",
+  "mcp__claudemesh__list_tasks",
   "mcp__claudemesh__mesh_execute",
+  "mcp__claudemesh__mesh_info",
   "mcp__claudemesh__mesh_query",
-  "mcp__claudemesh__mesh_schema"
+  "mcp__claudemesh__mesh_schema",
+  "mcp__claudemesh__message_status",
+  "mcp__claudemesh__ping_mesh",
+  "mcp__claudemesh__publish",
+  "mcp__claudemesh__recall",
+  "mcp__claudemesh__remember",
+  "mcp__claudemesh__schedule_reminder",
+  "mcp__claudemesh__send_message",
+  "mcp__claudemesh__set_state",
+  "mcp__claudemesh__set_status",
+  "mcp__claudemesh__set_summary",
+  "mcp__claudemesh__share_context",
+  "mcp__claudemesh__share_file",
+  "mcp__claudemesh__subscribe",
+  "mcp__claudemesh__vector_delete",
+  "mcp__claudemesh__vector_search",
+  "mcp__claudemesh__vector_store"
 ];
 function installAllowedTools() {
   const settings = readClaudeSettings();
@@ -49896,10 +51064,22 @@ function runInstall(args = []) {
   } else {
     console.log(dim("· Hooks skipped (--no-hooks)"));
   }
+  let hasMeshes = false;
+  try {
+    const meshConfig = loadConfig();
+    hasMeshes = meshConfig.meshes.length > 0;
+  } catch {}
   console.log("");
   console.log(yellow(bold2("⚠  RESTART CLAUDE CODE")) + yellow(" for MCP tools to appear."));
-  console.log("");
-  console.log(`Next: ${bold2("claudemesh join https://claudemesh.com/join/<token>")}`);
+  if (!hasMeshes) {
+    console.log("");
+    console.log(yellow("No meshes joined.") + " To connect with peers:");
+    console.log(`  ${bold2("claudemesh join <invite-url>")}` + dim("   — join an existing mesh"));
+    console.log(`  ${dim("Create one at")} ${bold2("https://claudemesh.com/dashboard")}`);
+  } else {
+    console.log("");
+    console.log(`Next: ${bold2("claudemesh join https://claudemesh.com/join/<token>")}`);
+  }
   console.log("");
   console.log(yellow("⚠  For real-time push messages from peers, launch with:"));
   console.log(`     ${bold2("claudemesh launch")}` + dim("    (or: claude --dangerously-load-development-channels server:claudemesh)"));
@@ -50559,7 +51739,7 @@ init_config();
 // package.json
 var package_default = {
   name: "claudemesh-cli",
-  version: "0.6.8",
+  version: "0.7.0",
   description: "Claude Code MCP client for claudemesh — peer mesh messaging between Claude sessions.",
   keywords: [
     "claude-code",
@@ -51025,8 +52205,19 @@ async function runPeers(flags) {
       const groups = p.groups.length ? " [" + p.groups.map((g) => `@${g.name}${g.role ? `:${g.role}` : ""}`).join(", ") + "]" : "";
       const statusIcon = p.status === "working" ? yellow("●") : green("●");
       const name = bold2(p.displayName);
+      const meta2 = [];
+      if (p.peerType)
+        meta2.push(p.peerType);
+      if (p.channel)
+        meta2.push(p.channel);
+      if (p.model)
+        meta2.push(p.model);
+      const metaStr = meta2.length ? dim(` (${meta2.join(", ")})`) : "";
+      const cwdStr = p.cwd ? dim(`  cwd: ${p.cwd}`) : "";
       const summary = p.summary ? dim(`  ${p.summary}`) : "";
-      console.log(`  ${statusIcon} ${name}${groups}${summary}`);
+      console.log(`  ${statusIcon} ${name}${groups}${metaStr}${summary}`);
+      if (cwdStr)
+        console.log(`    ${cwdStr}`);
     }
     console.log("");
   });
@@ -51313,13 +52504,15 @@ async function runRemind(flags, positional) {
   if (!message) {
     console.error("Usage: claudemesh remind <message> --in <duration>");
     console.error("       claudemesh remind <message> --at <time>");
+    console.error('       claudemesh remind <message> --cron "0 */2 * * *"');
     console.error("       claudemesh remind list");
     console.error("       claudemesh remind cancel <id>");
     process.exit(1);
   }
-  const deliverAt = parseDeliverAt(flags);
-  if (deliverAt === null) {
-    console.error('Specify when: --in <duration> (e.g. "2h", "30m") or --at <time> (e.g. "15:00")');
+  const isCron = !!flags.cron;
+  const deliverAt = isCron ? 0 : parseDeliverAt(flags);
+  if (!isCron && deliverAt === null) {
+    console.error('Specify when: --in <duration> (e.g. "2h", "30m"), --at <time> (e.g. "15:00"), or --cron <expression>');
     process.exit(1);
   }
   await withMesh({ meshSlug: flags.mesh ?? null }, async (client2) => {
@@ -51339,7 +52532,7 @@ async function runRemind(flags, positional) {
     } else {
       targetSpec = client2.getSessionPubkey() ?? "*";
     }
-    const result = await client2.scheduleMessage(targetSpec, message, deliverAt);
+    const result = await client2.scheduleMessage(targetSpec, message, deliverAt ?? 0, false, flags.cron);
     if (!result) {
       console.error("✗ Broker did not acknowledge — check connection");
       process.exit(1);
@@ -51348,34 +52541,170 @@ async function runRemind(flags, positional) {
       console.log(JSON.stringify(result));
       return;
     }
-    const when = new Date(result.deliverAt).toLocaleString();
     const toLabel = !flags.to || flags.to === "self" ? "yourself" : flags.to;
-    console.log(`✓ Reminder set (${result.scheduledId.slice(0, 8)}): "${message}" → ${toLabel} at ${when}`);
+    if (isCron) {
+      const nextFire = new Date(result.deliverAt).toLocaleString();
+      console.log(`✓ Recurring reminder set (${result.scheduledId.slice(0, 8)}): "${message}" → ${toLabel} — cron: ${flags.cron}, next fire: ${nextFire}`);
+    } else {
+      const when = new Date(result.deliverAt).toLocaleString();
+      console.log(`✓ Reminder set (${result.scheduledId.slice(0, 8)}): "${message}" → ${toLabel} at ${when}`);
+    }
   });
 }
+// src/templates/dev-team.json
+var dev_team_default = {
+  name: "dev-team",
+  description: "Software development team with frontend, backend, and devops groups",
+  groups: [
+    { name: "frontend", roles: ["lead", "member"] },
+    { name: "backend", roles: ["lead", "member"] },
+    { name: "devops", roles: ["lead", "member"] },
+    { name: "qa", roles: ["lead", "member"] }
+  ],
+  stateKeys: {
+    sprint: "current",
+    "deploy-frozen": "false",
+    "pr-queue": "[]"
+  },
+  suggestedRoles: ["lead", "member", "reviewer"],
+  systemPromptHint: "You are part of a dev team. Coordinate with @frontend, @backend, @devops groups. Check state keys for sprint status and deploy freezes before making changes."
+};
+// src/templates/research.json
+var research_default = {
+  name: "research",
+  description: "Research and analysis team focused on deep investigation and knowledge sharing",
+  groups: [
+    { name: "analysis", roles: ["lead", "analyst"] },
+    { name: "writing", roles: ["lead", "writer", "reviewer"] },
+    { name: "data", roles: ["engineer", "analyst"] }
+  ],
+  stateKeys: {
+    "research-topic": "",
+    phase: "exploration",
+    "findings-count": "0"
+  },
+  suggestedRoles: ["lead", "analyst", "writer", "reviewer"],
+  systemPromptHint: "You are part of a research team. Share findings via remember(), use recall() before starting new analysis. Coordinate phases through state keys."
+};
+// src/templates/ops-incident.json
+var ops_incident_default = {
+  name: "ops-incident",
+  description: "Incident response team with oncall, comms, and engineering groups",
+  groups: [
+    { name: "oncall", roles: ["primary", "secondary"] },
+    { name: "comms", roles: ["lead", "scribe"] },
+    { name: "engineering", roles: ["lead", "responder"] }
+  ],
+  stateKeys: {
+    "incident-status": "investigating",
+    severity: "unknown",
+    commander: "",
+    timeline: "[]"
+  },
+  suggestedRoles: ["commander", "primary-oncall", "scribe", "responder"],
+  systemPromptHint: "INCIDENT MODE. Priority: now for all messages. Update incident-status state. Commander coordinates. Scribe maintains timeline. Engineering fixes."
+};
+// src/templates/simulation.json
+var simulation_default = {
+  name: "simulation",
+  description: "Load testing simulation with configurable time multiplier and user personas",
+  groups: [
+    { name: "personas", roles: ["admin", "user", "customer"] },
+    { name: "observers", roles: ["monitor", "analyst"] },
+    { name: "control", roles: ["orchestrator"] }
+  ],
+  stateKeys: {
+    "clock-speed": "x1",
+    "sim-status": "paused",
+    "tick-count": "0",
+    scenario: ""
+  },
+  suggestedRoles: ["orchestrator", "persona", "monitor"],
+  systemPromptHint: "SIMULATION MODE. Follow the clock-speed state for time multiplier. Act according to your persona role and the simulated time. Report actions to @observers."
+};
+// src/templates/personal.json
+var personal_default = {
+  name: "personal",
+  description: "Private mesh for a single user — all sessions auto-join",
+  groups: [],
+  stateKeys: {
+    focus: "",
+    todos: "[]"
+  },
+  suggestedRoles: [],
+  systemPromptHint: "Personal workspace. All your Claude Code sessions share this mesh. Use state keys to track focus and todos across sessions."
+};
+
+// src/templates/index.ts
+var TEMPLATES = {
+  "dev-team": dev_team_default,
+  research: research_default,
+  "ops-incident": ops_incident_default,
+  simulation: simulation_default,
+  personal: personal_default
+};
+function listTemplates() {
+  return Object.values(TEMPLATES);
+}
+function getTemplate(name) {
+  return TEMPLATES[name];
+}
+
+// src/commands/create.ts
+function runCreate(args) {
+  if (args["list-templates"]) {
+    console.log(`Available mesh templates:
+`);
+    for (const t of listTemplates()) {
+      console.log(`  ${t.name}`);
+      console.log(`    ${t.description}`);
+      console.log(`    Groups: ${t.groups.map((g) => g.name).join(", ") || "(none)"}`);
+      console.log(`    State keys: ${Object.keys(t.stateKeys).join(", ") || "(none)"}`);
+      console.log();
+    }
+    return;
+  }
+  const templateName = args.template;
+  if (templateName) {
+    const template = getTemplate(templateName);
+    if (!template) {
+      console.error(`Unknown template "${templateName}". Use --list-templates to see available options.`);
+      process.exit(1);
+    }
+    console.log(`Template "${template.name}" loaded:`);
+    console.log(`  Groups: ${template.groups.map((g) => `@${g.name}`).join(", ")}`);
+    console.log(`  State keys: ${Object.keys(template.stateKeys).join(", ")}`);
+    console.log(`  Hint: ${template.systemPromptHint.slice(0, 80)}...`);
+    console.log();
+    console.log("Template applied. Use `claudemesh launch` with --groups to join the predefined groups.");
+    return;
+  }
+  console.log("Usage: claudemesh create --template <name>");
+  console.log("       claudemesh create --list-templates");
+}
 
 // src/index.ts
 var launch = defineCommand({
   meta: {
     name: "launch",
-    description: "Launch Claude Code connected to a mesh with real-time peer messaging"
+    description: "Spawn a Claude Code session with mesh connectivity and MCP tools"
   },
   args: {
     name: {
       type: "string",
-      description: "Display name for this session"
+      description: "Display name visible to other peers"
     },
     role: {
       type: "string",
-      description: "Role tag (dev, lead, analyst — free-form)"
+      description: "Free-form role tag: `dev`, `lead`, `analyst`, etc"
     },
     groups: {
       type: "string",
-      description: 'Groups to join: "group:role,group2" — colon sets role. Hierarchy via slash: "eng/frontend:lead"'
+      description: 'Groups to join as `group:role,...` — e.g. `"eng/frontend:lead,qa:member"`'
     },
     mesh: {
       type: "string",
-      description: "Select mesh by slug (interactive picker if omitted and >1 joined)"
+      description: "Mesh slug (interactive picker if omitted and >1 joined)"
     },
     join: {
       type: "string",
@@ -51383,21 +52712,21 @@ var launch = defineCommand({
     },
     "message-mode": {
       type: "string",
-      description: "push (default) | inbox | off — controls how peer messages are delivered"
+      description: '`"push"` (default) | `"inbox"` | `"off"` — how peer messages arrive'
     },
     "system-prompt": {
       type: "string",
-      description: "Set Claude's system prompt for this session"
+      description: "Custom system prompt for this Claude session"
     },
     yes: {
       type: "boolean",
       alias: "y",
-      description: "Skip permission confirmation",
+      description: "Skip the --dangerously-skip-permissions confirmation",
       default: false
     },
     quiet: {
       type: "boolean",
-      description: "Skip banner and all interactive prompts",
+      description: "Suppress banner and interactive prompts",
       default: false
     }
   },
@@ -51408,7 +52737,7 @@ var launch = defineCommand({
 var install = defineCommand({
   meta: {
     name: "install",
-    description: "Register MCP server + status hooks with Claude Code"
+    description: "Register MCP server and status hooks with Claude Code"
   },
   args: {
     "no-hooks": {
@@ -51424,12 +52753,12 @@ var install = defineCommand({
 var join7 = defineCommand({
   meta: {
     name: "join",
-    description: "Join a mesh via invite URL"
+    description: "Join a mesh via invite URL or token"
   },
   args: {
     url: {
       type: "positional",
-      description: "Invite URL (https://claudemesh.com/join/...)",
+      description: "Invite URL (`https://claudemesh.com/join/...`) or token",
       required: true
     }
   },
@@ -51440,12 +52769,12 @@ var join7 = defineCommand({
 var leave = defineCommand({
   meta: {
     name: "leave",
-    description: "Leave a joined mesh"
+    description: "Leave a joined mesh and remove its local keypair"
   },
   args: {
     slug: {
       type: "positional",
-      description: "Mesh slug to leave",
+      description: "Mesh slug to leave (see `claudemesh list`)",
       required: true
     }
   },
@@ -51461,23 +52790,33 @@ var main = defineCommand({
   },
   subCommands: {
     launch,
+    create: defineCommand({
+      meta: { name: "create", description: "Create a new mesh from a template" },
+      args: {
+        template: { type: "string", description: "Template name: `dev-team`, `research`, `ops-incident`, `simulation`, `personal`" },
+        "list-templates": { type: "boolean", description: "List available templates and exit", default: false }
+      },
+      run({ args }) {
+        runCreate(args);
+      }
+    }),
     install,
     uninstall: defineCommand({
-      meta: { name: "uninstall", description: "Remove MCP server and hooks" },
+      meta: { name: "uninstall", description: "Remove MCP server and hooks from Claude Code config" },
       run() {
         runUninstall();
       }
     }),
     join: join7,
     list: defineCommand({
-      meta: { name: "list", description: "Show joined meshes and identities" },
+      meta: { name: "list", description: "Show joined meshes, slugs, and local identities" },
       run() {
         runList();
       }
     }),
     leave,
     peers: defineCommand({
-      meta: { name: "peers", description: "List connected peers in the mesh" },
+      meta: { name: "peers", description: "List online peers with status, summary, and groups" },
       args: {
         mesh: { type: "string", description: "Mesh slug (auto-selected if only one joined)" },
         json: { type: "boolean", description: "Output as JSON", default: false }
@@ -51487,34 +52826,34 @@ var main = defineCommand({
       }
     }),
     send: defineCommand({
-      meta: { name: "send", description: "Send a message to a peer, group, or broadcast" },
+      meta: { name: "send", description: "Send a message to a peer, group, or all peers" },
       args: {
-        to: { type: "positional", description: "Recipient: display name, @group, pubkey, or *", required: true },
+        to: { type: "positional", description: "Recipient: display name, `@group`, `*` (broadcast), or pubkey hex", required: true },
         message: { type: "positional", description: "Message text", required: true },
         mesh: { type: "string", description: "Mesh slug (auto-selected if only one joined)" },
-        priority: { type: "string", description: "now | next (default) | low" }
+        priority: { type: "string", description: '`"now"` | `"next"` (default) | `"low"`' }
       },
       async run({ args }) {
         await runSend(args, args.to, args.message);
       }
     }),
     inbox: defineCommand({
-      meta: { name: "inbox", description: "Read pending peer messages" },
+      meta: { name: "inbox", description: "Drain pending inbound messages" },
       args: {
         mesh: { type: "string", description: "Mesh slug (auto-selected if only one joined)" },
         json: { type: "boolean", description: "Output as JSON", default: false },
-        wait: { type: "string", description: "Seconds to wait for broker delivery (default: 1)" }
+        wait: { type: "string", description: "Seconds to wait for broker delivery (default: `1`)" }
       },
       async run({ args }) {
         await runInbox({ ...args, wait: args.wait ? parseInt(args.wait, 10) : undefined });
       }
     }),
     state: defineCommand({
-      meta: { name: "state", description: "Read or write shared mesh state" },
+      meta: { name: "state", description: "Get, set, or list shared key-value state in the mesh" },
       args: {
-        action: { type: "positional", description: "get | set | list", required: true },
-        key: { type: "positional", description: "State key (required for get/set)" },
-        value: { type: "positional", description: "Value to set (required for set)" },
+        action: { type: "positional", description: "`get <key>` | `set <key> <value>` | `list`", required: true },
+        key: { type: "positional", description: "State key (required for `get` and `set`)" },
+        value: { type: "positional", description: "Value to store (required for `set`)" },
         mesh: { type: "string", description: "Mesh slug (auto-selected if only one joined)" },
         json: { type: "boolean", description: "Output as JSON", default: false }
       },
@@ -51550,11 +52889,11 @@ var main = defineCommand({
       }
     }),
     remember: defineCommand({
-      meta: { name: "remember", description: "Store a memory in the mesh (accessible to all peers)" },
+      meta: { name: "remember", description: "Store a persistent memory visible to all peers" },
       args: {
-        content: { type: "positional", description: "Text to remember", required: true },
+        content: { type: "positional", description: "Text to store", required: true },
         mesh: { type: "string", description: "Mesh slug (auto-selected if only one joined)" },
-        tags: { type: "string", description: "Comma-separated tags (e.g. task,context)" },
+        tags: { type: "string", description: "Comma-separated tags, e.g. `task,context`" },
         json: { type: "boolean", description: "Output as JSON", default: false }
       },
       async run({ args }) {
@@ -51562,9 +52901,9 @@ var main = defineCommand({
       }
     }),
     recall: defineCommand({
-      meta: { name: "recall", description: "Search mesh memory by keyword or phrase" },
+      meta: { name: "recall", description: "Search mesh memories by keyword or phrase" },
       args: {
-        query: { type: "positional", description: "Search query", required: true },
+        query: { type: "positional", description: "Full-text search query", required: true },
         mesh: { type: "string", description: "Mesh slug (auto-selected if only one joined)" },
         json: { type: "boolean", description: "Output as JSON", default: false }
       },
@@ -51573,13 +52912,14 @@ var main = defineCommand({
       }
     }),
     remind: defineCommand({
-      meta: { name: "remind", description: "Schedule a reminder or delayed message via the broker" },
+      meta: { name: "remind", description: "Schedule a delayed message. Also: `remind list`, `remind cancel <id>`" },
       args: {
-        message: { type: "positional", description: "Message text, or: list | cancel <id>", required: false },
-        extra: { type: "positional", description: "Additional positional args", required: false },
-        in: { type: "string", description: 'Deliver after duration: "2h", "30m", "90s"' },
-        at: { type: "string", description: 'Deliver at time: "15:00" or ISO timestamp' },
-        to: { type: "string", description: "Recipient (default: self). Name, @group, pubkey, or *" },
+        message: { type: "positional", description: "Message text — or `list` / `cancel <id>` to manage reminders", required: false },
+        extra: { type: "positional", description: "Reminder ID for `cancel`", required: false },
+        in: { type: "string", description: 'Deliver after duration: `"2h"`, `"30m"`, `"90s"`' },
+        at: { type: "string", description: 'Deliver at time: `"15:00"` or ISO timestamp' },
+        cron: { type: "string", description: 'Recurring cron expression: `"0 */2 * * *"` (every 2h), `"30 9 * * 1-5"` (9:30 weekdays)' },
+        to: { type: "string", description: "Recipient (default: self). Name, `@group`, `*`, or pubkey" },
         mesh: { type: "string", description: "Mesh slug (auto-selected if only one joined)" },
         json: { type: "boolean", description: "Output as JSON", default: false }
       },
@@ -51589,31 +52929,31 @@ var main = defineCommand({
       }
     }),
     status: defineCommand({
-      meta: { name: "status", description: "Check broker reachability for each joined mesh" },
+      meta: { name: "status", description: "Check broker connectivity for each joined mesh" },
       async run() {
         await runStatus();
       }
     }),
     doctor: defineCommand({
-      meta: { name: "doctor", description: "Diagnose install, config, keypairs, and PATH" },
+      meta: { name: "doctor", description: "Diagnose install, config, keypairs, and PATH issues" },
       async run() {
         await runDoctor();
       }
     }),
     mcp: defineCommand({
-      meta: { name: "mcp", description: "Start MCP server (stdio — invoked by Claude Code, not users)" },
+      meta: { name: "mcp", description: "Start MCP server on stdio (called by Claude Code, not users)" },
       async run() {
         await startMcpServer();
       }
     }),
     "seed-test-mesh": defineCommand({
-      meta: { name: "seed-test-mesh", description: "Dev only: inject a mesh into config (skips invite flow)" },
+      meta: { name: "seed-test-mesh", description: "Dev: inject a mesh into local config, skip invite flow" },
       run({ rawArgs }) {
         runSeedTestMesh(rawArgs);
       }
     }),
     hook: defineCommand({
-      meta: { name: "hook", description: "Internal hook handler (invoked by Claude Code hooks)" },
+      meta: { name: "hook", description: "Internal: handle Claude Code hook events" },
       async run({ rawArgs }) {
         await runHook(rawArgs);
       }