claudemesh-cli 0.6.9 → 0.7.1

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.",
@@ -47413,6 +47453,148 @@ 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"
+        },
+        persistent: {
+          type: "boolean",
+          description: "If true, registration survives peer disconnect. Other peers see it as 'offline' until you reconnect. Default: false"
+        }
+      },
+      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.",
@@ -47426,6 +47608,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"]
+    }
   }
 ];
 
@@ -47511,10 +47748,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;
@@ -47566,6 +47814,7 @@ class BrokerClient {
             sessionId: `${process.pid}-${Date.now()}`,
             pid: process.pid,
             cwd: process.cwd(),
+            hostname: __require("os").hostname(),
             peerType: "ai",
             channel: "claude-code",
             model: process.env.CLAUDE_MODEL || undefined,
@@ -47596,6 +47845,19 @@ class BrokerClient {
           this.setConnStatus("open");
           this.reconnectAttempt = 0;
           this.flushOutbound();
+          this.startStatsReporting();
+          if (msg.restored) {
+            const groups = msg.restoredGroups ? msg.restoredGroups.map((g) => g.role ? `@${g.name}:${g.role}` : `@${g.name}`).join(", ") : "none";
+            process.stderr.write(`[claudemesh] session restored — last seen ${msg.lastSeenAt ?? "unknown"}, groups: ${groups}
+`);
+            if (msg.restoredStats) {
+              const rs = msg.restoredStats;
+              this._statsCounters.messagesIn = rs.messagesIn ?? 0;
+              this._statsCounters.messagesOut = rs.messagesOut ?? 0;
+              this._statsCounters.toolCalls = rs.toolCalls ?? 0;
+              this._statsCounters.errors = rs.errors ?? 0;
+            }
+          }
           resolve();
           return;
         }
@@ -47635,6 +47897,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" });
@@ -47692,6 +47955,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 [];
@@ -47709,6 +47982,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;
@@ -47841,6 +48142,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;
@@ -48139,7 +48444,105 @@ class BrokerClient {
     this.stateChangeHandlers.add(handler);
     return () => this.stateChangeHandlers.delete(handler);
   }
+  async mcpRegister(serverName, description, tools, persistent) {
+    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, ...persistent ? { persistent: true } : {}, _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;
@@ -48152,8 +48555,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)
@@ -48165,6 +48692,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) {
@@ -48202,6 +48864,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 ?? "");
@@ -48402,10 +49065,34 @@ class BrokerClient {
       }
       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 ?? ""),
@@ -48423,6 +49110,75 @@ class BrokerClient {
       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 === "peer_file_request_forward") {
+      this.handlePeerFileRequest(msg);
+      return;
+    }
+    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 === "peer_dir_request_forward") {
+      this.handlePeerDirRequest(msg);
+      return;
+    }
+    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") {
       this.debug(`broker error: ${msg.code} ${msg.message}`);
       const id = msg.id ? String(msg.id) : null;
@@ -48465,7 +49221,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;
@@ -48562,6 +49329,25 @@ function stopAll() {
 }
 
 // src/mcp/server.ts
+function relativeTime(isoStr) {
+  const then = new Date(isoStr).getTime();
+  if (isNaN(then))
+    return "unknown";
+  const diffMs = Date.now() - then;
+  if (diffMs < 0)
+    return "just now";
+  const seconds = Math.floor(diffMs / 1000);
+  if (seconds < 60)
+    return `${seconds}s ago`;
+  const minutes = Math.floor(seconds / 60);
+  if (minutes < 60)
+    return `${minutes}m ago`;
+  const hours = Math.floor(minutes / 60);
+  if (hours < 24)
+    return `${hours}h ago`;
+  const days = Math.floor(hours / 24);
+  return `${days} day${days !== 1 ? "s" : ""} ago`;
+}
 function text(msg, isError = false) {
   return {
     content: [{ type: "text", text: msg }],
@@ -48668,6 +49454,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. |
@@ -48704,6 +49492,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\`).
 
@@ -48726,9 +49520,14 @@ Shared key-value store scoped to the mesh. Use get_state/set_state for live coor
 ## Memory
 Persistent knowledge that survives across sessions. Use remember(content, tags?) to store lessons, decisions, and incidents. Use recall(query) to search before asking peers. New peers should recall at session start to load institutional knowledge.
 
-## Files
-share_file for persistent references, send_message(file:) for ephemeral attachments.
-Tags on shared files make them searchable. Use list_files to find what peers shared.
+## File access — decision guide
+Three ways to access files. Pick the right one:
+
+1. **Local peer (same machine, [local] tag):** Read files directly via filesystem using their \`cwd\` path from list_peers. No limit, instant. This is the default for local peers.
+2. **Remote peer (different machine, [remote] tag):** Use \`read_peer_file(peer, path)\` — relays through the mesh. **1 MB limit**, base64 encoded. Use \`list_peer_files\` to browse first.
+3. **Persistent sharing (any peer):** Use \`share_file(path)\` — uploads to mesh storage (MinIO). **No size limit**. All peers can download anytime via \`get_file\`. Use for files that need to persist or be shared with multiple peers.
+
+**Rule of thumb:** local peer → filesystem. Remote peer, small file → read_peer_file. Large file or needs to persist → share_file.
 
 ## Vectors
 Store and search semantic embeddings. Use vector_store to index content, vector_search to find similar content.
@@ -48767,6 +49566,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);
     }
@@ -48822,7 +49624,12 @@ No peers connected.`);
                 meta2.push(`model:${p.model}`);
               const metaStr = meta2.length ? ` {${meta2.join(", ")}}` : "";
               const cwdStr = p.cwd ? ` cwd:${p.cwd}` : "";
-              return `- **${p.displayName}** [${p.status}]${groupsStr}${metaStr} (${p.pubkey.slice(0, 12)}…)${cwdStr}${summary}`;
+              const locality = p.hostname && p.hostname === __require("os").hostname() ? "local" : "remote";
+              const localityTag = ` [${locality}]`;
+              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}]${localityTag}${hiddenTag}${groupsStr}${metaStr} (${p.pubkey.slice(0, 12)}…)${cwdStr}${summary}`;
             });
             sections.push(`${header}
 ${peerLines.join(`
@@ -48889,6 +49696,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)
@@ -49422,6 +50255,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": {
@@ -49447,6 +50346,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"];
@@ -49483,6 +50465,59 @@ ${rows.join(`
         return text(results.join(`
 `));
       }
+      case "mesh_mcp_register": {
+        const { server_name, description, tools: regTools, persistent: regPersistent } = 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, regPersistent);
+        if (!result)
+          return text("mesh_mcp_register: broker did not acknowledge", true);
+        const persistLabel = regPersistent ? " (persistent — survives disconnect)" : "";
+        return text(`Registered MCP server "${result.serverName}" with ${result.toolCount} tool(s)${persistLabel}. 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(`
+`);
+          const status = s.online === false ? ` [OFFLINE${s.offlineSince ? ` since ${s.offlineSince}` : ""}]` : "";
+          return `- **${s.name}** (hosted by ${s.hostedBy})${status}: ${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)
@@ -49515,6 +50550,128 @@ ${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 resolvedPeer = peers.find((p) => p.pubkey === targetPubkey);
+        const isLocal = resolvedPeer?.hostname && resolvedPeer.hostname === __require("os").hostname();
+        let localHint = "";
+        if (isLocal && resolvedPeer?.cwd) {
+          const directPath = __require("path").resolve(resolvedPeer.cwd, filePath);
+          localHint = `
+
+> **Hint:** This peer is LOCAL (same machine). Next time, read directly: \`${directPath}\` — faster, no size limit.
+
+`;
+        }
+        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(localHint + 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);
     }
@@ -49530,10 +50687,28 @@ ${rows.join(`
         const eventName = msg.event;
         const data = msg.eventData ?? {};
         let content2;
-        if (eventName === "peer_joined") {
+        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_returned") {
+          const peerName = String(data.name ?? "unknown");
+          const lastSeenAt = data.lastSeenAt ? relativeTime(String(data.lastSeenAt)) : "unknown";
+          const groups = Array.isArray(data.groups) ? data.groups.map((g) => g.role ? `@${g.name}:${g.role}` : `@${g.name}`).join(", ") : "";
+          const summary = data.summary ? ` Summary: "${data.summary}"` : "";
+          content2 = `[system] Welcome back, "${peerName}"! Last seen ${lastSeenAt}.${groups ? ` Restored: ${groups}` : ""}${summary}`;
         } else if (eventName === "peer_left") {
           content2 = `[system] Peer "${data.name ?? "unknown"}" left the mesh`;
+        } else if (eventName === "mcp_registered") {
+          const tools = Array.isArray(data.tools) ? data.tools.join(", ") : "";
+          content2 = `[system] New MCP server available: "${data.serverName}" (hosted by ${data.hostedBy}). Tools: ${tools}. Use mesh_tool_call to invoke.`;
+        } else if (eventName === "mcp_unregistered") {
+          content2 = `[system] MCP server "${data.serverName}" removed (was hosted by ${data.hostedBy})`;
+        } else if (eventName === "mcp_restored") {
+          content2 = `[system] MCP server "${data.serverName}" is back online (hosted by ${data.hostedBy})`;
         } else {
           content2 = `[system] ${eventName}: ${JSON.stringify(data)}`;
         }
@@ -49657,6 +50832,7 @@ ${rows.join(`
 }
 
 // src/commands/install.ts
+init_config();
 import {
   chmodSync as chmodSync2,
   copyFileSync,
@@ -49957,10 +51133,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)"));
@@ -50620,7 +51808,7 @@ init_config();
 // package.json
 var package_default = {
   name: "claudemesh-cli",
-  version: "0.6.9",
+  version: "0.7.1",
   description: "Claude Code MCP client for claudemesh — peer mesh messaging between Claude sessions.",
   keywords: [
     "claude-code",