claudemesh-cli 0.3.0 → 0.5.0

package/dist/index.js

@@ -46250,8 +46250,11 @@ var TOOLS = [
       type: "object",
       properties: {
         to: {
-          type: "string",
-          description: "Peer name, pubkey, @group, or #channel"
+          oneOf: [
+            { type: "string", description: "Peer name, pubkey, @group" },
+            { type: "array", items: { type: "string" }, description: "Multiple targets" }
+          ],
+          description: "Single target or array of targets"
         },
         message: { type: "string", description: "Message text" },
         priority: {
@@ -46415,6 +46418,333 @@ var TOOLS = [
       },
       required: ["id"]
     }
+  },
+  {
+    name: "share_file",
+    description: "Share a persistent file with the mesh. All current and future peers can access it.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        path: { type: "string", description: "Local file path to share" },
+        name: {
+          type: "string",
+          description: "Display name (defaults to filename)"
+        },
+        tags: {
+          type: "array",
+          items: { type: "string" },
+          description: "Tags for categorization"
+        }
+      },
+      required: ["path"]
+    }
+  },
+  {
+    name: "get_file",
+    description: "Download a shared file to a local path.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        id: { type: "string", description: "File ID" },
+        save_to: {
+          type: "string",
+          description: "Local path to save the file"
+        }
+      },
+      required: ["id", "save_to"]
+    }
+  },
+  {
+    name: "list_files",
+    description: "List files shared in the mesh.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        query: { type: "string", description: "Search by name or tags" },
+        from: { type: "string", description: "Filter by uploader name" }
+      }
+    }
+  },
+  {
+    name: "file_status",
+    description: "Check who has accessed a shared file.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        id: { type: "string", description: "File ID" }
+      },
+      required: ["id"]
+    }
+  },
+  {
+    name: "delete_file",
+    description: "Remove a shared file from the mesh.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        id: { type: "string", description: "File ID" }
+      },
+      required: ["id"]
+    }
+  },
+  {
+    name: "vector_store",
+    description: "Store an embedding in a per-mesh Qdrant collection. Auto-creates the collection on first use.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        collection: { type: "string", description: "Collection name" },
+        text: { type: "string", description: "Text to embed and store" },
+        metadata: {
+          type: "object",
+          description: "Optional metadata to attach"
+        }
+      },
+      required: ["collection", "text"]
+    }
+  },
+  {
+    name: "vector_search",
+    description: "Semantic search over stored embeddings in a collection.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        collection: { type: "string", description: "Collection name" },
+        query: { type: "string", description: "Search query text" },
+        limit: {
+          type: "number",
+          description: "Max results (default: 10)"
+        }
+      },
+      required: ["collection", "query"]
+    }
+  },
+  {
+    name: "vector_delete",
+    description: "Remove an embedding from a collection.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        collection: { type: "string", description: "Collection name" },
+        id: { type: "string", description: "Embedding ID to delete" }
+      },
+      required: ["collection", "id"]
+    }
+  },
+  {
+    name: "list_collections",
+    description: "List vector collections in this mesh.",
+    inputSchema: { type: "object", properties: {} }
+  },
+  {
+    name: "graph_query",
+    description: "Run a read-only Cypher query on the per-mesh Neo4j database.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        cypher: { type: "string", description: "Cypher MATCH query" }
+      },
+      required: ["cypher"]
+    }
+  },
+  {
+    name: "graph_execute",
+    description: "Run a write Cypher query (CREATE, MERGE, DELETE) on the per-mesh Neo4j database.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        cypher: { type: "string", description: "Cypher write query" }
+      },
+      required: ["cypher"]
+    }
+  },
+  {
+    name: "mesh_query",
+    description: "Run a SELECT query on the per-mesh shared database.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        sql: { type: "string", description: "SQL SELECT query" }
+      },
+      required: ["sql"]
+    }
+  },
+  {
+    name: "mesh_execute",
+    description: "Run DDL/DML on the per-mesh database (CREATE TABLE, INSERT, UPDATE, DELETE).",
+    inputSchema: {
+      type: "object",
+      properties: {
+        sql: { type: "string", description: "SQL statement" }
+      },
+      required: ["sql"]
+    }
+  },
+  {
+    name: "mesh_schema",
+    description: "List tables and columns in the per-mesh shared database.",
+    inputSchema: { type: "object", properties: {} }
+  },
+  {
+    name: "create_stream",
+    description: "Create a real-time data stream in the mesh.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        name: { type: "string", description: "Stream name" }
+      },
+      required: ["name"]
+    }
+  },
+  {
+    name: "publish",
+    description: "Push data to a stream. Subscribers receive it in real-time.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        stream: { type: "string", description: "Stream name" },
+        data: { description: "Any JSON data to publish" }
+      },
+      required: ["stream", "data"]
+    }
+  },
+  {
+    name: "subscribe",
+    description: "Subscribe to a stream. Data pushes arrive as channel notifications.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        stream: { type: "string", description: "Stream name" }
+      },
+      required: ["stream"]
+    }
+  },
+  {
+    name: "list_streams",
+    description: "List active streams in the mesh.",
+    inputSchema: { type: "object", properties: {} }
+  },
+  {
+    name: "share_context",
+    description: "Share your session understanding with the mesh. Call after exploring a codebase area.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        summary: {
+          type: "string",
+          description: "Summary of what you explored/learned"
+        },
+        files_read: {
+          type: "array",
+          items: { type: "string" },
+          description: "File paths you read"
+        },
+        key_findings: {
+          type: "array",
+          items: { type: "string" },
+          description: "Key findings or insights"
+        },
+        tags: {
+          type: "array",
+          items: { type: "string" },
+          description: "Tags for categorization"
+        }
+      },
+      required: ["summary"]
+    }
+  },
+  {
+    name: "get_context",
+    description: "Find context from peers who explored an area. Check before re-reading files another peer already analyzed.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        query: {
+          type: "string",
+          description: "Search query (file path, topic, etc.)"
+        }
+      },
+      required: ["query"]
+    }
+  },
+  {
+    name: "list_contexts",
+    description: "See what all peers currently know about the codebase.",
+    inputSchema: { type: "object", properties: {} }
+  },
+  {
+    name: "create_task",
+    description: "Create a work item for the mesh.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        title: { type: "string", description: "Task title" },
+        assignee: {
+          type: "string",
+          description: "Peer name to assign (optional)"
+        },
+        priority: {
+          type: "string",
+          enum: ["low", "normal", "high", "urgent"],
+          description: "Priority level (default: normal)"
+        },
+        tags: {
+          type: "array",
+          items: { type: "string" },
+          description: "Tags for categorization"
+        }
+      },
+      required: ["title"]
+    }
+  },
+  {
+    name: "claim_task",
+    description: "Claim an unclaimed task to take ownership.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        id: { type: "string", description: "Task ID" }
+      },
+      required: ["id"]
+    }
+  },
+  {
+    name: "complete_task",
+    description: "Mark a task as done with an optional result summary.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        id: { type: "string", description: "Task ID" },
+        result: {
+          type: "string",
+          description: "Summary of what was done"
+        }
+      },
+      required: ["id"]
+    }
+  },
+  {
+    name: "list_tasks",
+    description: "List tasks filtered by status and/or assignee.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        status: {
+          type: "string",
+          enum: ["open", "claimed", "completed"],
+          description: "Filter by status"
+        },
+        assignee: {
+          type: "string",
+          description: "Filter by assignee name"
+        }
+      }
+    }
+  },
+  {
+    name: "mesh_info",
+    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: {} }
   }
 ];
 
@@ -46719,91 +47049,435 @@ class BrokerClient {
       return;
     this.ws.send(JSON.stringify({ type: "set_state", key, value }));
   }
-  async getState(key) {
+  async getState(key) {
+    if (!this.ws || this.ws.readyState !== this.ws.OPEN)
+      return null;
+    return new Promise((resolve) => {
+      this.stateResolvers.push(resolve);
+      this.ws.send(JSON.stringify({ type: "get_state", key }));
+      setTimeout(() => {
+        const idx = this.stateResolvers.indexOf(resolve);
+        if (idx !== -1) {
+          this.stateResolvers.splice(idx, 1);
+          resolve(null);
+        }
+      }, 5000);
+    });
+  }
+  async listState() {
+    if (!this.ws || this.ws.readyState !== this.ws.OPEN)
+      return [];
+    return new Promise((resolve) => {
+      this.stateListResolvers.push(resolve);
+      this.ws.send(JSON.stringify({ type: "list_state" }));
+      setTimeout(() => {
+        const idx = this.stateListResolvers.indexOf(resolve);
+        if (idx !== -1) {
+          this.stateListResolvers.splice(idx, 1);
+          resolve([]);
+        }
+      }, 5000);
+    });
+  }
+  async remember(content, tags) {
+    if (!this.ws || this.ws.readyState !== this.ws.OPEN)
+      return null;
+    return new Promise((resolve) => {
+      this.memoryStoreResolvers.push(resolve);
+      this.ws.send(JSON.stringify({ type: "remember", content, tags }));
+      setTimeout(() => {
+        const idx = this.memoryStoreResolvers.indexOf(resolve);
+        if (idx !== -1) {
+          this.memoryStoreResolvers.splice(idx, 1);
+          resolve(null);
+        }
+      }, 5000);
+    });
+  }
+  async recall(query) {
+    if (!this.ws || this.ws.readyState !== this.ws.OPEN)
+      return [];
+    return new Promise((resolve) => {
+      this.memoryRecallResolvers.push(resolve);
+      this.ws.send(JSON.stringify({ type: "recall", query }));
+      setTimeout(() => {
+        const idx = this.memoryRecallResolvers.indexOf(resolve);
+        if (idx !== -1) {
+          this.memoryRecallResolvers.splice(idx, 1);
+          resolve([]);
+        }
+      }, 5000);
+    });
+  }
+  async forget(memoryId) {
+    if (!this.ws || this.ws.readyState !== this.ws.OPEN)
+      return;
+    this.ws.send(JSON.stringify({ type: "forget", memoryId }));
+  }
+  messageStatusResolvers = [];
+  fileUrlResolvers = [];
+  fileListResolvers = [];
+  fileStatusResolvers = [];
+  vectorStoredResolvers = [];
+  vectorResultsResolvers = [];
+  collectionListResolvers = [];
+  graphResultResolvers = [];
+  contextListResolvers = [];
+  contextResultsResolvers = [];
+  taskCreatedResolvers = [];
+  taskListResolvers = [];
+  meshQueryResolvers = [];
+  meshSchemaResolvers = [];
+  streamCreatedResolvers = [];
+  streamListResolvers = [];
+  streamDataHandlers = new Set;
+  async messageStatus(messageId) {
+    if (!this.ws || this.ws.readyState !== this.ws.OPEN)
+      return null;
+    return new Promise((resolve) => {
+      this.messageStatusResolvers.push(resolve);
+      this.ws.send(JSON.stringify({ type: "message_status", messageId }));
+      setTimeout(() => {
+        const idx = this.messageStatusResolvers.indexOf(resolve);
+        if (idx !== -1) {
+          this.messageStatusResolvers.splice(idx, 1);
+          resolve(null);
+        }
+      }, 5000);
+    });
+  }
+  async getFile(fileId) {
+    if (!this.ws || this.ws.readyState !== this.ws.OPEN)
+      return null;
+    return new Promise((resolve) => {
+      this.fileUrlResolvers.push(resolve);
+      this.ws.send(JSON.stringify({ type: "get_file", fileId }));
+      setTimeout(() => {
+        const idx = this.fileUrlResolvers.indexOf(resolve);
+        if (idx !== -1) {
+          this.fileUrlResolvers.splice(idx, 1);
+          resolve(null);
+        }
+      }, 5000);
+    });
+  }
+  async listFiles(query, from) {
+    if (!this.ws || this.ws.readyState !== this.ws.OPEN)
+      return [];
+    return new Promise((resolve) => {
+      this.fileListResolvers.push(resolve);
+      this.ws.send(JSON.stringify({ type: "list_files", query, from }));
+      setTimeout(() => {
+        const idx = this.fileListResolvers.indexOf(resolve);
+        if (idx !== -1) {
+          this.fileListResolvers.splice(idx, 1);
+          resolve([]);
+        }
+      }, 5000);
+    });
+  }
+  async fileStatus(fileId) {
+    if (!this.ws || this.ws.readyState !== this.ws.OPEN)
+      return [];
+    return new Promise((resolve) => {
+      this.fileStatusResolvers.push(resolve);
+      this.ws.send(JSON.stringify({ type: "file_status", fileId }));
+      setTimeout(() => {
+        const idx = this.fileStatusResolvers.indexOf(resolve);
+        if (idx !== -1) {
+          this.fileStatusResolvers.splice(idx, 1);
+          resolve([]);
+        }
+      }, 5000);
+    });
+  }
+  async deleteFile(fileId) {
+    if (!this.ws || this.ws.readyState !== this.ws.OPEN)
+      return;
+    this.ws.send(JSON.stringify({ type: "delete_file", fileId }));
+  }
+  async uploadFile(filePath, meshId, memberId, opts) {
+    const { readFileSync: readFileSync2 } = await import("node:fs");
+    const { basename } = await import("node:path");
+    const data = readFileSync2(filePath);
+    const fileName = opts.name ?? basename(filePath);
+    const brokerHttp = this.mesh.brokerUrl.replace("wss://", "https://").replace("ws://", "http://").replace("/ws", "");
+    const res = await fetch(`${brokerHttp}/upload`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/octet-stream",
+        "X-Mesh-Id": meshId,
+        "X-Member-Id": memberId,
+        "X-File-Name": fileName,
+        "X-Tags": JSON.stringify(opts.tags ?? []),
+        "X-Persistent": String(opts.persistent ?? true),
+        "X-Target-Spec": opts.targetSpec ?? ""
+      },
+      body: data,
+      signal: AbortSignal.timeout(30000)
+    });
+    const body = await res.json();
+    return body.fileId ?? null;
+  }
+  async vectorStore(collection, text, metadata) {
+    if (!this.ws || this.ws.readyState !== this.ws.OPEN)
+      return null;
+    return new Promise((resolve) => {
+      this.vectorStoredResolvers.push(resolve);
+      this.ws.send(JSON.stringify({ type: "vector_store", collection, text, metadata }));
+      setTimeout(() => {
+        const idx = this.vectorStoredResolvers.indexOf(resolve);
+        if (idx !== -1) {
+          this.vectorStoredResolvers.splice(idx, 1);
+          resolve(null);
+        }
+      }, 5000);
+    });
+  }
+  async vectorSearch(collection, query, limit) {
+    if (!this.ws || this.ws.readyState !== this.ws.OPEN)
+      return [];
+    return new Promise((resolve) => {
+      this.vectorResultsResolvers.push(resolve);
+      this.ws.send(JSON.stringify({ type: "vector_search", collection, query, limit }));
+      setTimeout(() => {
+        const idx = this.vectorResultsResolvers.indexOf(resolve);
+        if (idx !== -1) {
+          this.vectorResultsResolvers.splice(idx, 1);
+          resolve([]);
+        }
+      }, 5000);
+    });
+  }
+  async vectorDelete(collection, id) {
+    if (!this.ws || this.ws.readyState !== this.ws.OPEN)
+      return;
+    this.ws.send(JSON.stringify({ type: "vector_delete", collection, id }));
+  }
+  async listCollections() {
+    if (!this.ws || this.ws.readyState !== this.ws.OPEN)
+      return [];
+    return new Promise((resolve) => {
+      this.collectionListResolvers.push(resolve);
+      this.ws.send(JSON.stringify({ type: "list_collections" }));
+      setTimeout(() => {
+        const idx = this.collectionListResolvers.indexOf(resolve);
+        if (idx !== -1) {
+          this.collectionListResolvers.splice(idx, 1);
+          resolve([]);
+        }
+      }, 5000);
+    });
+  }
+  async graphQuery(cypher) {
+    if (!this.ws || this.ws.readyState !== this.ws.OPEN)
+      return [];
+    return new Promise((resolve) => {
+      this.graphResultResolvers.push(resolve);
+      this.ws.send(JSON.stringify({ type: "graph_query", cypher }));
+      setTimeout(() => {
+        const idx = this.graphResultResolvers.indexOf(resolve);
+        if (idx !== -1) {
+          this.graphResultResolvers.splice(idx, 1);
+          resolve([]);
+        }
+      }, 5000);
+    });
+  }
+  async graphExecute(cypher) {
+    if (!this.ws || this.ws.readyState !== this.ws.OPEN)
+      return [];
+    return new Promise((resolve) => {
+      this.graphResultResolvers.push(resolve);
+      this.ws.send(JSON.stringify({ type: "graph_execute", cypher }));
+      setTimeout(() => {
+        const idx = this.graphResultResolvers.indexOf(resolve);
+        if (idx !== -1) {
+          this.graphResultResolvers.splice(idx, 1);
+          resolve([]);
+        }
+      }, 5000);
+    });
+  }
+  async shareContext(summary, filesRead, keyFindings, tags) {
+    if (!this.ws || this.ws.readyState !== this.ws.OPEN)
+      return;
+    this.ws.send(JSON.stringify({ type: "share_context", summary, filesRead, keyFindings, tags }));
+  }
+  async getContext(query) {
+    if (!this.ws || this.ws.readyState !== this.ws.OPEN)
+      return [];
+    return new Promise((resolve) => {
+      this.contextResultsResolvers.push(resolve);
+      this.ws.send(JSON.stringify({ type: "get_context", query }));
+      setTimeout(() => {
+        const idx = this.contextResultsResolvers.indexOf(resolve);
+        if (idx !== -1) {
+          this.contextResultsResolvers.splice(idx, 1);
+          resolve([]);
+        }
+      }, 5000);
+    });
+  }
+  async listContexts() {
+    if (!this.ws || this.ws.readyState !== this.ws.OPEN)
+      return [];
+    return new Promise((resolve) => {
+      this.contextListResolvers.push(resolve);
+      this.ws.send(JSON.stringify({ type: "list_contexts" }));
+      setTimeout(() => {
+        const idx = this.contextListResolvers.indexOf(resolve);
+        if (idx !== -1) {
+          this.contextListResolvers.splice(idx, 1);
+          resolve([]);
+        }
+      }, 5000);
+    });
+  }
+  async createTask(title, assignee, priority, tags) {
+    if (!this.ws || this.ws.readyState !== this.ws.OPEN)
+      return null;
+    return new Promise((resolve) => {
+      this.taskCreatedResolvers.push(resolve);
+      this.ws.send(JSON.stringify({ type: "create_task", title, assignee, priority, tags }));
+      setTimeout(() => {
+        const idx = this.taskCreatedResolvers.indexOf(resolve);
+        if (idx !== -1) {
+          this.taskCreatedResolvers.splice(idx, 1);
+          resolve(null);
+        }
+      }, 5000);
+    });
+  }
+  async claimTask(id) {
+    if (!this.ws || this.ws.readyState !== this.ws.OPEN)
+      return;
+    this.ws.send(JSON.stringify({ type: "claim_task", id }));
+  }
+  async completeTask(id, result) {
+    if (!this.ws || this.ws.readyState !== this.ws.OPEN)
+      return;
+    this.ws.send(JSON.stringify({ type: "complete_task", id, result }));
+  }
+  async listTasks(status, assignee) {
+    if (!this.ws || this.ws.readyState !== this.ws.OPEN)
+      return [];
+    return new Promise((resolve) => {
+      this.taskListResolvers.push(resolve);
+      this.ws.send(JSON.stringify({ type: "list_tasks", status, assignee }));
+      setTimeout(() => {
+        const idx = this.taskListResolvers.indexOf(resolve);
+        if (idx !== -1) {
+          this.taskListResolvers.splice(idx, 1);
+          resolve([]);
+        }
+      }, 5000);
+    });
+  }
+  async meshQuery(sql) {
     if (!this.ws || this.ws.readyState !== this.ws.OPEN)
       return null;
     return new Promise((resolve) => {
-      this.stateResolvers.push(resolve);
-      this.ws.send(JSON.stringify({ type: "get_state", key }));
+      this.meshQueryResolvers.push(resolve);
+      this.ws.send(JSON.stringify({ type: "mesh_query", sql }));
       setTimeout(() => {
-        const idx = this.stateResolvers.indexOf(resolve);
+        const idx = this.meshQueryResolvers.indexOf(resolve);
         if (idx !== -1) {
-          this.stateResolvers.splice(idx, 1);
+          this.meshQueryResolvers.splice(idx, 1);
           resolve(null);
         }
       }, 5000);
     });
   }
-  async listState() {
+  async meshExecute(sql) {
+    if (!this.ws || this.ws.readyState !== this.ws.OPEN)
+      return;
+    this.ws.send(JSON.stringify({ type: "mesh_execute", sql }));
+  }
+  async meshSchema() {
     if (!this.ws || this.ws.readyState !== this.ws.OPEN)
       return [];
     return new Promise((resolve) => {
-      this.stateListResolvers.push(resolve);
-      this.ws.send(JSON.stringify({ type: "list_state" }));
+      this.meshSchemaResolvers.push(resolve);
+      this.ws.send(JSON.stringify({ type: "mesh_schema" }));
       setTimeout(() => {
-        const idx = this.stateListResolvers.indexOf(resolve);
+        const idx = this.meshSchemaResolvers.indexOf(resolve);
         if (idx !== -1) {
-          this.stateListResolvers.splice(idx, 1);
+          this.meshSchemaResolvers.splice(idx, 1);
           resolve([]);
         }
       }, 5000);
     });
   }
-  async remember(content, tags) {
+  async createStream(name) {
     if (!this.ws || this.ws.readyState !== this.ws.OPEN)
       return null;
     return new Promise((resolve) => {
-      this.memoryStoreResolvers.push(resolve);
-      this.ws.send(JSON.stringify({ type: "remember", content, tags }));
+      this.streamCreatedResolvers.push(resolve);
+      this.ws.send(JSON.stringify({ type: "create_stream", name }));
       setTimeout(() => {
-        const idx = this.memoryStoreResolvers.indexOf(resolve);
+        const idx = this.streamCreatedResolvers.indexOf(resolve);
         if (idx !== -1) {
-          this.memoryStoreResolvers.splice(idx, 1);
+          this.streamCreatedResolvers.splice(idx, 1);
           resolve(null);
         }
       }, 5000);
     });
   }
-  async recall(query) {
+  async publish(stream, data) {
+    if (!this.ws || this.ws.readyState !== this.ws.OPEN)
+      return;
+    this.ws.send(JSON.stringify({ type: "publish", stream, data }));
+  }
+  async subscribe(stream) {
+    if (!this.ws || this.ws.readyState !== this.ws.OPEN)
+      return;
+    this.ws.send(JSON.stringify({ type: "subscribe", stream }));
+  }
+  async unsubscribe(stream) {
+    if (!this.ws || this.ws.readyState !== this.ws.OPEN)
+      return;
+    this.ws.send(JSON.stringify({ type: "unsubscribe", stream }));
+  }
+  async listStreams() {
     if (!this.ws || this.ws.readyState !== this.ws.OPEN)
       return [];
     return new Promise((resolve) => {
-      this.memoryRecallResolvers.push(resolve);
-      this.ws.send(JSON.stringify({ type: "recall", query }));
+      this.streamListResolvers.push(resolve);
+      this.ws.send(JSON.stringify({ type: "list_streams" }));
       setTimeout(() => {
-        const idx = this.memoryRecallResolvers.indexOf(resolve);
+        const idx = this.streamListResolvers.indexOf(resolve);
         if (idx !== -1) {
-          this.memoryRecallResolvers.splice(idx, 1);
+          this.streamListResolvers.splice(idx, 1);
           resolve([]);
         }
       }, 5000);
     });
   }
-  async forget(memoryId) {
-    if (!this.ws || this.ws.readyState !== this.ws.OPEN)
-      return;
-    this.ws.send(JSON.stringify({ type: "forget", memoryId }));
+  onStreamData(handler) {
+    this.streamDataHandlers.add(handler);
+    return () => this.streamDataHandlers.delete(handler);
   }
-  messageStatusResolvers = [];
-  async messageStatus(messageId) {
+  onStateChange(handler) {
+    this.stateChangeHandlers.add(handler);
+    return () => this.stateChangeHandlers.delete(handler);
+  }
+  meshInfoResolvers = [];
+  async meshInfo() {
     if (!this.ws || this.ws.readyState !== this.ws.OPEN)
       return null;
     return new Promise((resolve) => {
-      this.messageStatusResolvers.push(resolve);
-      this.ws.send(JSON.stringify({ type: "message_status", messageId }));
+      this.meshInfoResolvers.push(resolve);
+      this.ws.send(JSON.stringify({ type: "mesh_info" }));
       setTimeout(() => {
-        const idx = this.messageStatusResolvers.indexOf(resolve);
+        const idx = this.meshInfoResolvers.indexOf(resolve);
         if (idx !== -1) {
-          this.messageStatusResolvers.splice(idx, 1);
+          this.meshInfoResolvers.splice(idx, 1);
           resolve(null);
         }
       }, 5000);
     });
   }
-  onStateChange(handler) {
-    this.stateChangeHandlers.add(handler);
-    return () => this.stateChangeHandlers.delete(handler);
-  }
   close() {
     this.closed = true;
     if (this.helloTimer)
@@ -46941,6 +47615,139 @@ class BrokerClient {
         resolver(msg);
       return;
     }
+    if (msg.type === "file_url") {
+      const resolver = this.fileUrlResolvers.shift();
+      if (resolver) {
+        if (msg.url) {
+          resolver({ url: String(msg.url), name: String(msg.name ?? "") });
+        } else {
+          resolver(null);
+        }
+      }
+      return;
+    }
+    if (msg.type === "file_list") {
+      const files = msg.files ?? [];
+      const resolver = this.fileListResolvers.shift();
+      if (resolver)
+        resolver(files);
+      return;
+    }
+    if (msg.type === "file_status_result") {
+      const accesses = msg.accesses ?? [];
+      const resolver = this.fileStatusResolvers.shift();
+      if (resolver)
+        resolver(accesses);
+      return;
+    }
+    if (msg.type === "vector_stored") {
+      const resolver = this.vectorStoredResolvers.shift();
+      if (resolver)
+        resolver(msg.id ? String(msg.id) : null);
+      return;
+    }
+    if (msg.type === "vector_results") {
+      const results = msg.results ?? [];
+      const resolver = this.vectorResultsResolvers.shift();
+      if (resolver)
+        resolver(results);
+      return;
+    }
+    if (msg.type === "collection_list") {
+      const collections = msg.collections ?? [];
+      const resolver = this.collectionListResolvers.shift();
+      if (resolver)
+        resolver(collections);
+      return;
+    }
+    if (msg.type === "graph_result") {
+      const rows = msg.rows ?? [];
+      const resolver = this.graphResultResolvers.shift();
+      if (resolver)
+        resolver(rows);
+      return;
+    }
+    if (msg.type === "context_list") {
+      const contexts = msg.contexts ?? [];
+      const resolver = this.contextListResolvers.shift();
+      if (resolver)
+        resolver(contexts);
+      return;
+    }
+    if (msg.type === "context_results") {
+      const contexts = msg.contexts ?? [];
+      const resolver = this.contextResultsResolvers.shift();
+      if (resolver)
+        resolver(contexts);
+      return;
+    }
+    if (msg.type === "task_created") {
+      const resolver = this.taskCreatedResolvers.shift();
+      if (resolver)
+        resolver(msg.id ? String(msg.id) : null);
+      return;
+    }
+    if (msg.type === "task_list") {
+      const tasks = msg.tasks ?? [];
+      const resolver = this.taskListResolvers.shift();
+      if (resolver)
+        resolver(tasks);
+      return;
+    }
+    if (msg.type === "mesh_query_result") {
+      const resolver = this.meshQueryResolvers.shift();
+      if (resolver) {
+        if (msg.columns) {
+          resolver({
+            columns: msg.columns ?? [],
+            rows: msg.rows ?? [],
+            rowCount: msg.rowCount ?? 0
+          });
+        } else {
+          resolver(null);
+        }
+      }
+      return;
+    }
+    if (msg.type === "mesh_schema_result") {
+      const tables = msg.tables ?? [];
+      const resolver = this.meshSchemaResolvers.shift();
+      if (resolver)
+        resolver(tables);
+      return;
+    }
+    if (msg.type === "stream_created") {
+      const resolver = this.streamCreatedResolvers.shift();
+      if (resolver)
+        resolver(msg.id ? String(msg.id) : null);
+      return;
+    }
+    if (msg.type === "stream_list") {
+      const streams = msg.streams ?? [];
+      const resolver = this.streamListResolvers.shift();
+      if (resolver)
+        resolver(streams);
+      return;
+    }
+    if (msg.type === "stream_data") {
+      const evt = {
+        stream: String(msg.stream ?? ""),
+        data: msg.data,
+        publishedBy: String(msg.publishedBy ?? "")
+      };
+      for (const h of this.streamDataHandlers) {
+        try {
+          h(evt);
+        } catch {}
+      }
+      return;
+    }
+    if (msg.type === "mesh_info_result") {
+      const resolver = this.meshInfoResolvers.shift();
+      if (resolver)
+        resolver(msg);
+      return;
+    }
     if (msg.type === "error") {
       this.debug(`broker error: ${msg.code} ${msg.message}`);
       const id = msg.id ? String(msg.id) : null;
@@ -47141,9 +47948,44 @@ When you receive a <channel source="claudemesh" ...> message, RESPOND IMMEDIATEL
 | remember(content, tags?) | Store persistent knowledge with optional tags. |
 | recall(query) | Full-text search over mesh memory. |
 | forget(id) | Soft-delete a memory entry. |
+| share_file(path, name?, tags?) | Share a persistent file with the mesh. |
+| get_file(id, save_to) | Download a shared file to a local path. |
+| list_files(query?, from?) | Find files shared in the mesh. |
+| file_status(id) | Check who has accessed a file. |
+| delete_file(id) | Remove a shared file from the mesh. |
+| vector_store(collection, text, metadata?) | Store embedding in per-mesh Qdrant collection. |
+| vector_search(collection, query, limit?) | Semantic search over stored embeddings. |
+| vector_delete(collection, id) | Remove an embedding. |
+| list_collections() | List vector collections in this mesh. |
+| graph_query(cypher) | Read-only Cypher query on per-mesh Neo4j. |
+| graph_execute(cypher) | Write Cypher query (CREATE, MERGE, DELETE). |
+| mesh_query(sql) | Run a SELECT query on the per-mesh shared database. |
+| mesh_execute(sql) | Run DDL/DML on the per-mesh database (CREATE TABLE, INSERT, UPDATE, DELETE). |
+| mesh_schema() | List tables and columns in the per-mesh shared database. |
+| create_stream(name) | Create a real-time data stream in the mesh. |
+| publish(stream, data) | Push data to a stream. Subscribers receive it in real-time. |
+| subscribe(stream) | Subscribe to a stream. Data pushes arrive as channel notifications. |
+| list_streams() | List active streams in the mesh. |
+| share_context(summary, files_read?, key_findings?, tags?) | Share session understanding with peers. |
+| get_context(query) | Find context from peers who explored an area. |
+| list_contexts() | See what all peers currently know. |
+| create_task(title, assignee?, priority?, tags?) | Create a work item. |
+| claim_task(id) | Claim an unclaimed task. |
+| complete_task(id, result?) | Mark task done with optional result. |
+| list_tasks(status?, assignee?) | List tasks filtered by status/assignee. |
 
 If multiple meshes are joined, prefix \`to\` with \`<mesh-slug>:\` to disambiguate (e.g. \`dev-team:Alice\`).
 
+Multi-target: send_message accepts an array of targets for the 'to' field.
+  send_message(to: ["Alice", "@backend"], message: "sprint starts")
+Targets are deduplicated — each peer receives the message once.
+
+Targeted views: when different audiences need different details about the same event,
+send tailored messages instead of one generic broadcast:
+  send_message(to: "@frontend", message: "Auth v2: useAuth hook changed, see src/auth/")
+  send_message(to: "@backend", message: "Auth v2: new /api/auth/v2 endpoints, v1 deprecated")
+  send_message(to: "@pm", message: "Auth v2 done. 3 points, no blockers.")
+
 ## Groups
 Groups are routing labels. Send to @groupname to multicast to all members. Roles are metadata that peers interpret: a "lead" gathers input before synthesizing a response, a "member" contributes when asked, an "observer" watches silently. Join and leave groups dynamically with join_group/leave_group. Check list_peers to see who belongs to which groups and their roles.
 
@@ -47153,6 +47995,28 @@ 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.
+
+## Vectors
+Store and search semantic embeddings. Use vector_store to index content, vector_search to find similar content.
+
+## Graph
+Build and query entity relationship graphs. Use graph_execute for writes (CREATE, MERGE), graph_query for reads (MATCH).
+
+## Mesh Database
+Per-mesh PostgreSQL database. Use mesh_execute for DDL/DML (CREATE TABLE, INSERT), mesh_query for SELECT, mesh_schema to inspect tables. Schema auto-created on first use.
+
+## Streams
+Real-time data channels. create_stream to start one, publish to push data, subscribe to receive pushes. Use for build logs, deploy status, live metrics.
+
+## Context
+Share your session understanding with peers. Use share_context after exploring a codebase area. Check get_context before re-reading files another peer already analyzed.
+
+## Tasks
+Create and claim work items. create_task to propose work, claim_task to take ownership, complete_task when done. Prevents duplicate effort.
+
 ## Priority
 - "now": interrupt immediately, even if recipient is in DND (use for urgent: broken deploy, blocking issue)
 - "next" (default): deliver when recipient goes idle (normal coordination)
@@ -47174,13 +48038,27 @@ Call list_peers at session start to understand who is online, their roles, and w
         const { to, message, priority } = args ?? {};
         if (!to || !message)
           return text("send_message: `to` and `message` required", true);
-        const { client, targetSpec, error: error2 } = await resolveClient(to);
-        if (!client)
-          return text(`send_message: ${error2 ?? "no client resolved"}`, true);
-        const result = await client.send(targetSpec, message, priority ?? "next");
-        if (!result.ok)
-          return text(`send_message failed (${client.meshSlug}): ${result.error}`, true);
-        return text(`Sent to ${targetSpec} via ${client.meshSlug} [${priority ?? "next"}] → ${result.messageId}`);
+        const targets = Array.isArray(to) ? to : [to];
+        const results = [];
+        const seen = new Set;
+        for (const target of targets) {
+          const { client, targetSpec, error: error2 } = await resolveClient(target);
+          if (!client) {
+            results.push(`✗ ${target}: ${error2 ?? "no client resolved"}`);
+            continue;
+          }
+          if (seen.has(targetSpec))
+            continue;
+          seen.add(targetSpec);
+          const result = await client.send(targetSpec, message, priority ?? "next");
+          if (!result.ok) {
+            results.push(`✗ ${target}: ${result.error}`);
+          } else {
+            results.push(`✓ ${target} → ${result.messageId}`);
+          }
+        }
+        return text(results.join(`
+`));
       }
       case "list_peers": {
         const { mesh_slug } = args ?? {};
@@ -47342,6 +48220,341 @@ ${lines.join(`
         await client.forget(id);
         return text(`Forgotten: ${id}`);
       }
+      case "share_file": {
+        const { path: filePath, name: fileName, tags } = args ?? {};
+        if (!filePath)
+          return text("share_file: `path` required", true);
+        const { existsSync: existsSync2 } = await import("node:fs");
+        if (!existsSync2(filePath))
+          return text(`share_file: file not found: ${filePath}`, true);
+        const client = allClients()[0];
+        if (!client)
+          return text("share_file: not connected", true);
+        const fileId = await client.uploadFile(filePath, client.meshId, client.meshSlug, {
+          name: fileName,
+          tags,
+          persistent: true
+        });
+        if (!fileId)
+          return text("share_file: upload failed", true);
+        return text(`Shared: ${fileName ?? filePath} (${fileId})`);
+      }
+      case "get_file": {
+        const { id, save_to } = args ?? {};
+        if (!id || !save_to)
+          return text("get_file: `id` and `save_to` required", true);
+        const client = allClients()[0];
+        if (!client)
+          return text("get_file: not connected", true);
+        const result = await client.getFile(id);
+        if (!result)
+          return text(`get_file: file ${id} not found`, true);
+        const res = await fetch(result.url, { signal: AbortSignal.timeout(30000) });
+        if (!res.ok)
+          return text(`get_file: download failed (${res.status})`, true);
+        const { writeFileSync: writeFileSync2, mkdirSync: mkdirSync2 } = await import("node:fs");
+        const { dirname: dirname2 } = await import("node:path");
+        mkdirSync2(dirname2(save_to), { recursive: true });
+        writeFileSync2(save_to, Buffer.from(await res.arrayBuffer()));
+        return text(`Downloaded: ${result.name} → ${save_to}`);
+      }
+      case "list_files": {
+        const { query, from } = args ?? {};
+        const client = allClients()[0];
+        if (!client)
+          return text("list_files: not connected", true);
+        const files = await client.listFiles(query, from);
+        if (files.length === 0)
+          return text("No files found.");
+        const lines = files.map((f) => `- **${f.name}** (${f.id.slice(0, 8)}…, ${f.size} bytes) by ${f.uploadedBy}${f.tags.length ? ` [${f.tags.join(", ")}]` : ""}`);
+        return text(lines.join(`
+`));
+      }
+      case "file_status": {
+        const { id } = args ?? {};
+        if (!id)
+          return text("file_status: `id` required", true);
+        const client = allClients()[0];
+        if (!client)
+          return text("file_status: not connected", true);
+        const accesses = await client.fileStatus(id);
+        if (accesses.length === 0)
+          return text("No one has accessed this file yet.");
+        const lines = accesses.map((a) => `- ${a.peerName} at ${a.accessedAt}`);
+        return text(`Accessed by:
+${lines.join(`
+`)}`);
+      }
+      case "delete_file": {
+        const { id } = args ?? {};
+        if (!id)
+          return text("delete_file: `id` required", true);
+        const client = allClients()[0];
+        if (!client)
+          return text("delete_file: not connected", true);
+        await client.deleteFile(id);
+        return text(`Deleted: ${id}`);
+      }
+      case "vector_store": {
+        const { collection, text: storeText, metadata } = args ?? {};
+        if (!collection || !storeText)
+          return text("vector_store: `collection` and `text` required", true);
+        const client = allClients()[0];
+        if (!client)
+          return text("vector_store: not connected", true);
+        const id = await client.vectorStore(collection, storeText, metadata);
+        return text(`Stored in ${collection}${id ? ` (${id})` : ""}`);
+      }
+      case "vector_search": {
+        const { collection, query, limit } = args ?? {};
+        if (!collection || !query)
+          return text("vector_search: `collection` and `query` required", true);
+        const client = allClients()[0];
+        if (!client)
+          return text("vector_search: not connected", true);
+        const results = await client.vectorSearch(collection, query, limit);
+        if (results.length === 0)
+          return text(`No results in ${collection} for "${query}".`);
+        const lines = results.map((r) => `- [${r.id.slice(0, 8)}…] (score: ${r.score.toFixed(3)}) ${r.text.slice(0, 120)}${r.text.length > 120 ? "…" : ""}`);
+        return text(`${results.length} result(s) in ${collection}:
+${lines.join(`
+`)}`);
+      }
+      case "vector_delete": {
+        const { collection, id } = args ?? {};
+        if (!collection || !id)
+          return text("vector_delete: `collection` and `id` required", true);
+        const client = allClients()[0];
+        if (!client)
+          return text("vector_delete: not connected", true);
+        await client.vectorDelete(collection, id);
+        return text(`Deleted ${id} from ${collection}`);
+      }
+      case "list_collections": {
+        const client = allClients()[0];
+        if (!client)
+          return text("list_collections: not connected", true);
+        const collections = await client.listCollections();
+        if (collections.length === 0)
+          return text("No vector collections.");
+        return text(`Collections:
+${collections.map((c) => `- ${c}`).join(`
+`)}`);
+      }
+      case "graph_query": {
+        const { cypher } = args ?? {};
+        if (!cypher)
+          return text("graph_query: `cypher` required", true);
+        const client = allClients()[0];
+        if (!client)
+          return text("graph_query: not connected", true);
+        const rows = await client.graphQuery(cypher);
+        if (rows.length === 0)
+          return text("No results.");
+        return text(JSON.stringify(rows, null, 2));
+      }
+      case "graph_execute": {
+        const { cypher } = args ?? {};
+        if (!cypher)
+          return text("graph_execute: `cypher` required", true);
+        const client = allClients()[0];
+        if (!client)
+          return text("graph_execute: not connected", true);
+        const rows = await client.graphExecute(cypher);
+        return text(rows.length > 0 ? JSON.stringify(rows, null, 2) : "Executed successfully.");
+      }
+      case "share_context": {
+        const { summary, files_read, key_findings, tags } = args ?? {};
+        if (!summary)
+          return text("share_context: `summary` required", true);
+        const client = allClients()[0];
+        if (!client)
+          return text("share_context: not connected", true);
+        await client.shareContext(summary, files_read, key_findings, tags);
+        return text(`Context shared: "${summary.slice(0, 80)}${summary.length > 80 ? "…" : ""}"`);
+      }
+      case "get_context": {
+        const { query } = args ?? {};
+        if (!query)
+          return text("get_context: `query` required", true);
+        const client = allClients()[0];
+        if (!client)
+          return text("get_context: not connected", true);
+        const contexts = await client.getContext(query);
+        if (contexts.length === 0)
+          return text(`No context found for "${query}".`);
+        const lines = contexts.map((c) => {
+          const files = c.filesRead.length ? `
+  Files: ${c.filesRead.join(", ")}` : "";
+          const findings = c.keyFindings.length ? `
+  Findings: ${c.keyFindings.join("; ")}` : "";
+          return `- **${c.peerName}** (${c.updatedAt}): ${c.summary}${files}${findings}`;
+        });
+        return text(`${contexts.length} context(s):
+${lines.join(`
+`)}`);
+      }
+      case "list_contexts": {
+        const client = allClients()[0];
+        if (!client)
+          return text("list_contexts: not connected", true);
+        const contexts = await client.listContexts();
+        if (contexts.length === 0)
+          return text("No peer contexts shared yet.");
+        const lines = contexts.map((c) => `- **${c.peerName}**: ${c.summary}${c.tags.length ? ` [${c.tags.join(", ")}]` : ""}`);
+        return text(`Peer contexts:
+${lines.join(`
+`)}`);
+      }
+      case "create_task": {
+        const { title, assignee, priority, tags } = args ?? {};
+        if (!title)
+          return text("create_task: `title` required", true);
+        const client = allClients()[0];
+        if (!client)
+          return text("create_task: not connected", true);
+        const id = await client.createTask(title, assignee, priority, tags);
+        return text(`Task created${id ? ` (${id})` : ""}: "${title}"${assignee ? ` → ${assignee}` : ""}`);
+      }
+      case "claim_task": {
+        const { id } = args ?? {};
+        if (!id)
+          return text("claim_task: `id` required", true);
+        const client = allClients()[0];
+        if (!client)
+          return text("claim_task: not connected", true);
+        await client.claimTask(id);
+        return text(`Claimed task: ${id}`);
+      }
+      case "complete_task": {
+        const { id, result } = args ?? {};
+        if (!id)
+          return text("complete_task: `id` required", true);
+        const client = allClients()[0];
+        if (!client)
+          return text("complete_task: not connected", true);
+        await client.completeTask(id, result);
+        return text(`Completed task: ${id}${result ? ` — ${result}` : ""}`);
+      }
+      case "list_tasks": {
+        const { status, assignee } = args ?? {};
+        const client = allClients()[0];
+        if (!client)
+          return text("list_tasks: not connected", true);
+        const tasks = await client.listTasks(status, assignee);
+        if (tasks.length === 0)
+          return text("No tasks found.");
+        const lines = tasks.map((t) => `- [${t.id.slice(0, 8)}…] **${t.title}** (${t.status}, ${t.priority}) ${t.assignee ? `→ ${t.assignee}` : "unassigned"} (by ${t.createdBy})`);
+        return text(`${tasks.length} task(s):
+${lines.join(`
+`)}`);
+      }
+      case "mesh_query": {
+        const { sql: querySql } = args ?? {};
+        if (!querySql)
+          return text("mesh_query: `sql` required", true);
+        const client = allClients()[0];
+        if (!client)
+          return text("mesh_query: not connected", true);
+        const result = await client.meshQuery(querySql);
+        if (!result)
+          return text("mesh_query: query failed or timed out", true);
+        if (result.rows.length === 0)
+          return text(`Query returned 0 rows.`);
+        const header = `| ${result.columns.join(" | ")} |`;
+        const sep = `| ${result.columns.map(() => "---").join(" | ")} |`;
+        const rows = result.rows.map((r) => `| ${result.columns.map((c) => String(r[c] ?? "")).join(" | ")} |`);
+        return text(`${result.rowCount} row(s):
+${header}
+${sep}
+${rows.join(`
+`)}`);
+      }
+      case "mesh_execute": {
+        const { sql: execSql } = args ?? {};
+        if (!execSql)
+          return text("mesh_execute: `sql` required", true);
+        const client = allClients()[0];
+        if (!client)
+          return text("mesh_execute: not connected", true);
+        await client.meshExecute(execSql);
+        return text(`Executed.`);
+      }
+      case "mesh_schema": {
+        const client = allClients()[0];
+        if (!client)
+          return text("mesh_schema: not connected", true);
+        const tables = await client.meshSchema();
+        if (!tables || tables.length === 0)
+          return text("No tables in mesh database.");
+        const lines = tables.map((t) => `**${t.name}**: ${t.columns.map((c) => `${c.name} (${c.type}${c.nullable ? ", nullable" : ""})`).join(", ")}`);
+        return text(lines.join(`
+`));
+      }
+      case "create_stream": {
+        const { name: streamName } = args ?? {};
+        if (!streamName)
+          return text("create_stream: `name` required", true);
+        const client = allClients()[0];
+        if (!client)
+          return text("create_stream: not connected", true);
+        const streamId = await client.createStream(streamName);
+        return text(`Stream created: ${streamName}${streamId ? ` (${streamId})` : ""}`);
+      }
+      case "publish": {
+        const { stream: pubStream, data: pubData } = args ?? {};
+        if (!pubStream)
+          return text("publish: `stream` required", true);
+        const client = allClients()[0];
+        if (!client)
+          return text("publish: not connected", true);
+        await client.publish(pubStream, pubData);
+        return text(`Published to ${pubStream}.`);
+      }
+      case "subscribe": {
+        const { stream: subStream } = args ?? {};
+        if (!subStream)
+          return text("subscribe: `stream` required", true);
+        const client = allClients()[0];
+        if (!client)
+          return text("subscribe: not connected", true);
+        await client.subscribe(subStream);
+        return text(`Subscribed to ${subStream}. Data pushes will arrive as channel notifications.`);
+      }
+      case "list_streams": {
+        const client = allClients()[0];
+        if (!client)
+          return text("list_streams: not connected", true);
+        const streams = await client.listStreams();
+        if (streams.length === 0)
+          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_info": {
+        const client = allClients()[0];
+        if (!client)
+          return text("mesh_info: not connected", true);
+        const info = await client.meshInfo();
+        if (!info)
+          return text("mesh_info: timed out", true);
+        const lines = [
+          `**Mesh**: ${info.mesh}`,
+          `**Peers**: ${info.peers}`,
+          `**Groups**: ${info.groups?.join(", ") || "none"}`,
+          `**State keys**: ${info.stateKeys?.join(", ") || "none"}`,
+          `**Memories**: ${info.memoryCount}`,
+          `**Files**: ${info.fileCount}`,
+          `**Tasks**: open=${info.tasks?.open ?? 0}, claimed=${info.tasks?.claimed ?? 0}, done=${info.tasks?.done ?? 0}`,
+          `**Streams**: ${info.streams?.join(", ") || "none"}`,
+          `**Tables**: ${info.tables?.join(", ") || "none"}`,
+          `**Your name**: ${info.yourName}`,
+          `**Your groups**: ${info.yourGroups?.map((g) => `@${g.name}${g.role ? ":" + g.role : ""}`).join(", ") || "none"}`
+        ];
+        return text(lines.join(`
+`));
+      }
       default:
         return text(`Unknown tool: ${name}`, true);
     }
@@ -47373,6 +48586,21 @@ ${lines.join(`
         });
       } catch {}
     });
+    client.onStreamData(async (evt) => {
+      try {
+        await server.notification({
+          method: "notifications/claude/channel",
+          params: {
+            content: `[stream:${evt.stream}] from ${evt.publishedBy}: ${JSON.stringify(evt.data)}`,
+            meta: {
+              kind: "stream_data",
+              stream: evt.stream,
+              published_by: evt.publishedBy
+            }
+          }
+        });
+      } catch {}
+    });
     client.onStateChange(async (change) => {
       try {
         await server.notification({
@@ -48273,7 +49501,7 @@ init_config();
 // package.json
 var package_default = {
   name: "claudemesh-cli",
-  version: "0.3.0",
+  version: "0.5.0",
   description: "Claude Code MCP client for claudemesh — peer mesh messaging between Claude sessions.",
   keywords: [
     "claude-code",