claudemesh-cli 0.6.5 → 0.6.7

package/dist/index.js

@@ -47374,6 +47374,49 @@ var TOOLS = [
       }
     }
   },
+  {
+    name: "schedule_reminder",
+    description: "Schedule a reminder message delivered back to yourself at a future time. The broker fires it as a push when the time arrives. Use to prompt yourself to check on something later.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        message: { type: "string", description: "Reminder text" },
+        deliver_at: { type: "number", description: "Unix timestamp (ms) when to deliver" },
+        in_seconds: { type: "number", description: "Alternative to deliver_at: fire after N seconds" }
+      },
+      required: ["message"]
+    }
+  },
+  {
+    name: "send_later",
+    description: "Send a message to a peer, @group, or broadcast (*) at a future time. The broker holds it and delivers when the time arrives.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        to: { type: "string", description: "Recipient: display name, pubkey hex, @group, or *" },
+        message: { type: "string", description: "Message text" },
+        deliver_at: { type: "number", description: "Unix timestamp (ms) when to deliver" },
+        in_seconds: { type: "number", description: "Alternative to deliver_at: fire after N seconds" }
+      },
+      required: ["to", "message"]
+    }
+  },
+  {
+    name: "list_scheduled",
+    description: "List all your pending scheduled messages: id, recipient, preview, and delivery time.",
+    inputSchema: { type: "object", properties: {} }
+  },
+  {
+    name: "cancel_scheduled",
+    description: "Cancel a pending scheduled message before it fires.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        id: { type: "string", description: "Scheduled message ID" }
+      },
+      required: ["id"]
+    }
+  },
   {
     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.",
@@ -47468,15 +47511,15 @@ class BrokerClient {
   outbound = [];
   pushHandlers = new Set;
   pushBuffer = [];
-  listPeersResolvers = [];
-  stateResolvers = [];
-  stateListResolvers = [];
-  memoryStoreResolvers = [];
-  memoryRecallResolvers = [];
+  listPeersResolvers = new Map;
+  stateResolvers = new Map;
+  stateListResolvers = new Map;
+  memoryStoreResolvers = new Map;
+  memoryRecallResolvers = new Map;
   stateChangeHandlers = new Set;
   sessionPubkey = null;
   sessionSecretKey = null;
-  grantFileAccessResolvers = [];
+  grantFileAccessResolvers = new Map;
   closed = false;
   reconnectAttempt = 0;
   helloTimer = null;
@@ -47503,6 +47546,9 @@ class BrokerClient {
   getSessionSecretKey() {
     return this.sessionSecretKey;
   }
+  makeReqId() {
+    return Math.random().toString(36).slice(2) + Date.now().toString(36);
+  }
   async connect() {
     if (this.closed)
       throw new Error("client is closed");
@@ -47656,15 +47702,12 @@ class BrokerClient {
     if (!this.ws || this.ws.readyState !== this.ws.OPEN)
       return [];
     return new Promise((resolve) => {
-      this.listPeersResolvers.push(resolve);
-      this.ws.send(JSON.stringify({ type: "list_peers" }));
-      setTimeout(() => {
-        const idx = this.listPeersResolvers.indexOf(resolve);
-        if (idx !== -1) {
-          this.listPeersResolvers.splice(idx, 1);
+      const reqId = this.makeReqId();
+      this.listPeersResolvers.set(reqId, { resolve, timer: setTimeout(() => {
+        if (this.listPeersResolvers.delete(reqId))
           resolve([]);
-        }
-      }, 5000);
+      }, 5000) });
+      this.ws.send(JSON.stringify({ type: "list_peers", _reqId: reqId }));
     });
   }
   async setSummary(summary) {
@@ -47691,60 +47734,48 @@ class BrokerClient {
     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);
+      const reqId = this.makeReqId();
+      this.stateResolvers.set(reqId, { resolve, timer: setTimeout(() => {
+        if (this.stateResolvers.delete(reqId))
           resolve(null);
-        }
-      }, 5000);
+      }, 5000) });
+      this.ws.send(JSON.stringify({ type: "get_state", key, _reqId: reqId }));
     });
   }
   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);
+      const reqId = this.makeReqId();
+      this.stateListResolvers.set(reqId, { resolve, timer: setTimeout(() => {
+        if (this.stateListResolvers.delete(reqId))
           resolve([]);
-        }
-      }, 5000);
+      }, 5000) });
+      this.ws.send(JSON.stringify({ type: "list_state", _reqId: reqId }));
     });
   }
   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);
+      const reqId = this.makeReqId();
+      this.memoryStoreResolvers.set(reqId, { resolve, timer: setTimeout(() => {
+        if (this.memoryStoreResolvers.delete(reqId))
           resolve(null);
-        }
-      }, 5000);
+      }, 5000) });
+      this.ws.send(JSON.stringify({ type: "remember", content, tags, _reqId: reqId }));
     });
   }
   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);
+      const reqId = this.makeReqId();
+      this.memoryRecallResolvers.set(reqId, { resolve, timer: setTimeout(() => {
+        if (this.memoryRecallResolvers.delete(reqId))
           resolve([]);
-        }
-      }, 5000);
+      }, 5000) });
+      this.ws.send(JSON.stringify({ type: "recall", query, _reqId: reqId }));
     });
   }
   async forget(memoryId) {
@@ -47752,81 +47783,108 @@ class BrokerClient {
       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 = [];
+  async scheduleMessage(to, message, deliverAt) {
+    if (!this.ws || this.ws.readyState !== this.ws.OPEN)
+      return null;
+    return new Promise((resolve) => {
+      const reqId = this.makeReqId();
+      this.scheduledAckResolvers.set(reqId, { resolve, timer: setTimeout(() => {
+        if (this.scheduledAckResolvers.delete(reqId))
+          resolve(null);
+      }, 8000) });
+      this.ws.send(JSON.stringify({ type: "schedule", to, message, deliverAt, _reqId: reqId }));
+    });
+  }
+  async listScheduled() {
+    if (!this.ws || this.ws.readyState !== this.ws.OPEN)
+      return [];
+    return new Promise((resolve) => {
+      const reqId = this.makeReqId();
+      this.scheduledListResolvers.set(reqId, { resolve, timer: setTimeout(() => {
+        if (this.scheduledListResolvers.delete(reqId))
+          resolve([]);
+      }, 5000) });
+      this.ws.send(JSON.stringify({ type: "list_scheduled", _reqId: reqId }));
+    });
+  }
+  async cancelScheduled(scheduledId) {
+    if (!this.ws || this.ws.readyState !== this.ws.OPEN)
+      return false;
+    return new Promise((resolve) => {
+      const reqId = this.makeReqId();
+      this.cancelScheduledResolvers.set(reqId, { resolve, timer: setTimeout(() => {
+        if (this.cancelScheduledResolvers.delete(reqId))
+          resolve(false);
+      }, 5000) });
+      this.ws.send(JSON.stringify({ type: "cancel_scheduled", scheduledId, _reqId: reqId }));
+    });
+  }
+  messageStatusResolvers = new Map;
+  fileUrlResolvers = new Map;
+  fileListResolvers = new Map;
+  fileStatusResolvers = new Map;
+  vectorStoredResolvers = new Map;
+  vectorResultsResolvers = new Map;
+  collectionListResolvers = new Map;
+  graphResultResolvers = new Map;
+  contextListResolvers = new Map;
+  contextResultsResolvers = new Map;
+  taskCreatedResolvers = new Map;
+  taskListResolvers = new Map;
+  meshQueryResolvers = new Map;
+  meshSchemaResolvers = new Map;
+  streamCreatedResolvers = new Map;
+  streamListResolvers = new Map;
   streamDataHandlers = new Set;
+  scheduledAckResolvers = new Map;
+  scheduledListResolvers = new Map;
+  cancelScheduledResolvers = new Map;
   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);
+      const reqId = this.makeReqId();
+      this.messageStatusResolvers.set(reqId, { resolve, timer: setTimeout(() => {
+        if (this.messageStatusResolvers.delete(reqId))
           resolve(null);
-        }
-      }, 5000);
+      }, 5000) });
+      this.ws.send(JSON.stringify({ type: "message_status", messageId, _reqId: reqId }));
     });
   }
   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);
+      const reqId = this.makeReqId();
+      this.fileUrlResolvers.set(reqId, { resolve, timer: setTimeout(() => {
+        if (this.fileUrlResolvers.delete(reqId))
           resolve(null);
-        }
-      }, 5000);
+      }, 5000) });
+      this.ws.send(JSON.stringify({ type: "get_file", fileId, _reqId: reqId }));
     });
   }
   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);
+      const reqId = this.makeReqId();
+      this.fileListResolvers.set(reqId, { resolve, timer: setTimeout(() => {
+        if (this.fileListResolvers.delete(reqId))
           resolve([]);
-        }
-      }, 5000);
+      }, 5000) });
+      this.ws.send(JSON.stringify({ type: "list_files", query, from, _reqId: reqId }));
     });
   }
   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);
+      const reqId = this.makeReqId();
+      this.fileStatusResolvers.set(reqId, { resolve, timer: setTimeout(() => {
+        if (this.fileStatusResolvers.delete(reqId))
           resolve([]);
-        }
-      }, 5000);
+      }, 5000) });
+      this.ws.send(JSON.stringify({ type: "file_status", fileId, _reqId: reqId }));
     });
   }
   async deleteFile(fileId) {
@@ -47867,46 +47925,36 @@ class BrokerClient {
     if (!this.ws || this.ws.readyState !== this.ws.OPEN)
       return false;
     return new Promise((resolve) => {
-      const resolvers = this.grantFileAccessResolvers;
-      resolvers.push(resolve);
-      this.ws.send(JSON.stringify({ type: "grant_file_access", fileId, peerPubkey, sealedKey }));
-      setTimeout(() => {
-        const idx = resolvers.indexOf(resolve);
-        if (idx !== -1) {
-          resolvers.splice(idx, 1);
+      const reqId = this.makeReqId();
+      this.grantFileAccessResolvers.set(reqId, { resolve, timer: setTimeout(() => {
+        if (this.grantFileAccessResolvers.delete(reqId))
           resolve(false);
-        }
-      }, 5000);
+      }, 5000) });
+      this.ws.send(JSON.stringify({ type: "grant_file_access", fileId, peerPubkey, sealedKey, _reqId: reqId }));
     });
   }
   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);
+      const reqId = this.makeReqId();
+      this.vectorStoredResolvers.set(reqId, { resolve, timer: setTimeout(() => {
+        if (this.vectorStoredResolvers.delete(reqId))
           resolve(null);
-        }
-      }, 5000);
+      }, 5000) });
+      this.ws.send(JSON.stringify({ type: "vector_store", collection, text, metadata, _reqId: reqId }));
     });
   }
   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);
+      const reqId = this.makeReqId();
+      this.vectorResultsResolvers.set(reqId, { resolve, timer: setTimeout(() => {
+        if (this.vectorResultsResolvers.delete(reqId))
           resolve([]);
-        }
-      }, 5000);
+      }, 5000) });
+      this.ws.send(JSON.stringify({ type: "vector_search", collection, query, limit, _reqId: reqId }));
     });
   }
   async vectorDelete(collection, id) {
@@ -47918,45 +47966,36 @@ class BrokerClient {
     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);
+      const reqId = this.makeReqId();
+      this.collectionListResolvers.set(reqId, { resolve, timer: setTimeout(() => {
+        if (this.collectionListResolvers.delete(reqId))
           resolve([]);
-        }
-      }, 5000);
+      }, 5000) });
+      this.ws.send(JSON.stringify({ type: "list_collections", _reqId: reqId }));
     });
   }
   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);
+      const reqId = this.makeReqId();
+      this.graphResultResolvers.set(reqId, { resolve, timer: setTimeout(() => {
+        if (this.graphResultResolvers.delete(reqId))
           resolve([]);
-        }
-      }, 5000);
+      }, 5000) });
+      this.ws.send(JSON.stringify({ type: "graph_query", cypher, _reqId: reqId }));
     });
   }
   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);
+      const reqId = this.makeReqId();
+      this.graphResultResolvers.set(reqId, { resolve, timer: setTimeout(() => {
+        if (this.graphResultResolvers.delete(reqId))
           resolve([]);
-        }
-      }, 5000);
+      }, 5000) });
+      this.ws.send(JSON.stringify({ type: "graph_execute", cypher, _reqId: reqId }));
     });
   }
   async shareContext(summary, filesRead, keyFindings, tags) {
@@ -47968,45 +48007,36 @@ class BrokerClient {
     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);
+      const reqId = this.makeReqId();
+      this.contextResultsResolvers.set(reqId, { resolve, timer: setTimeout(() => {
+        if (this.contextResultsResolvers.delete(reqId))
           resolve([]);
-        }
-      }, 5000);
+      }, 5000) });
+      this.ws.send(JSON.stringify({ type: "get_context", query, _reqId: reqId }));
     });
   }
   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);
+      const reqId = this.makeReqId();
+      this.contextListResolvers.set(reqId, { resolve, timer: setTimeout(() => {
+        if (this.contextListResolvers.delete(reqId))
           resolve([]);
-        }
-      }, 5000);
+      }, 5000) });
+      this.ws.send(JSON.stringify({ type: "list_contexts", _reqId: reqId }));
     });
   }
   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);
+      const reqId = this.makeReqId();
+      this.taskCreatedResolvers.set(reqId, { resolve, timer: setTimeout(() => {
+        if (this.taskCreatedResolvers.delete(reqId))
           resolve(null);
-        }
-      }, 5000);
+      }, 5000) });
+      this.ws.send(JSON.stringify({ type: "create_task", title, assignee, priority, tags, _reqId: reqId }));
     });
   }
   async claimTask(id) {
@@ -48023,30 +48053,24 @@ class BrokerClient {
     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);
+      const reqId = this.makeReqId();
+      this.taskListResolvers.set(reqId, { resolve, timer: setTimeout(() => {
+        if (this.taskListResolvers.delete(reqId))
           resolve([]);
-        }
-      }, 5000);
+      }, 5000) });
+      this.ws.send(JSON.stringify({ type: "list_tasks", status, assignee, _reqId: reqId }));
     });
   }
   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);
+      const reqId = this.makeReqId();
+      this.meshQueryResolvers.set(reqId, { resolve, timer: setTimeout(() => {
+        if (this.meshQueryResolvers.delete(reqId))
           resolve(null);
-        }
-      }, 5000);
+      }, 5000) });
+      this.ws.send(JSON.stringify({ type: "mesh_query", sql, _reqId: reqId }));
     });
   }
   async meshExecute(sql) {
@@ -48058,30 +48082,24 @@ class BrokerClient {
     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);
+      const reqId = this.makeReqId();
+      this.meshSchemaResolvers.set(reqId, { resolve, timer: setTimeout(() => {
+        if (this.meshSchemaResolvers.delete(reqId))
           resolve([]);
-        }
-      }, 5000);
+      }, 5000) });
+      this.ws.send(JSON.stringify({ type: "mesh_schema", _reqId: reqId }));
     });
   }
   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);
+      const reqId = this.makeReqId();
+      this.streamCreatedResolvers.set(reqId, { resolve, timer: setTimeout(() => {
+        if (this.streamCreatedResolvers.delete(reqId))
           resolve(null);
-        }
-      }, 5000);
+      }, 5000) });
+      this.ws.send(JSON.stringify({ type: "create_stream", name, _reqId: reqId }));
     });
   }
   async publish(stream, data) {
@@ -48103,15 +48121,12 @@ class BrokerClient {
     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);
+      const reqId = this.makeReqId();
+      this.streamListResolvers.set(reqId, { resolve, timer: setTimeout(() => {
+        if (this.streamListResolvers.delete(reqId))
           resolve([]);
-        }
-      }, 5000);
+      }, 5000) });
+      this.ws.send(JSON.stringify({ type: "list_streams", _reqId: reqId }));
     });
   }
   onStreamData(handler) {
@@ -48122,20 +48137,17 @@ class BrokerClient {
     this.stateChangeHandlers.add(handler);
     return () => this.stateChangeHandlers.delete(handler);
   }
-  meshInfoResolvers = [];
+  meshInfoResolvers = new Map;
   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);
+      const reqId = this.makeReqId();
+      this.meshInfoResolvers.set(reqId, { resolve, timer: setTimeout(() => {
+        if (this.meshInfoResolvers.delete(reqId))
           resolve(null);
-        }
-      }, 5000);
+      }, 5000) });
+      this.ws.send(JSON.stringify({ type: "mesh_info", _reqId: reqId }));
     });
   }
   close() {
@@ -48151,7 +48163,26 @@ class BrokerClient {
     }
     this.setConnStatus("closed");
   }
+  resolveFromMap(map2, reqId, value) {
+    let entry = reqId ? map2.get(reqId) : undefined;
+    if (!entry) {
+      const first = map2.entries().next().value;
+      if (first) {
+        entry = first[1];
+        map2.delete(first[0]);
+      }
+    } else {
+      map2.delete(reqId);
+    }
+    if (entry) {
+      clearTimeout(entry.timer);
+      entry.resolve(value);
+      return true;
+    }
+    return false;
+  }
   handleServerMessage(msg) {
+    const msgReqId = msg._reqId;
     if (msg.type === "ack") {
       const pending = this.pendingSends.get(String(msg.id ?? ""));
       if (pending) {
@@ -48165,9 +48196,7 @@ class BrokerClient {
     }
     if (msg.type === "peers_list") {
       const peers = msg.peers ?? [];
-      const resolver = this.listPeersResolvers.shift();
-      if (resolver)
-        resolver(peers);
+      this.resolveFromMap(this.listPeersResolvers, msgReqId, peers);
       return;
     }
     if (msg.type === "push") {
@@ -48221,26 +48250,21 @@ class BrokerClient {
       return;
     }
     if (msg.type === "state_result") {
-      const resolver = this.stateResolvers.shift();
-      if (resolver) {
-        if (msg.key) {
-          resolver({
-            key: String(msg.key),
-            value: msg.value,
-            updatedBy: String(msg.updatedBy ?? ""),
-            updatedAt: String(msg.updatedAt ?? "")
-          });
-        } else {
-          resolver(null);
-        }
+      if (msg.key) {
+        this.resolveFromMap(this.stateResolvers, msgReqId, {
+          key: String(msg.key),
+          value: msg.value,
+          updatedBy: String(msg.updatedBy ?? ""),
+          updatedAt: String(msg.updatedAt ?? "")
+        });
+      } else {
+        this.resolveFromMap(this.stateResolvers, msgReqId, null);
       }
       return;
     }
     if (msg.type === "state_list") {
       const entries = msg.entries ?? [];
-      const resolver = this.stateListResolvers.shift();
-      if (resolver)
-        resolver(entries);
+      this.resolveFromMap(this.stateListResolvers, msgReqId, entries);
       return;
     }
     if (msg.type === "state_change") {
@@ -48257,147 +48281,107 @@ class BrokerClient {
       return;
     }
     if (msg.type === "memory_stored") {
-      const resolver = this.memoryStoreResolvers.shift();
-      if (resolver)
-        resolver(msg.id ? String(msg.id) : null);
+      this.resolveFromMap(this.memoryStoreResolvers, msgReqId, msg.id ? String(msg.id) : null);
       return;
     }
     if (msg.type === "memory_results") {
       const memories = msg.memories ?? [];
-      const resolver = this.memoryRecallResolvers.shift();
-      if (resolver)
-        resolver(memories);
+      this.resolveFromMap(this.memoryRecallResolvers, msgReqId, memories);
       return;
     }
     if (msg.type === "message_status_result") {
-      const resolver = this.messageStatusResolvers.shift();
-      if (resolver)
-        resolver(msg);
+      this.resolveFromMap(this.messageStatusResolvers, msgReqId, 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 ?? ""),
-            encrypted: msg.encrypted ? true : undefined,
-            sealedKey: msg.sealedKey ? String(msg.sealedKey) : undefined
-          });
-        } else {
-          resolver(null);
-        }
+      if (msg.url) {
+        this.resolveFromMap(this.fileUrlResolvers, msgReqId, {
+          url: String(msg.url),
+          name: String(msg.name ?? ""),
+          encrypted: msg.encrypted ? true : undefined,
+          sealedKey: msg.sealedKey ? String(msg.sealedKey) : undefined
+        });
+      } else {
+        this.resolveFromMap(this.fileUrlResolvers, msgReqId, null);
       }
       return;
     }
     if (msg.type === "file_list") {
       const files = msg.files ?? [];
-      const resolver = this.fileListResolvers.shift();
-      if (resolver)
-        resolver(files);
+      this.resolveFromMap(this.fileListResolvers, msgReqId, files);
       return;
     }
     if (msg.type === "file_status_result") {
       const accesses = msg.accesses ?? [];
-      const resolver = this.fileStatusResolvers.shift();
-      if (resolver)
-        resolver(accesses);
+      this.resolveFromMap(this.fileStatusResolvers, msgReqId, accesses);
       return;
     }
     if (msg.type === "grant_file_access_ok") {
-      const resolver = this.grantFileAccessResolvers.shift();
-      if (resolver)
-        resolver(true);
+      this.resolveFromMap(this.grantFileAccessResolvers, msgReqId, true);
       return;
     }
     if (msg.type === "vector_stored") {
-      const resolver = this.vectorStoredResolvers.shift();
-      if (resolver)
-        resolver(msg.id ? String(msg.id) : null);
+      this.resolveFromMap(this.vectorStoredResolvers, msgReqId, 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);
+      this.resolveFromMap(this.vectorResultsResolvers, msgReqId, results);
       return;
     }
     if (msg.type === "collection_list") {
       const collections = msg.collections ?? [];
-      const resolver = this.collectionListResolvers.shift();
-      if (resolver)
-        resolver(collections);
+      this.resolveFromMap(this.collectionListResolvers, msgReqId, collections);
       return;
     }
     if (msg.type === "graph_result") {
       const rows = msg.records ?? [];
-      const resolver = this.graphResultResolvers.shift();
-      if (resolver)
-        resolver(rows);
+      this.resolveFromMap(this.graphResultResolvers, msgReqId, rows);
       return;
     }
     if (msg.type === "context_list") {
       const contexts = msg.contexts ?? [];
-      const resolver = this.contextListResolvers.shift();
-      if (resolver)
-        resolver(contexts);
+      this.resolveFromMap(this.contextListResolvers, msgReqId, contexts);
       return;
     }
     if (msg.type === "context_results") {
       const contexts = msg.contexts ?? [];
-      const resolver = this.contextResultsResolvers.shift();
-      if (resolver)
-        resolver(contexts);
+      this.resolveFromMap(this.contextResultsResolvers, msgReqId, contexts);
       return;
     }
     if (msg.type === "task_created") {
-      const resolver = this.taskCreatedResolvers.shift();
-      if (resolver)
-        resolver(msg.id ? String(msg.id) : null);
+      this.resolveFromMap(this.taskCreatedResolvers, msgReqId, 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);
+      this.resolveFromMap(this.taskListResolvers, msgReqId, 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);
-        }
+      if (msg.columns) {
+        this.resolveFromMap(this.meshQueryResolvers, msgReqId, {
+          columns: msg.columns ?? [],
+          rows: msg.rows ?? [],
+          rowCount: msg.rowCount ?? 0
+        });
+      } else {
+        this.resolveFromMap(this.meshQueryResolvers, msgReqId, null);
       }
       return;
     }
     if (msg.type === "mesh_schema_result") {
       const tables = msg.tables ?? [];
-      const resolver = this.meshSchemaResolvers.shift();
-      if (resolver)
-        resolver(tables);
+      this.resolveFromMap(this.meshSchemaResolvers, msgReqId, tables);
       return;
     }
     if (msg.type === "stream_created") {
-      const resolver = this.streamCreatedResolvers.shift();
-      if (resolver)
-        resolver(msg.id ? String(msg.id) : null);
+      this.resolveFromMap(this.streamCreatedResolvers, msgReqId, 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);
+      this.resolveFromMap(this.streamListResolvers, msgReqId, streams);
       return;
     }
     if (msg.type === "stream_data") {
@@ -48414,9 +48398,23 @@ class BrokerClient {
       return;
     }
     if (msg.type === "mesh_info_result") {
-      const resolver = this.meshInfoResolvers.shift();
-      if (resolver)
-        resolver(msg);
+      this.resolveFromMap(this.meshInfoResolvers, msgReqId, msg);
+      return;
+    }
+    if (msg.type === "scheduled_ack") {
+      this.resolveFromMap(this.scheduledAckResolvers, msgReqId, {
+        scheduledId: String(msg.scheduledId ?? ""),
+        deliverAt: Number(msg.deliverAt ?? 0)
+      });
+      return;
+    }
+    if (msg.type === "scheduled_list") {
+      const messages = msg.messages ?? [];
+      this.resolveFromMap(this.scheduledListResolvers, msgReqId, messages);
+      return;
+    }
+    if (msg.type === "cancel_scheduled_ack") {
+      this.resolveFromMap(this.cancelScheduledResolvers, msgReqId, Boolean(msg.ok));
       return;
     }
     if (msg.type === "error") {
@@ -48435,36 +48433,42 @@ class BrokerClient {
         }
       }
       if (!handledByPendingSend) {
-        if (this.stateResolvers.length > 0) {
-          this.stateResolvers.shift()(null);
-        } else if (this.stateListResolvers.length > 0) {
-          this.stateListResolvers.shift()([]);
-        } else if (this.memoryStoreResolvers.length > 0) {
-          this.memoryStoreResolvers.shift()(null);
-        } else if (this.memoryRecallResolvers.length > 0) {
-          this.memoryRecallResolvers.shift()([]);
-        } else if (this.fileUrlResolvers.length > 0) {
-          this.fileUrlResolvers.shift()(null);
-        } else if (this.fileListResolvers.length > 0) {
-          this.fileListResolvers.shift()([]);
-        } else if (this.fileStatusResolvers.length > 0) {
-          this.fileStatusResolvers.shift()([]);
-        } else if (this.graphResultResolvers.length > 0) {
-          this.graphResultResolvers.shift()([]);
-        } else if (this.vectorStoredResolvers.length > 0) {
-          this.vectorStoredResolvers.shift()(null);
-        } else if (this.vectorResultsResolvers.length > 0) {
-          this.vectorResultsResolvers.shift()([]);
-        } else if (this.taskListResolvers.length > 0) {
-          this.taskListResolvers.shift()([]);
-        } else if (this.meshQueryResolvers.length > 0) {
-          this.meshQueryResolvers.shift()(null);
-        } else if (this.contextResultsResolvers.length > 0) {
-          this.contextResultsResolvers.shift()([]);
-        } else if (this.contextListResolvers.length > 0) {
-          this.contextListResolvers.shift()([]);
-        } else if (this.streamListResolvers.length > 0) {
-          this.streamListResolvers.shift()([]);
+        const allMaps = [
+          [this.stateResolvers, null],
+          [this.stateListResolvers, []],
+          [this.memoryStoreResolvers, null],
+          [this.memoryRecallResolvers, []],
+          [this.fileUrlResolvers, null],
+          [this.fileListResolvers, []],
+          [this.fileStatusResolvers, []],
+          [this.graphResultResolvers, []],
+          [this.vectorStoredResolvers, null],
+          [this.vectorResultsResolvers, []],
+          [this.taskListResolvers, []],
+          [this.meshQueryResolvers, null],
+          [this.contextResultsResolvers, []],
+          [this.contextListResolvers, []],
+          [this.streamListResolvers, []],
+          [this.scheduledAckResolvers, null],
+          [this.scheduledListResolvers, []],
+          [this.cancelScheduledResolvers, false],
+          [this.messageStatusResolvers, null],
+          [this.grantFileAccessResolvers, false],
+          [this.collectionListResolvers, []],
+          [this.meshSchemaResolvers, []],
+          [this.taskCreatedResolvers, null],
+          [this.streamCreatedResolvers, null],
+          [this.listPeersResolvers, []],
+          [this.meshInfoResolvers, null]
+        ];
+        for (const [map2, defaultVal] of allMaps) {
+          const first = map2.entries().next().value;
+          if (first) {
+            map2.delete(first[0]);
+            clearTimeout(first[1].timer);
+            first[1].resolve(defaultVal);
+            break;
+          }
         }
       }
     }
@@ -48515,17 +48519,17 @@ async function ensureClient(mesh) {
   const existing = clients.get(mesh.meshId);
   if (existing)
     return existing;
-  const client = new BrokerClient(mesh, { debug: env.CLAUDEMESH_DEBUG, displayName: configDisplayName });
-  clients.set(mesh.meshId, client);
+  const client2 = new BrokerClient(mesh, { debug: env.CLAUDEMESH_DEBUG, displayName: configDisplayName });
+  clients.set(mesh.meshId, client2);
   try {
-    await client.connect();
+    await client2.connect();
     for (const g of configGroups ?? []) {
       try {
-        await client.joinGroup(g.name, g.role);
+        await client2.joinGroup(g.name, g.role);
       } catch {}
     }
   } catch {}
-  return client;
+  return client2;
 }
 async function startClients(config2) {
   configDisplayName = config2.displayName;
@@ -48608,12 +48612,12 @@ async function resolveClient(to) {
 var peerNameCache = new Map;
 var peerNameCacheAge = 0;
 var CACHE_TTL_MS = 30000;
-async function resolvePeerName(client, pubkey) {
+async function resolvePeerName(client2, pubkey) {
   const now = Date.now();
   if (now - peerNameCacheAge > CACHE_TTL_MS) {
     peerNameCache.clear();
     try {
-      const peers = await client.listPeers();
+      const peers = await client2.listPeers();
       for (const p of peers)
         peerNameCache.set(p.pubkey, p.displayName);
     } catch {}
@@ -48763,15 +48767,15 @@ Your message mode is "${messageMode}".
         const results = [];
         const seen = new Set;
         for (const target of targets) {
-          const { client, targetSpec, error: error2 } = await resolveClient(target);
-          if (!client) {
+          const { client: client2, targetSpec, error: error2 } = await resolveClient(target);
+          if (!client2) {
             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");
+          const result = await client2.send(targetSpec, message, priority ?? "next");
           if (!result.ok) {
             results.push(`✗ ${target}: ${result.error}`);
           } else {
@@ -48892,19 +48896,19 @@ ${drained.join(`
         const { key } = args ?? {};
         if (!key)
           return text("get_state: `key` required", true);
-        const client = allClients()[0];
-        if (!client)
+        const client2 = allClients()[0];
+        if (!client2)
           return text("get_state: not connected", true);
-        const result = await client.getState(key);
+        const result = await client2.getState(key);
         if (!result)
           return text(`State "${key}" not found.`);
         return text(`${key} = ${JSON.stringify(result.value)} (set by ${result.updatedBy} at ${result.updatedAt})`);
       }
       case "list_state": {
-        const client = allClients()[0];
-        if (!client)
+        const client2 = allClients()[0];
+        if (!client2)
           return text("list_state: not connected", true);
-        const entries = await client.listState();
+        const entries = await client2.listState();
         if (entries.length === 0)
           return text("No shared state set.");
         const lines = entries.map((e) => `- **${e.key}** = ${JSON.stringify(e.value)} (by ${e.updatedBy})`);
@@ -48915,20 +48919,20 @@ ${drained.join(`
         const { content, tags } = args ?? {};
         if (!content)
           return text("remember: `content` required", true);
-        const client = allClients()[0];
-        if (!client)
+        const client2 = allClients()[0];
+        if (!client2)
           return text("remember: not connected", true);
-        const id = await client.remember(content, tags);
+        const id = await client2.remember(content, tags);
         return text(`Remembered${id ? ` (${id})` : ""}: "${content.slice(0, 80)}${content.length > 80 ? "..." : ""}"`);
       }
       case "recall": {
         const { query } = args ?? {};
         if (!query)
           return text("recall: `query` required", true);
-        const client = allClients()[0];
-        if (!client)
+        const client2 = allClients()[0];
+        if (!client2)
           return text("recall: not connected", true);
-        const memories = await client.recall(query);
+        const memories = await client2.recall(query);
         if (memories.length === 0)
           return text(`No memories found for "${query}".`);
         const lines = memories.map((m) => `- [${m.id.slice(0, 8)}] ${m.content} (by ${m.rememberedBy}, ${m.rememberedAt})`);
@@ -48940,12 +48944,63 @@ ${lines.join(`
         const { id } = args ?? {};
         if (!id)
           return text("forget: `id` required", true);
-        const client = allClients()[0];
-        if (!client)
+        const client2 = allClients()[0];
+        if (!client2)
           return text("forget: not connected", true);
-        await client.forget(id);
+        await client2.forget(id);
         return text(`Forgotten: ${id}`);
       }
+      case "schedule_reminder":
+      case "send_later": {
+        const sArgs = args ?? {};
+        if (!sArgs.message)
+          return text(`${name}: \`message\` required`, true);
+        const to = name === "schedule_reminder" ? "self" : sArgs.to ?? "";
+        if (name === "send_later" && !to)
+          return text("send_later: `to` required", true);
+        let deliverAt;
+        if (sArgs.deliver_at) {
+          deliverAt = Number(sArgs.deliver_at);
+        } else if (sArgs.in_seconds) {
+          deliverAt = Date.now() + Number(sArgs.in_seconds) * 1000;
+        } else {
+          return text(`${name}: provide \`deliver_at\` (ms timestamp) or \`in_seconds\``, true);
+        }
+        let targetSpec = to;
+        if (name === "send_later" && !to.startsWith("@") && to !== "*" && !/^[0-9a-f]{64}$/i.test(to) && to !== "self") {
+          const peers = await client.listPeers();
+          const match = peers.find((p) => p.displayName.toLowerCase() === to.toLowerCase());
+          if (!match) {
+            const names = peers.map((p) => p.displayName).join(", ");
+            return text(`send_later: peer "${to}" not found. Online: ${names || "(none)"}`, true);
+          }
+          targetSpec = match.pubkey;
+        }
+        if (name === "schedule_reminder") {
+          targetSpec = client.getSessionPubkey() ?? "*";
+        }
+        const result = await client.scheduleMessage(targetSpec, sArgs.message, deliverAt);
+        if (!result)
+          return text(`${name}: broker did not acknowledge — check connection`, true);
+        const when = new Date(result.deliverAt).toISOString();
+        return text(name === "schedule_reminder" ? `Reminder scheduled (${result.scheduledId.slice(0, 8)}): "${sArgs.message.slice(0, 60)}" at ${when}` : `Message to "${to}" scheduled (${result.scheduledId.slice(0, 8)}) for ${when}`);
+      }
+      case "list_scheduled": {
+        const scheduled = await client.listScheduled();
+        if (scheduled.length === 0)
+          return text("No pending scheduled messages.");
+        const lines = scheduled.map((m) => `- [${m.id.slice(0, 8)}] → ${m.to === client.getSessionPubkey() ? "self (reminder)" : m.to} at ${new Date(m.deliverAt).toISOString()}: "${m.message.slice(0, 60)}${m.message.length > 60 ? "…" : ""}"`);
+        return text(`${scheduled.length} scheduled:
+${lines.join(`
+`)}`);
+      }
+      case "cancel_scheduled": {
+        const { id: schedId } = args ?? {};
+        if (!schedId)
+          return text("cancel_scheduled: `id` required", true);
+        const ok = await client.cancelScheduled(schedId);
+        return text(ok ? `Cancelled: ${schedId}` : `Not found or already fired: ${schedId}`, !ok);
+      }
       case "share_file": {
         const { path: filePath, name: fileName, tags, to: fileTo } = args ?? {};
         if (!filePath)
@@ -48953,15 +49008,15 @@ ${lines.join(`
         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)
+        const client2 = allClients()[0];
+        if (!client2)
           return text("share_file: not connected", true);
         if (fileTo) {
           const { encryptFile: encryptFile2, sealKeyForPeer: sealKeyForPeer2 } = await Promise.resolve().then(() => (init_file_crypto(), exports_file_crypto));
           const { readFileSync: readFileSync2, writeFileSync: writeFileSync2, mkdtempSync, unlinkSync, rmdirSync } = await import("node:fs");
           const { tmpdir } = await import("node:os");
           const { join: join2, basename } = await import("node:path");
-          const peers = await client.listPeers();
+          const peers = await client2.listPeers();
           const targetPeer = peers.find((p) => p.pubkey === fileTo || p.displayName === fileTo);
           if (!targetPeer) {
             return text(`share_file: peer not found: ${fileTo}`, true);
@@ -48969,7 +49024,7 @@ ${lines.join(`
           const plaintext = readFileSync2(filePath);
           const { ciphertext, nonce, key } = await encryptFile2(new Uint8Array(plaintext));
           const sealedForTarget = await sealKeyForPeer2(key, targetPeer.pubkey);
-          const myPubkey = client.getSessionPubkey();
+          const myPubkey = client2.getSessionPubkey();
           const sealedForSelf = myPubkey ? await sealKeyForPeer2(key, myPubkey) : null;
           const fileKeys = [
             { peerPubkey: targetPeer.pubkey, sealedKey: sealedForTarget },
@@ -48986,7 +49041,7 @@ ${lines.join(`
           const tmpPath = join2(tmpDir, baseName);
           writeFileSync2(tmpPath, combined);
           try {
-            const fileId = await client.uploadFile(tmpPath, client.meshId, client.meshSlug, {
+            const fileId = await client2.uploadFile(tmpPath, client2.meshId, client2.meshSlug, {
               name: baseName,
               tags,
               persistent: true,
@@ -49007,7 +49062,7 @@ ${lines.join(`
           }
         }
         try {
-          const fileId = await client.uploadFile(filePath, client.meshId, client.meshSlug, {
+          const fileId = await client2.uploadFile(filePath, client2.meshId, client2.meshSlug, {
             name: fileName,
             tags,
             persistent: true
@@ -49021,10 +49076,10 @@ ${lines.join(`
         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)
+        const client2 = allClients()[0];
+        if (!client2)
           return text("get_file: not connected", true);
-        const result = await client.getFile(id);
+        const result = await client2.getFile(id);
         if (!result)
           return text(`get_file: file ${id} not found`, true);
         if (result.encrypted) {
@@ -49032,8 +49087,8 @@ ${lines.join(`
             return text("get_file: encrypted file — no decryption key available for your session", true);
           const { openSealedKey: openSealedKey2, decryptFile: decryptFile2 } = await Promise.resolve().then(() => (init_file_crypto(), exports_file_crypto));
           const { ensureSodium: ensureSodium2 } = await Promise.resolve().then(() => (init_keypair(), exports_keypair));
-          const myPubkey = client.getSessionPubkey();
-          const mySecret = client.getSessionSecretKey();
+          const myPubkey = client2.getSessionPubkey();
+          const mySecret = client2.getSessionSecretKey();
           if (!myPubkey || !mySecret) {
             return text("get_file: no session keypair — cannot decrypt", true);
           }
@@ -49068,10 +49123,10 @@ ${lines.join(`
       }
       case "list_files": {
         const { query, from } = args ?? {};
-        const client = allClients()[0];
-        if (!client)
+        const client2 = allClients()[0];
+        if (!client2)
           return text("list_files: not connected", true);
-        const files = await client.listFiles(query, from);
+        const files = await client2.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(", ")}]` : ""}`);
@@ -49082,10 +49137,10 @@ ${lines.join(`
         const { id } = args ?? {};
         if (!id)
           return text("file_status: `id` required", true);
-        const client = allClients()[0];
-        if (!client)
+        const client2 = allClients()[0];
+        if (!client2)
           return text("file_status: not connected", true);
-        const accesses = await client.fileStatus(id);
+        const accesses = await client2.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}`);
@@ -49097,30 +49152,30 @@ ${lines.join(`
         const { id } = args ?? {};
         if (!id)
           return text("delete_file: `id` required", true);
-        const client = allClients()[0];
-        if (!client)
+        const client2 = allClients()[0];
+        if (!client2)
           return text("delete_file: not connected", true);
-        await client.deleteFile(id);
+        await client2.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)
+        const client2 = allClients()[0];
+        if (!client2)
           return text("vector_store: not connected", true);
-        const id = await client.vectorStore(collection, storeText, metadata);
+        const id = await client2.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)
+        const client2 = allClients()[0];
+        if (!client2)
           return text("vector_search: not connected", true);
-        const results = await client.vectorSearch(collection, query, limit);
+        const results = await client2.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 ? "…" : ""}`);
@@ -49132,17 +49187,17 @@ ${lines.join(`
         const { collection, id } = args ?? {};
         if (!collection || !id)
           return text("vector_delete: `collection` and `id` required", true);
-        const client = allClients()[0];
-        if (!client)
+        const client2 = allClients()[0];
+        if (!client2)
           return text("vector_delete: not connected", true);
-        await client.vectorDelete(collection, id);
+        await client2.vectorDelete(collection, id);
         return text(`Deleted ${id} from ${collection}`);
       }
       case "list_collections": {
-        const client = allClients()[0];
-        if (!client)
+        const client2 = allClients()[0];
+        if (!client2)
           return text("list_collections: not connected", true);
-        const collections = await client.listCollections();
+        const collections = await client2.listCollections();
         if (collections.length === 0)
           return text("No vector collections.");
         return text(`Collections:
@@ -49153,10 +49208,10 @@ ${collections.map((c) => `- ${c}`).join(`
         const { cypher } = args ?? {};
         if (!cypher)
           return text("graph_query: `cypher` required", true);
-        const client = allClients()[0];
-        if (!client)
+        const client2 = allClients()[0];
+        if (!client2)
           return text("graph_query: not connected", true);
-        const rows = await client.graphQuery(cypher);
+        const rows = await client2.graphQuery(cypher);
         if (rows.length === 0)
           return text("No results.");
         return text(JSON.stringify(rows, null, 2));
@@ -49165,30 +49220,30 @@ ${collections.map((c) => `- ${c}`).join(`
         const { cypher } = args ?? {};
         if (!cypher)
           return text("graph_execute: `cypher` required", true);
-        const client = allClients()[0];
-        if (!client)
+        const client2 = allClients()[0];
+        if (!client2)
           return text("graph_execute: not connected", true);
-        const rows = await client.graphExecute(cypher);
+        const rows = await client2.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)
+        const client2 = allClients()[0];
+        if (!client2)
           return text("share_context: not connected", true);
-        await client.shareContext(summary, files_read, key_findings, tags);
+        await client2.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)
+        const client2 = allClients()[0];
+        if (!client2)
           return text("get_context: not connected", true);
-        const contexts = await client.getContext(query);
+        const contexts = await client2.getContext(query);
         if (contexts.length === 0)
           return text(`No context found for "${query}".`);
         const lines = contexts.map((c) => {
@@ -49203,10 +49258,10 @@ ${lines.join(`
 `)}`);
       }
       case "list_contexts": {
-        const client = allClients()[0];
-        if (!client)
+        const client2 = allClients()[0];
+        if (!client2)
           return text("list_contexts: not connected", true);
-        const contexts = await client.listContexts();
+        const contexts = await client2.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(", ")}]` : ""}`);
@@ -49218,38 +49273,38 @@ ${lines.join(`
         const { title, assignee, priority, tags } = args ?? {};
         if (!title)
           return text("create_task: `title` required", true);
-        const client = allClients()[0];
-        if (!client)
+        const client2 = allClients()[0];
+        if (!client2)
           return text("create_task: not connected", true);
-        const id = await client.createTask(title, assignee, priority, tags);
+        const id = await client2.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)
+        const client2 = allClients()[0];
+        if (!client2)
           return text("claim_task: not connected", true);
-        await client.claimTask(id);
+        await client2.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)
+        const client2 = allClients()[0];
+        if (!client2)
           return text("complete_task: not connected", true);
-        await client.completeTask(id, result);
+        await client2.completeTask(id, result);
         return text(`Completed task: ${id}${result ? ` — ${result}` : ""}`);
       }
       case "list_tasks": {
         const { status, assignee } = args ?? {};
-        const client = allClients()[0];
-        if (!client)
+        const client2 = allClients()[0];
+        if (!client2)
           return text("list_tasks: not connected", true);
-        const tasks = await client.listTasks(status, assignee);
+        const tasks = await client2.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})`);
@@ -49261,10 +49316,10 @@ ${lines.join(`
         const { sql: querySql } = args ?? {};
         if (!querySql)
           return text("mesh_query: `sql` required", true);
-        const client = allClients()[0];
-        if (!client)
+        const client2 = allClients()[0];
+        if (!client2)
           return text("mesh_query: not connected", true);
-        const result = await client.meshQuery(querySql);
+        const result = await client2.meshQuery(querySql);
         if (!result)
           return text("mesh_query: query failed or timed out", true);
         if (result.rows.length === 0)
@@ -49282,17 +49337,17 @@ ${rows.join(`
         const { sql: execSql } = args ?? {};
         if (!execSql)
           return text("mesh_execute: `sql` required", true);
-        const client = allClients()[0];
-        if (!client)
+        const client2 = allClients()[0];
+        if (!client2)
           return text("mesh_execute: not connected", true);
-        await client.meshExecute(execSql);
+        await client2.meshExecute(execSql);
         return text(`Executed.`);
       }
       case "mesh_schema": {
-        const client = allClients()[0];
-        if (!client)
+        const client2 = allClients()[0];
+        if (!client2)
           return text("mesh_schema: not connected", true);
-        const tables = await client.meshSchema();
+        const tables = await client2.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(", ")}`);
@@ -49303,37 +49358,37 @@ ${rows.join(`
         const { name: streamName } = args ?? {};
         if (!streamName)
           return text("create_stream: `name` required", true);
-        const client = allClients()[0];
-        if (!client)
+        const client2 = allClients()[0];
+        if (!client2)
           return text("create_stream: not connected", true);
-        const streamId = await client.createStream(streamName);
+        const streamId = await client2.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)
+        const client2 = allClients()[0];
+        if (!client2)
           return text("publish: not connected", true);
-        await client.publish(pubStream, pubData);
+        await client2.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)
+        const client2 = allClients()[0];
+        if (!client2)
           return text("subscribe: not connected", true);
-        await client.subscribe(subStream);
+        await client2.subscribe(subStream);
         return text(`Subscribed to ${subStream}. Data pushes will arrive as channel notifications.`);
       }
       case "list_streams": {
-        const client = allClients()[0];
-        if (!client)
+        const client2 = allClients()[0];
+        if (!client2)
           return text("list_streams: not connected", true);
-        const streams = await client.listStreams();
+        const streams = await client2.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)`);
@@ -49341,10 +49396,10 @@ ${rows.join(`
 `));
       }
       case "mesh_info": {
-        const client = allClients()[0];
-        if (!client)
+        const client2 = allClients()[0];
+        if (!client2)
           return text("mesh_info: not connected", true);
-        const info = await client.meshInfo();
+        const info = await client2.meshInfo();
         if (!info)
           return text("mesh_info: timed out", true);
         const lines = [
@@ -49366,21 +49421,21 @@ ${rows.join(`
       case "ping_mesh": {
         const { priorities: pingPriorities } = args ?? {};
         const toTest = pingPriorities ?? ["now", "next"];
-        const client = allClients()[0];
-        if (!client)
+        const client2 = allClients()[0];
+        if (!client2)
           return text("ping_mesh: not connected", true);
         const results = [];
-        results.push(`WS status: ${client.status}`);
-        results.push(`Mesh: ${client.meshSlug}`);
-        const peers = await client.listPeers();
+        results.push(`WS status: ${client2.status}`);
+        results.push(`Mesh: ${client2.meshSlug}`);
+        const peers = await client2.listPeers();
         const selfPeer = peers.find((p) => p.displayName === myName);
         results.push(`Your status: ${selfPeer?.status ?? "not found in peer list"}`);
         results.push(`Peers online: ${peers.length}`);
-        results.push(`Push buffer: ${client.pushHistory.length} buffered`);
+        results.push(`Push buffer: ${client2.pushHistory.length} buffered`);
         for (const prio of toTest) {
           const sendTime = Date.now();
           const target = peers.find((p) => p.displayName !== myName);
-          const sendResult = await client.send(target?.pubkey ?? "*", `__ping__ ${prio} from ${myName} at ${new Date().toISOString()}`, prio);
+          const sendResult = await client2.send(target?.pubkey ?? "*", `__ping__ ${prio} from ${myName} at ${new Date().toISOString()}`, prio);
           const ackTime = Date.now();
           if (!sendResult.ok) {
             results.push(`[${prio}] SEND FAILED: ${sendResult.error}`);
@@ -49403,14 +49458,14 @@ ${rows.join(`
         const { fileId, to: grantTo } = args ?? {};
         if (!fileId || !grantTo)
           return text("grant_file_access: `fileId` and `to` required", true);
-        const client = allClients()[0];
-        if (!client)
+        const client2 = allClients()[0];
+        if (!client2)
           return text("grant_file_access: not connected", true);
-        const peers = await client.listPeers();
+        const peers = await client2.listPeers();
         const targetPeer = peers.find((p) => p.pubkey === grantTo || p.displayName === grantTo);
         if (!targetPeer)
           return text(`grant_file_access: peer not found: ${grantTo}`, true);
-        const result = await client.getFile(fileId);
+        const result = await client2.getFile(fileId);
         if (!result)
           return text("grant_file_access: file not found", true);
         if (!result.encrypted)
@@ -49418,15 +49473,15 @@ ${rows.join(`
         if (!result.sealedKey)
           return text("grant_file_access: no key available (are you the owner?)", true);
         const { openSealedKey: openSealedKey2, sealKeyForPeer: sealKeyForPeer2 } = await Promise.resolve().then(() => (init_file_crypto(), exports_file_crypto));
-        const myPubkey = client.getSessionPubkey();
-        const mySecret = client.getSessionSecretKey();
+        const myPubkey = client2.getSessionPubkey();
+        const mySecret = client2.getSessionSecretKey();
         if (!myPubkey || !mySecret)
           return text("grant_file_access: no session keypair", true);
         const kf = await openSealedKey2(result.sealedKey, myPubkey, mySecret);
         if (!kf)
           return text("grant_file_access: cannot decrypt your own key", true);
         const sealedForPeer = await sealKeyForPeer2(kf, targetPeer.pubkey);
-        const ok = await client.grantFileAccess(fileId, targetPeer.pubkey, sealedForPeer);
+        const ok = await client2.grantFileAccess(fileId, targetPeer.pubkey, sealedForPeer);
         if (!ok)
           return text("grant_file_access: broker did not confirm", true);
         return text(`Access granted: ${targetPeer.displayName} can now download file ${fileId}`);
@@ -49438,12 +49493,12 @@ ${rows.join(`
   await startClients(config2);
   const transport = new StdioServerTransport;
   await server.connect(transport);
-  for (const client of allClients()) {
-    client.onPush(async (msg) => {
+  for (const client2 of allClients()) {
+    client2.onPush(async (msg) => {
       if (messageMode === "off")
         return;
       const fromPubkey = msg.senderPubkey || "";
-      const fromName = fromPubkey ? await resolvePeerName(client, fromPubkey) : "unknown";
+      const fromName = fromPubkey ? await resolvePeerName(client2, fromPubkey) : "unknown";
       if (messageMode === "inbox") {
         try {
           await server.notification({
@@ -49465,8 +49520,8 @@ ${rows.join(`
             meta: {
               from_id: fromPubkey,
               from_name: fromName,
-              mesh_slug: client.meshSlug,
-              mesh_id: client.meshId,
+              mesh_slug: client2.meshSlug,
+              mesh_id: client2.meshId,
               priority: msg.priority,
               sent_at: msg.createdAt,
               delivered_at: msg.receivedAt,
@@ -49481,7 +49536,7 @@ ${rows.join(`
 `);
       }
     });
-    client.onStreamData(async (evt) => {
+    client2.onStreamData(async (evt) => {
       try {
         await server.notification({
           method: "notifications/claude/channel",
@@ -49496,7 +49551,7 @@ ${rows.join(`
         });
       } catch {}
     });
-    client.onStateChange(async (change) => {
+    client2.onStateChange(async (change) => {
       try {
         await server.notification({
           method: "notifications/claude/channel",
@@ -49513,17 +49568,17 @@ ${rows.join(`
     });
   }
   setTimeout(async () => {
-    const client = allClients()[0];
-    if (!client || client.status !== "open")
+    const client2 = allClients()[0];
+    if (!client2 || client2.status !== "open")
       return;
     try {
-      const peers = await client.listPeers();
+      const peers = await client2.listPeers();
       const peerNames = peers.filter((p) => p.displayName !== myName).map((p) => p.displayName).join(", ") || "none";
       await server.notification({
         method: "notifications/claude/channel",
         params: {
-          content: `[system] Connected as ${myName} to mesh ${client.meshSlug}. ${peers.length} peer(s) online: ${peerNames}. Call mesh_info for full details or set_summary to announce yourself.`,
-          meta: { kind: "welcome", mesh_slug: client.meshSlug }
+          content: `[system] Connected as ${myName} to mesh ${client2.meshSlug}. ${peers.length} peer(s) online: ${peerNames}. Call mesh_info for full details or set_summary to announce yourself.`,
+          meta: { kind: "welcome", mesh_slug: client2.meshSlug }
         }
       });
     } catch {}
@@ -50498,7 +50553,7 @@ init_config();
 // package.json
 var package_default = {
   name: "claudemesh-cli",
-  version: "0.6.5",
+  version: "0.6.7",
   description: "Claude Code MCP client for claudemesh — peer mesh messaging between Claude sessions.",
   keywords: [
     "claude-code",
@@ -50931,13 +50986,13 @@ Joined: ${config2.meshes.map((m) => m.slug).join(", ")}`);
     process.exit(1);
   }
   const displayName = opts.displayName ?? config2.displayName ?? `${hostname3()}-${process.pid}`;
-  const client = new BrokerClient(mesh, { displayName });
+  const client2 = new BrokerClient(mesh, { displayName });
   try {
-    await client.connect();
-    const result = await fn(client, mesh);
+    await client2.connect();
+    const result = await fn(client2, mesh);
     return result;
   } finally {
-    client.close();
+    client2.close();
   }
 }
 
@@ -50948,8 +51003,8 @@ async function runPeers(flags) {
   const bold2 = (s) => useColor ? `\x1B[1m${s}\x1B[22m` : s;
   const green = (s) => useColor ? `\x1B[32m${s}\x1B[39m` : s;
   const yellow = (s) => useColor ? `\x1B[33m${s}\x1B[39m` : s;
-  await withMesh({ meshSlug: flags.mesh ?? null }, async (client, mesh) => {
-    const peers = await client.listPeers();
+  await withMesh({ meshSlug: flags.mesh ?? null }, async (client2, mesh) => {
+    const peers = await client2.listPeers();
     if (flags.json) {
       console.log(JSON.stringify(peers, null, 2));
       return;
@@ -50974,10 +51029,10 @@ async function runPeers(flags) {
 // src/commands/send.ts
 async function runSend(flags, to, message) {
   const priority = flags.priority === "now" ? "now" : flags.priority === "low" ? "low" : "next";
-  await withMesh({ meshSlug: flags.mesh ?? null }, async (client) => {
+  await withMesh({ meshSlug: flags.mesh ?? null }, async (client2) => {
     let targetSpec = to;
     if (!to.startsWith("@") && to !== "*" && !/^[0-9a-f]{64}$/i.test(to)) {
-      const peers = await client.listPeers();
+      const peers = await client2.listPeers();
       const match = peers.find((p) => p.displayName.toLowerCase() === to.toLowerCase());
       if (!match) {
         const names = peers.map((p) => p.displayName).join(", ");
@@ -50986,7 +51041,7 @@ async function runSend(flags, to, message) {
       }
       targetSpec = match.pubkey;
     }
-    const result = await client.send(targetSpec, message, priority);
+    const result = await client2.send(targetSpec, message, priority);
     if (result.ok) {
       console.log(`✓ Sent to ${to}${result.messageId ? ` (${result.messageId.slice(0, 8)})` : ""}`);
     } else {
@@ -51012,9 +51067,9 @@ async function runInbox(flags) {
   const dim = (s) => useColor ? `\x1B[2m${s}\x1B[22m` : s;
   const bold2 = (s) => useColor ? `\x1B[1m${s}\x1B[22m` : s;
   const waitMs = (flags.wait ?? 1) * 1000;
-  await withMesh({ meshSlug: flags.mesh ?? null }, async (client, mesh) => {
+  await withMesh({ meshSlug: flags.mesh ?? null }, async (client2, mesh) => {
     await new Promise((resolve2) => setTimeout(resolve2, waitMs));
-    const messages = client.drainPushBuffer();
+    const messages = client2.drainPushBuffer();
     if (flags.json) {
       console.log(JSON.stringify(messages, null, 2));
       return;
@@ -51036,8 +51091,8 @@ async function runInbox(flags) {
 async function runStateGet(flags, key) {
   const useColor = !process.env.NO_COLOR && process.env.TERM !== "dumb" && process.stdout.isTTY;
   const dim = (s) => useColor ? `\x1B[2m${s}\x1B[22m` : s;
-  await withMesh({ meshSlug: flags.mesh ?? null }, async (client) => {
-    const entry = await client.getState(key);
+  await withMesh({ meshSlug: flags.mesh ?? null }, async (client2) => {
+    const entry = await client2.getState(key);
     if (!entry) {
       console.log(dim(`(not set)`));
       return;
@@ -51058,8 +51113,8 @@ async function runStateSet(flags, key, value) {
   } catch {
     parsed = value;
   }
-  await withMesh({ meshSlug: flags.mesh ?? null }, async (client) => {
-    await client.setState(key, parsed);
+  await withMesh({ meshSlug: flags.mesh ?? null }, async (client2) => {
+    await client2.setState(key, parsed);
     console.log(`✓ ${key} = ${JSON.stringify(parsed)}`);
   });
 }
@@ -51067,8 +51122,8 @@ async function runStateList(flags) {
   const useColor = !process.env.NO_COLOR && process.env.TERM !== "dumb" && process.stdout.isTTY;
   const dim = (s) => useColor ? `\x1B[2m${s}\x1B[22m` : s;
   const bold2 = (s) => useColor ? `\x1B[1m${s}\x1B[22m` : s;
-  await withMesh({ meshSlug: flags.mesh ?? null }, async (client, mesh) => {
-    const entries = await client.listState();
+  await withMesh({ meshSlug: flags.mesh ?? null }, async (client2, mesh) => {
+    const entries = await client2.listState();
     if (flags.json) {
       console.log(JSON.stringify(entries, null, 2));
       return;
@@ -51085,6 +51140,214 @@ async function runStateList(flags) {
   });
 }
 
+// src/commands/memory.ts
+async function runRemember(flags, content) {
+  const tags = flags.tags ? flags.tags.split(",").map((t) => t.trim()).filter(Boolean) : undefined;
+  await withMesh({ meshSlug: flags.mesh ?? null }, async (client2) => {
+    const id = await client2.remember(content, tags);
+    if (flags.json) {
+      console.log(JSON.stringify({ id, content, tags }));
+      return;
+    }
+    if (id) {
+      console.log(`✓ Remembered (${id.slice(0, 8)})`);
+    } else {
+      console.error("✗ Failed to store memory");
+      process.exit(1);
+    }
+  });
+}
+async function runRecall(flags, query) {
+  const useColor = !process.env.NO_COLOR && process.env.TERM !== "dumb" && process.stdout.isTTY;
+  const dim = (s) => useColor ? `\x1B[2m${s}\x1B[22m` : s;
+  const bold2 = (s) => useColor ? `\x1B[1m${s}\x1B[22m` : s;
+  await withMesh({ meshSlug: flags.mesh ?? null }, async (client2) => {
+    const memories = await client2.recall(query);
+    if (flags.json) {
+      console.log(JSON.stringify(memories, null, 2));
+      return;
+    }
+    if (memories.length === 0) {
+      console.log(dim("No memories found."));
+      return;
+    }
+    for (const m of memories) {
+      const tags = m.tags.length ? dim(` [${m.tags.join(", ")}]`) : "";
+      console.log(`${bold2(m.id.slice(0, 8))}${tags}`);
+      console.log(`  ${m.content}`);
+      console.log(dim(`  ${m.rememberedBy} · ${new Date(m.rememberedAt).toLocaleString()}`));
+      console.log("");
+    }
+  });
+}
+
+// src/commands/info.ts
+init_config();
+async function runInfo(flags) {
+  const useColor = !process.env.NO_COLOR && process.env.TERM !== "dumb" && process.stdout.isTTY;
+  const dim = (s) => useColor ? `\x1B[2m${s}\x1B[22m` : s;
+  const bold2 = (s) => useColor ? `\x1B[1m${s}\x1B[22m` : s;
+  const config2 = loadConfig();
+  await withMesh({ meshSlug: flags.mesh ?? null }, async (client2, mesh) => {
+    const [brokerInfo, peers, state] = await Promise.all([
+      client2.meshInfo(),
+      client2.listPeers(),
+      client2.listState()
+    ]);
+    const output = {
+      slug: mesh.slug,
+      meshId: mesh.meshId,
+      memberId: mesh.memberId,
+      brokerUrl: mesh.brokerUrl,
+      displayName: config2.displayName ?? null,
+      peerCount: peers.length,
+      stateCount: state.length,
+      ...brokerInfo ?? {}
+    };
+    if (flags.json) {
+      console.log(JSON.stringify(output, null, 2));
+      return;
+    }
+    console.log(bold2(mesh.slug) + dim(` · ${mesh.brokerUrl}`));
+    console.log(dim(`  mesh:   ${mesh.meshId}`));
+    console.log(dim(`  member: ${mesh.memberId}`));
+    console.log(`  peers:  ${peers.length} connected`);
+    console.log(`  state:  ${state.length} keys`);
+    if (brokerInfo && typeof brokerInfo === "object") {
+      for (const [k, v] of Object.entries(brokerInfo)) {
+        if (["slug", "meshId", "brokerUrl"].includes(k))
+          continue;
+        console.log(dim(`  ${k}: ${JSON.stringify(v)}`));
+      }
+    }
+  });
+}
+
+// src/commands/remind.ts
+function parseDuration(raw) {
+  const m = raw.trim().match(/^(\d+(?:\.\d+)?)\s*(s|sec|m|min|h|hr|d|day)?$/i);
+  if (!m)
+    return null;
+  const n = parseFloat(m[1]);
+  const unit = (m[2] ?? "s").toLowerCase();
+  if (unit.startsWith("d"))
+    return n * 86400000;
+  if (unit.startsWith("h"))
+    return n * 3600000;
+  if (unit.startsWith("m"))
+    return n * 60000;
+  return n * 1000;
+}
+function parseDeliverAt(flags) {
+  if (flags.in) {
+    const ms = parseDuration(flags.in);
+    if (ms === null)
+      return null;
+    return Date.now() + ms;
+  }
+  if (flags.at) {
+    const hm = flags.at.match(/^(\d{1,2}):(\d{2})$/);
+    if (hm) {
+      const now = new Date;
+      const target = new Date(now);
+      target.setHours(parseInt(hm[1], 10), parseInt(hm[2], 10), 0, 0);
+      if (target <= now)
+        target.setDate(target.getDate() + 1);
+      return target.getTime();
+    }
+    const ts = Date.parse(flags.at);
+    return isNaN(ts) ? null : ts;
+  }
+  return null;
+}
+async function runRemind(flags, positional) {
+  const useColor = !process.env.NO_COLOR && process.env.TERM !== "dumb" && process.stdout.isTTY;
+  const dim = (s) => useColor ? `\x1B[2m${s}\x1B[22m` : s;
+  const bold2 = (s) => useColor ? `\x1B[1m${s}\x1B[22m` : s;
+  const action = positional[0];
+  if (action === "list") {
+    await withMesh({ meshSlug: flags.mesh ?? null }, async (client2) => {
+      const scheduled = await client2.listScheduled();
+      if (flags.json) {
+        console.log(JSON.stringify(scheduled, null, 2));
+        return;
+      }
+      if (scheduled.length === 0) {
+        console.log(dim("No pending reminders."));
+        return;
+      }
+      for (const m of scheduled) {
+        const when = new Date(m.deliverAt).toLocaleString();
+        const to = m.to === client2.getSessionPubkey() ? dim("(self)") : m.to;
+        console.log(`  ${bold2(m.id.slice(0, 8))} → ${to} at ${when}`);
+        console.log(`  ${dim(m.message.slice(0, 80))}`);
+        console.log("");
+      }
+    });
+    return;
+  }
+  if (action === "cancel") {
+    const id = positional[1];
+    if (!id) {
+      console.error("Usage: claudemesh remind cancel <id>");
+      process.exit(1);
+    }
+    await withMesh({ meshSlug: flags.mesh ?? null }, async (client2) => {
+      const ok = await client2.cancelScheduled(id);
+      if (ok)
+        console.log(`✓ Cancelled ${id}`);
+      else {
+        console.error(`✗ Not found or already fired: ${id}`);
+        process.exit(1);
+      }
+    });
+    return;
+  }
+  const message = action ?? positional.join(" ");
+  if (!message) {
+    console.error("Usage: claudemesh remind <message> --in <duration>");
+    console.error("       claudemesh remind <message> --at <time>");
+    console.error("       claudemesh remind list");
+    console.error("       claudemesh remind cancel <id>");
+    process.exit(1);
+  }
+  const deliverAt = parseDeliverAt(flags);
+  if (deliverAt === null) {
+    console.error('Specify when: --in <duration> (e.g. "2h", "30m") or --at <time> (e.g. "15:00")');
+    process.exit(1);
+  }
+  await withMesh({ meshSlug: flags.mesh ?? null }, async (client2) => {
+    let targetSpec;
+    if (flags.to && flags.to !== "self") {
+      if (flags.to.startsWith("@") || flags.to === "*" || /^[0-9a-f]{64}$/i.test(flags.to)) {
+        targetSpec = flags.to;
+      } else {
+        const peers = await client2.listPeers();
+        const match = peers.find((p) => p.displayName.toLowerCase() === flags.to.toLowerCase());
+        if (!match) {
+          console.error(`Peer "${flags.to}" not found. Online: ${peers.map((p) => p.displayName).join(", ") || "(none)"}`);
+          process.exit(1);
+        }
+        targetSpec = match.pubkey;
+      }
+    } else {
+      targetSpec = client2.getSessionPubkey() ?? "*";
+    }
+    const result = await client2.scheduleMessage(targetSpec, message, deliverAt);
+    if (!result) {
+      console.error("✗ Broker did not acknowledge — check connection");
+      process.exit(1);
+    }
+    if (flags.json) {
+      console.log(JSON.stringify(result));
+      return;
+    }
+    const when = new Date(result.deliverAt).toLocaleString();
+    const toLabel = !flags.to || flags.to === "self" ? "yourself" : flags.to;
+    console.log(`✓ Reminder set (${result.scheduledId.slice(0, 8)}): "${message}" → ${toLabel} at ${when}`);
+  });
+}
+
 // src/index.ts
 var launch = defineCommand({
   meta: {
@@ -51270,6 +51533,55 @@ var main = defineCommand({
         }
       }
     }),
+    info: defineCommand({
+      meta: { name: "info", description: "Show mesh overview: slug, broker, peer count, state keys" },
+      args: {
+        mesh: { type: "string", description: "Mesh slug (auto-selected if only one joined)" },
+        json: { type: "boolean", description: "Output as JSON", default: false }
+      },
+      async run({ args }) {
+        await runInfo(args);
+      }
+    }),
+    remember: defineCommand({
+      meta: { name: "remember", description: "Store a memory in the mesh (accessible to all peers)" },
+      args: {
+        content: { type: "positional", description: "Text to remember", required: true },
+        mesh: { type: "string", description: "Mesh slug (auto-selected if only one joined)" },
+        tags: { type: "string", description: "Comma-separated tags (e.g. task,context)" },
+        json: { type: "boolean", description: "Output as JSON", default: false }
+      },
+      async run({ args }) {
+        await runRemember(args, args.content);
+      }
+    }),
+    recall: defineCommand({
+      meta: { name: "recall", description: "Search mesh memory by keyword or phrase" },
+      args: {
+        query: { type: "positional", description: "Search query", required: true },
+        mesh: { type: "string", description: "Mesh slug (auto-selected if only one joined)" },
+        json: { type: "boolean", description: "Output as JSON", default: false }
+      },
+      async run({ args }) {
+        await runRecall(args, args.query);
+      }
+    }),
+    remind: defineCommand({
+      meta: { name: "remind", description: "Schedule a reminder or delayed message via the broker" },
+      args: {
+        message: { type: "positional", description: "Message text, or: list | cancel <id>", required: false },
+        extra: { type: "positional", description: "Additional positional args", required: false },
+        in: { type: "string", description: 'Deliver after duration: "2h", "30m", "90s"' },
+        at: { type: "string", description: 'Deliver at time: "15:00" or ISO timestamp' },
+        to: { type: "string", description: "Recipient (default: self). Name, @group, pubkey, or *" },
+        mesh: { type: "string", description: "Mesh slug (auto-selected if only one joined)" },
+        json: { type: "boolean", description: "Output as JSON", default: false }
+      },
+      async run({ args, rawArgs }) {
+        const positionals = rawArgs.filter((a) => !a.startsWith("-"));
+        await runRemind(args, positionals);
+      }
+    }),
     status: defineCommand({
       meta: { name: "status", description: "Check broker reachability for each joined mesh" },
       async run() {