claudemesh-cli 0.4.0 → 0.5.0

package/dist/index.js

@@ -46486,6 +46486,265 @@ var TOOLS = [
       },
       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: {} }
   }
 ];
 
@@ -46859,6 +47118,19 @@ class BrokerClient {
   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;
@@ -46947,10 +47219,265 @@ class BrokerClient {
     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.meshQueryResolvers.push(resolve);
+      this.ws.send(JSON.stringify({ type: "mesh_query", sql }));
+      setTimeout(() => {
+        const idx = this.meshQueryResolvers.indexOf(resolve);
+        if (idx !== -1) {
+          this.meshQueryResolvers.splice(idx, 1);
+          resolve(null);
+        }
+      }, 5000);
+    });
+  }
+  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.meshSchemaResolvers.push(resolve);
+      this.ws.send(JSON.stringify({ type: "mesh_schema" }));
+      setTimeout(() => {
+        const idx = this.meshSchemaResolvers.indexOf(resolve);
+        if (idx !== -1) {
+          this.meshSchemaResolvers.splice(idx, 1);
+          resolve([]);
+        }
+      }, 5000);
+    });
+  }
+  async createStream(name) {
+    if (!this.ws || this.ws.readyState !== this.ws.OPEN)
+      return null;
+    return new Promise((resolve) => {
+      this.streamCreatedResolvers.push(resolve);
+      this.ws.send(JSON.stringify({ type: "create_stream", name }));
+      setTimeout(() => {
+        const idx = this.streamCreatedResolvers.indexOf(resolve);
+        if (idx !== -1) {
+          this.streamCreatedResolvers.splice(idx, 1);
+          resolve(null);
+        }
+      }, 5000);
+    });
+  }
+  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.streamListResolvers.push(resolve);
+      this.ws.send(JSON.stringify({ type: "list_streams" }));
+      setTimeout(() => {
+        const idx = this.streamListResolvers.indexOf(resolve);
+        if (idx !== -1) {
+          this.streamListResolvers.splice(idx, 1);
+          resolve([]);
+        }
+      }, 5000);
+    });
+  }
+  onStreamData(handler) {
+    this.streamDataHandlers.add(handler);
+    return () => this.streamDataHandlers.delete(handler);
+  }
   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.meshInfoResolvers.push(resolve);
+      this.ws.send(JSON.stringify({ type: "mesh_info" }));
+      setTimeout(() => {
+        const idx = this.meshInfoResolvers.indexOf(resolve);
+        if (idx !== -1) {
+          this.meshInfoResolvers.splice(idx, 1);
+          resolve(null);
+        }
+      }, 5000);
+    });
+  }
   close() {
     this.closed = true;
     if (this.helloTimer)
@@ -47113,6 +47640,114 @@ class BrokerClient {
         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;
@@ -47318,6 +47953,26 @@ When you receive a <channel source="claudemesh" ...> message, RESPOND IMMEDIATEL
 | 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\`).
 
@@ -47344,6 +47999,24 @@ Persistent knowledge that survives across sessions. Use remember(content, tags?)
 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)
@@ -47622,6 +48295,266 @@ ${lines.join(`
         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);
     }
@@ -47653,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({
@@ -48553,7 +49501,7 @@ init_config();
 // package.json
 var package_default = {
   name: "claudemesh-cli",
-  version: "0.4.0",
+  version: "0.5.0",
   description: "Claude Code MCP client for claudemesh — peer mesh messaging between Claude sessions.",
   keywords: [
     "claude-code",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claudemesh-cli",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "description": "Claude Code MCP client for claudemesh — peer mesh messaging between Claude sessions.",
   "keywords": [
     "claude-code",