claudemesh-cli 0.6.6 → 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.",
@@ -47740,6 +47783,42 @@ class BrokerClient {
       return;
     this.ws.send(JSON.stringify({ type: "forget", memoryId }));
   }
+  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;
@@ -47757,6 +47836,9 @@ class BrokerClient {
   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;
@@ -48319,6 +48401,22 @@ class BrokerClient {
       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") {
       this.debug(`broker error: ${msg.code} ${msg.message}`);
       const id = msg.id ? String(msg.id) : null;
@@ -48351,6 +48449,9 @@ class BrokerClient {
           [this.contextResultsResolvers, []],
           [this.contextListResolvers, []],
           [this.streamListResolvers, []],
+          [this.scheduledAckResolvers, null],
+          [this.scheduledListResolvers, []],
+          [this.cancelScheduledResolvers, false],
           [this.messageStatusResolvers, null],
           [this.grantFileAccessResolvers, false],
           [this.collectionListResolvers, []],
@@ -48418,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;
@@ -48511,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 {}
@@ -48666,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 {
@@ -48795,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})`);
@@ -48818,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})`);
@@ -48843,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)
@@ -48856,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);
@@ -48872,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 },
@@ -48889,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,
@@ -48910,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
@@ -48924,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) {
@@ -48935,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);
           }
@@ -48971,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(", ")}]` : ""}`);
@@ -48985,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}`);
@@ -49000,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 ? "…" : ""}`);
@@ -49035,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:
@@ -49056,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));
@@ -49068,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) => {
@@ -49106,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(", ")}]` : ""}`);
@@ -49121,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})`);
@@ -49164,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)
@@ -49185,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(", ")}`);
@@ -49206,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)`);
@@ -49244,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 = [
@@ -49269,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}`);
@@ -49306,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)
@@ -49321,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}`);
@@ -49341,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({
@@ -49368,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,
@@ -49384,7 +49536,7 @@ ${rows.join(`
 `);
       }
     });
-    client.onStreamData(async (evt) => {
+    client2.onStreamData(async (evt) => {
       try {
         await server.notification({
           method: "notifications/claude/channel",
@@ -49399,7 +49551,7 @@ ${rows.join(`
         });
       } catch {}
     });
-    client.onStateChange(async (change) => {
+    client2.onStateChange(async (change) => {
       try {
         await server.notification({
           method: "notifications/claude/channel",
@@ -49416,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 {}
@@ -50401,7 +50553,7 @@ init_config();
 // package.json
 var package_default = {
   name: "claudemesh-cli",
-  version: "0.6.6",
+  version: "0.6.7",
   description: "Claude Code MCP client for claudemesh — peer mesh messaging between Claude sessions.",
   keywords: [
     "claude-code",
@@ -50834,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();
   }
 }
 
@@ -50851,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;
@@ -50877,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(", ");
@@ -50889,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 {
@@ -50915,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;
@@ -50939,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;
@@ -50961,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)}`);
   });
 }
@@ -50970,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;
@@ -50988,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: {
@@ -51173,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() {

package/package.json

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