@shodh/memory-mcp 0.1.80 → 0.1.90

package/README.md

@@ -5,7 +5,7 @@
 <h1 align="center">Shodh-Memory MCP Server</h1>
 
 <p align="center">
-  <strong>v0.1.70</strong> | Persistent cognitive memory for AI agents
+  <strong>v0.1.90</strong> | Persistent cognitive memory for AI agents
 </p>
 
 <p align="center">
@@ -29,9 +29,11 @@
 - **Semantic Search**: Find memories by meaning using MiniLM-L6 embeddings
 - **Knowledge Graph**: Entity extraction and relationship tracking
 - **Memory Consolidation**: Automatic decay, replay, and strengthening
+- **Idempotent**: Content-hash dedup — identical memories are never stored twice
 - **1-Click Install**: Auto-downloads native server binary for your platform
 - **Offline-First**: All models auto-downloaded on first run (~38MB total), no internet required after
-- **Fast**: Sub-millisecond graph lookup, 30-50ms semantic search
+- **Fast**: <200ms API response, sub-millisecond graph lookup, 30-50ms semantic search
+- **GTD Task Management**: Full todo system with projects, subtasks, comments, and reminders
 
 ## Installation
 
@@ -81,25 +83,80 @@ env = { SHODH_API_KEY = "your-api-key-here" }
 | `SHODH_STREAM` | Enable/disable streaming ingestion | `true` |
 | `SHODH_PROACTIVE` | Enable/disable proactive memory surfacing | `true` |
 
-## MCP Tools (15 total)
+## MCP Tools (47 total)
+
+<details>
+<summary><b>Memory</b> — Store, search, and manage memories</summary>
 
 | Tool | Description |
 |------|-------------|
-| `remember` | Store a memory with optional type and tags |
+| `remember` | Store a memory with optional type, tags, and metadata |
 | `recall` | Semantic search to find relevant memories |
 | `proactive_context` | Auto-surface relevant memories for current context |
 | `context_summary` | Get categorized context for session bootstrap |
 | `list_memories` | List all stored memories |
+| `read_memory` | Read full content of a specific memory by ID |
 | `forget` | Delete a specific memory by ID |
-| `forget_by_tags` | Delete memories matching any of the specified tags |
-| `forget_by_date` | Delete memories within a date range |
+| `reinforce` | Reinforce a memory (boost importance) |
+</details>
+
+<details>
+<summary><b>Todos (GTD)</b> — Task management with projects and subtasks</summary>
+
+| Tool | Description |
+|------|-------------|
+| `add_todo` | Create a task with priority, due date, project, contexts |
+| `list_todos` | List/search todos with semantic or GTD-style filtering |
+| `update_todo` | Update task properties (status, priority, notes) |
+| `complete_todo` | Mark a task as done (auto-creates next for recurring) |
+| `delete_todo` | Permanently delete a task |
+| `reorder_todo` | Move a task up or down within its status group |
+| `list_subtasks` | List subtasks of a parent todo |
+| `add_todo_comment` | Add a comment to a task (progress, resolution) |
+| `list_todo_comments` | List all comments on a task |
+| `update_todo_comment` | Edit an existing comment |
+| `delete_todo_comment` | Delete a comment |
+| `todo_stats` | Get todo statistics by status, overdue items |
+</details>
+
+<details>
+<summary><b>Projects</b> — Organize todos into groups</summary>
+
+| Tool | Description |
+|------|-------------|
+| `add_project` | Create a project with optional parent (sub-projects) |
+| `list_projects` | List all projects with todo counts |
+| `archive_project` | Archive a project (hidden but restorable) |
+| `delete_project` | Permanently delete a project |
+</details>
+
+<details>
+<summary><b>Reminders</b> — Time, duration, and context-triggered reminders</summary>
+
+| Tool | Description |
+|------|-------------|
+| `set_reminder` | Set a reminder (time, duration, or keyword trigger) |
+| `list_reminders` | List pending/triggered/dismissed reminders |
+| `dismiss_reminder` | Acknowledge a triggered reminder |
+</details>
+
+<details>
+<summary><b>System</b> — Health, backups, and diagnostics</summary>
+
+| Tool | Description |
+|------|-------------|
 | `memory_stats` | Get statistics about stored memories |
-| `recall_by_tags` | Find memories by tag |
-| `recall_by_date` | Find memories within a date range |
-| `verify_index` | Check vector index health |
-| `repair_index` | Repair orphaned memories |
+| `verify_index` | Check vector index integrity |
+| `repair_index` | Re-index orphaned memories |
+| `token_status` | Get current session token usage |
+| `reset_token_session` | Reset token counter for new session |
 | `consolidation_report` | View memory consolidation activity |
-| `streaming_status` | Check WebSocket streaming connection status |
+| `backup_create` | Create a backup of all memories |
+| `backup_list` | List available backups |
+| `backup_verify` | Verify backup integrity (SHA-256) |
+| `backup_restore` | Restore from a backup |
+| `backup_purge` | Purge old backups, keep most recent N |
+</details>
 
 ## REST API (for Developers)
 

package/dist/index.js

@@ -4881,28 +4881,74 @@ class StdioServerTransport {
 import { spawn } from "child_process";
 import * as path from "path";
 import * as fs from "fs";
+import * as crypto from "crypto";
 import { fileURLToPath } from "url";
-var __filename2 = fileURLToPath(import.meta.url);
-var __dirname2 = path.dirname(__filename2);
+
+// security-utils.ts
+function isLocalHostFromUrl(apiUrl) {
+  try {
+    const url = new URL(apiUrl);
+    const host = url.hostname;
+    return host === "127.0.0.1" || host === "localhost" || host === "::1" || host === "0.0.0.0";
+  } catch {
+    return false;
+  }
+}
+function shouldWarnInsecureApiUrl(apiUrl, allowHttpEnv) {
+  return !isLocalHostFromUrl(apiUrl) && apiUrl.startsWith("http://") && allowHttpEnv !== "true";
+}
+function serializeAndValidateBody(body, maxLength) {
+  const serialized = JSON.stringify(body);
+  if (serialized.length > maxLength) {
+    return { ok: false, error: `Request body exceeds maximum length of ${maxLength} characters` };
+  }
+  return { ok: true, serialized };
+}
+function nextReconnectDelay(currentDelayMs, maxDelayMs) {
+  const safeCurrent = Math.max(currentDelayMs, 1000);
+  return Math.min(safeCurrent * 2, maxDelayMs);
+}
+
+// index.ts
+var __filename2 = typeof import.meta !== "undefined" && import.meta.url ? fileURLToPath(import.meta.url) : "";
+var __dirname2 = __filename2 ? path.dirname(__filename2) : process.cwd();
 var API_URL = process.env.SHODH_API_URL || "http://127.0.0.1:3030";
 var WS_URL = API_URL.replace(/^http/, "ws") + "/api/stream";
 var USER_ID = process.env.SHODH_USER_ID || "claude-code";
-var API_KEY = process.env.SHODH_API_KEY;
+function isLocalServer() {
+  try {
+    const url = new URL(API_URL);
+    const host = url.hostname;
+    return host === "127.0.0.1" || host === "localhost" || host === "::1" || host === "0.0.0.0";
+  } catch {
+    return false;
+  }
+}
+var SANDBOX_MODE = process.env.SMITHERY_SANDBOX === "true";
+var API_KEY = process.env.SHODH_API_KEY || (SANDBOX_MODE ? "sandbox" : "");
 if (!API_KEY) {
-  console.error("ERROR: SHODH_API_KEY environment variable not set.");
-  console.error("");
-  console.error("To fix, add to your MCP config (claude_desktop_config.json or mcp.json):");
-  console.error(`  "env": { "SHODH_API_KEY": "your-api-key" }`);
-  console.error("");
-  console.error("Or set in your shell:");
-  console.error("  export SHODH_API_KEY=your-api-key");
-  console.error("");
-  console.error("For local development, use the same key set in SHODH_DEV_API_KEY on the server.");
-  process.exit(1);
+  if (isLocalServer()) {
+    API_KEY = crypto.randomBytes(32).toString("hex");
+    console.error("[shodh-memory] No API key set — auto-generated for local server.");
+  } else {
+    console.error("ERROR: SHODH_API_KEY is required for remote servers.");
+    console.error("");
+    console.error("To fix, add to your MCP config (claude_desktop_config.json or mcp.json):");
+    console.error(`  "env": { "SHODH_API_KEY": "your-api-key" }`);
+    console.error("");
+    console.error("Or set in your shell:");
+    console.error("  export SHODH_API_KEY=your-api-key");
+    process.exit(1);
+  }
 }
 var RETRY_ATTEMPTS = 3;
 var RETRY_DELAY_MS = 1000;
 var REQUEST_TIMEOUT_MS = 1e4;
+var WRITE_TIMEOUT_MS = 30000;
+if (shouldWarnInsecureApiUrl(API_URL, process.env.SHODH_ALLOW_HTTP)) {
+  console.error("[shodh-memory] WARNING: Using HTTP for a non-localhost server is insecure.");
+  console.error("[shodh-memory] Set SHODH_API_URL to an https:// URL, or set SHODH_ALLOW_HTTP=true to suppress this warning.");
+}
 var MAX_CONTENT_LENGTH = 1e5;
 var MAX_QUERY_LENGTH = 1e4;
 var MAX_LIMIT = 250;
@@ -4930,10 +4976,28 @@ var STREAM_ENABLED = process.env.SHODH_STREAM !== "false";
 var STREAM_MIN_CONTENT_LENGTH = 50;
 var PROACTIVE_SURFACING = process.env.SHODH_PROACTIVE !== "false";
 var PROACTIVE_MIN_CONTEXT_LENGTH = 30;
+var MAX_CONTEXT_LENGTH = 4000;
+function stripSystemNoise(text) {
+  let result = text;
+  const tagPatterns = [
+    /<task-notification>[\s\S]*?<\/task-notification>/g,
+    /<system-reminder>[\s\S]*?<\/system-reminder>/g,
+    /<shodh-context[\s\S]*?<\/shodh-context>/g,
+    /<shodh-memory[\s\S]*?<\/shodh-memory>/g,
+    /<command-name>[\s\S]*?<\/command-name>/g
+  ];
+  for (const pattern of tagPatterns) {
+    result = result.replace(pattern, "");
+  }
+  result = result.replace(/\s{3,}/g, " ").trim();
+  return result;
+}
 var lastProactiveResponse = "";
 var streamSocket = null;
 var streamConnecting = false;
 var streamReconnectTimer = null;
+var streamReconnectDelay = 1000;
+var STREAM_RECONNECT_MAX_DELAY = 60000;
 var streamBuffer = [];
 var MAX_BUFFER_SIZE = 100;
 var streamHandshakeComplete = false;
@@ -4944,9 +5008,15 @@ async function connectStream() {
   streamConnecting = true;
   streamHandshakeComplete = false;
   try {
-    streamSocket = new WebSocket(WS_URL);
+    const wsUrlWithAuth = WS_URL + (WS_URL.includes("?") ? "&" : "?") + "api_key=" + encodeURIComponent(API_KEY);
+    streamSocket = new WebSocket(wsUrlWithAuth, {
+      headers: {
+        "X-API-Key": API_KEY
+      }
+    });
     streamSocket.onopen = () => {
       streamConnecting = false;
+      streamReconnectDelay = 1000;
       console.error("[Stream] WebSocket connected to", WS_URL);
       const handshake = JSON.stringify({
         user_id: USER_ID,
@@ -4988,11 +5058,13 @@ async function connectStream() {
       streamConnecting = false;
       streamHandshakeComplete = false;
       if (STREAM_ENABLED && !streamReconnectTimer) {
+        const delay = streamReconnectDelay;
+        streamReconnectDelay = nextReconnectDelay(streamReconnectDelay, STREAM_RECONNECT_MAX_DELAY);
         streamReconnectTimer = setTimeout(() => {
           streamReconnectTimer = null;
-          console.error("[Stream] Attempting reconnect...");
+          console.error(`[Stream] Attempting reconnect (next delay: ${streamReconnectDelay}ms)...`);
           connectStream().catch((e) => console.error("[Stream] Reconnect failed:", e));
-        }, 5000);
+        }, delay);
       }
     };
     streamSocket.onerror = (error) => {
@@ -5076,7 +5148,7 @@ async function surfaceRelevant(context, maxResults = 3) {
 function formatSurfacedMemories(memories) {
   if (!memories || memories.length === 0)
     return "";
-  const formatted = memories.map((m, i) => `  ${i + 1}. [${(m.relevance_score * 100).toFixed(0)}%] ${m.content.slice(0, 80)}...`).join(`
+  const formatted = memories.map((m, i) => `  ${i + 1}. [${((m.relevance_score ?? 0) * 100).toFixed(0)}%] ${m.content.slice(0, 80)}...`).join(`
 `);
   return `
 
@@ -5097,7 +5169,8 @@ async function apiCall(endpoint, method = "GET", body) {
   for (let attempt = 1;attempt <= RETRY_ATTEMPTS; attempt++) {
     try {
       const controller = new AbortController;
-      const timeoutId = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS);
+      const timeout = method === "GET" ? REQUEST_TIMEOUT_MS : WRITE_TIMEOUT_MS;
+      const timeoutId = setTimeout(() => controller.abort(), timeout);
       const options = {
         method,
         headers: {
@@ -5107,7 +5180,11 @@ async function apiCall(endpoint, method = "GET", body) {
         signal: controller.signal
       };
       if (body) {
-        options.body = JSON.stringify(body);
+        const bodyValidation = serializeAndValidateBody(body, MAX_CONTENT_LENGTH);
+        if (!bodyValidation.ok) {
+          throw new Error(bodyValidation.error);
+        }
+        options.body = bodyValidation.serialized;
       }
       const response = await fetch(`${API_URL}${endpoint}`, options);
       clearTimeout(timeoutId);
@@ -5148,7 +5225,7 @@ async function isServerAvailable() {
 }
 var server = new Server({
   name: "shodh-memory",
-  version: "0.1.61"
+  version: "0.1.90"
 }, {
   capabilities: {
     tools: {},
@@ -5375,6 +5452,20 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
           }
         }
       },
+      {
+        name: "backup_restore",
+        description: "Restore a previously created backup by ID. This replaces all current data for the user with the backup contents. Server restart is recommended after restore.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            backup_id: {
+              type: "number",
+              description: "The backup ID to restore (from backup_list)"
+            }
+          },
+          required: ["backup_id"]
+        }
+      },
       {
         name: "consolidation_report",
         description: "Get a report of what the memory system has been learning. Shows memory strengthening/decay events, edge formation, fact extraction, and maintenance cycles. Use this to understand how your memories are evolving.",
@@ -5489,6 +5580,10 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
               type: "array",
               items: { type: "string" },
               description: "Optional tags for categorization"
+            },
+            threshold: {
+              type: "number",
+              description: "Semantic similarity threshold for 'context' trigger (0.0-1.0, default: 0.7). Lower values match more broadly, higher values require closer semantic match."
             }
           },
           required: ["content", "trigger_type"]
@@ -6001,7 +6096,7 @@ To start: cd shodh-memory && cargo run`
           response += ` │ Tags: ${tags.join(", ")}`;
         }
         response += `
-ID: ${result.id.slice(0, 8)}...`;
+ID: ${result.id}`;
         return {
           content: [{ type: "text", text: response }]
         };
@@ -6028,6 +6123,7 @@ ID: ${result.id.slice(0, 8)}...`;
         const memories = result.memories || [];
         const todos = result.todos || [];
         const stats = result.retrieval_stats;
+        const lineage = result.lineage || [];
         if (memories.length === 0 && todos.length === 0) {
           return {
             content: [
@@ -6084,7 +6180,7 @@ ID: ${result.id.slice(0, 8)}...`;
 `;
             response += `  ${content.slice(0, 200)}${content.length > 200 ? "..." : ""}
 `;
-            response += `  ┗━ ${getType(m)}${m.tier ? ` │ ${m.tier}` : ""} │ ${m.id.slice(0, 8)}...
+            response += `  ┗━ ${getType(m)}${m.tier ? ` │ ${m.tier}` : ""} │ ${m.id}
 `;
             if (i < memories.length - 1)
               response += `
@@ -6126,12 +6222,34 @@ ID: ${result.id.slice(0, 8)}...`;
 `;
           const graphPct = (stats.graph_weight * 100).toFixed(0);
           const semPct = (stats.semantic_weight * 100).toFixed(0);
-          response += `   Graph: ${graphPct}% │ Semantic: ${semPct}% │ Density: ${stats.graph_density.toFixed(2)}
+          response += `   Graph: ${graphPct}% │ Semantic: ${semPct}% │ Density: ${(stats.graph_density ?? 0).toFixed(2)}
 `;
           response += `   Candidates: ${stats.graph_candidates} graph + ${stats.semantic_candidates} semantic
 `;
           response += `   Entities: ${stats.entities_activated} │ Time: ${(stats.retrieval_time_us / 1000).toFixed(1)}ms`;
         }
+        if (lineage.length > 0) {
+          const idShort = (id) => id;
+          const idToContent = new Map;
+          for (const m of memories) {
+            idToContent.set(m.id, getContent(m).slice(0, 40));
+          }
+          response += `
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+`;
+          response += `\uD83D\uDD17 LINEAGE (${lineage.length} causal edge${lineage.length > 1 ? "s" : ""})
+`;
+          for (const edge of lineage) {
+            const fromLabel = idToContent.get(edge.from) || idShort(edge.from);
+            const toLabel = idToContent.get(edge.to) || idShort(edge.to);
+            const conf = (edge.confidence * 100).toFixed(0);
+            response += `  ${idShort(edge.from)} ──${edge.relation}──▶ ${idShort(edge.to)}  (${conf}%)
+`;
+            response += `    "${fromLabel}..." → "${toLabel}..."
+`;
+          }
+        }
         return {
           content: [{ type: "text", text: response }]
         };
@@ -6303,7 +6421,7 @@ ID: ${result.id.slice(0, 8)}...`;
           }[getType(m)] || "\uD83D\uDCE6";
           response += `${String(i + 1).padStart(2)}. ${typeIcon} ${content.slice(0, 150)}${content.length > 150 ? "..." : ""}
 `;
-          response += `    ┗━ ${getType(m)}${m.tier ? ` │ ${m.tier}` : ""} │ ${m.id.slice(0, 8)}...
+          response += `    ┗━ ${getType(m)}${m.tier ? ` │ ${m.tier}` : ""} │ ${m.id}
 `;
         }
         return {
@@ -6317,7 +6435,7 @@ ID: ${result.id.slice(0, 8)}...`;
 `;
         response += `━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 `;
-        response += `✓ Removed: ${id.slice(0, 8)}...`;
+        response += `✓ Removed: ${id}`;
         return {
           content: [{ type: "text", text: response }]
         };
@@ -6463,7 +6581,7 @@ By Type:
           response += `Created: ${new Date(b.created_at).toLocaleString()}
 `;
         } else {
-          response += `✗ Failed: ${result.message}
+          response += `✗ Failed: ${result.message || "Unknown backup creation error"}
 `;
         }
         return {
@@ -6520,7 +6638,7 @@ By Type:
 `;
         response += `━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 `;
-        response += result.message;
+        response += result.message || "No verification details provided";
         return {
           content: [{ type: "text", text: response }]
         };
@@ -6546,6 +6664,32 @@ By Type:
           content: [{ type: "text", text: response }]
         };
       }
+      case "backup_restore": {
+        const { backup_id } = args;
+        const result = await apiCall("/api/backup/restore", "POST", {
+          user_id: USER_ID,
+          backup_id
+        });
+        let response = `\uD83D\uDD04 Backup Restore
+`;
+        response += `━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+`;
+        if (result.success) {
+          response += `✓ Backup #${backup_id} restored successfully
+`;
+          if (result.restored_stores.length > 0) {
+            response += `Restored stores: ${result.restored_stores.join(", ")}
+`;
+          }
+          response += `
+⚠️ ${result.message || "Restore completed with no additional details"}`;
+        } else {
+          response += `✗ Restore failed: ${result.message || "Unknown restore error"}`;
+        }
+        return {
+          content: [{ type: "text", text: response }]
+        };
+      }
       case "proactive_context": {
         const {
           context,
@@ -6556,9 +6700,17 @@ By Type:
           memory_types = [],
           auto_ingest = true
         } = args;
+        const cleanedContext = stripSystemNoise(context).slice(0, MAX_CONTEXT_LENGTH);
+        if (cleanedContext.length < PROACTIVE_MIN_CONTEXT_LENGTH) {
+          return {
+            content: [{ type: "text", text: `No relevant memories surfaced (context too short after cleaning).
+
+[Latency: 0.0ms]` }]
+          };
+        }
         const result = await apiCall("/api/proactive_context", "POST", {
           user_id: USER_ID,
-          context,
+          context: cleanedContext,
           max_results,
           semantic_threshold,
           entity_match_weight,
@@ -6566,7 +6718,7 @@ By Type:
           memory_types,
           auto_ingest,
           previous_response: lastProactiveResponse || undefined,
-          user_followup: lastProactiveResponse ? context : undefined
+          user_followup: lastProactiveResponse ? cleanedContext : undefined
         });
         const memories = result.memories || [];
         const entities = result.detected_entities || [];
@@ -6579,7 +6731,7 @@ Detected entities: ${entities.map((e) => `"${e.name}" (${e.entity_type})`).join(
 [Feedback: ${result.feedback_processed.memories_evaluated} evaluated, ${result.feedback_processed.reinforced.length} reinforced, ${result.feedback_processed.weakened.length} weakened]` : "";
           const emptyText = `No relevant memories surfaced for this context.${entityList}${feedbackNote2}
 
-[Latency: ${result.latency_ms.toFixed(1)}ms]`;
+[Latency: ${(result.latency_ms ?? 0).toFixed(1)}ms]`;
           lastProactiveResponse = emptyText;
           return {
             content: [{ type: "text", text: emptyText }]
@@ -6605,7 +6757,7 @@ Detected entities: ${entities.map((e) => `"${e.name}" (${e.entity_type})`).join(
             for (const r of uniqueReminders) {
               const icon = r.overdue_seconds && r.overdue_seconds > 0 ? "⏰" : "\uD83D\uDCCC";
               const contentText = r.content.slice(0, 38);
-              reminderBlock += `┃  ${icon} ${contentText.padEnd(44)} [${r.id.slice(0, 8)}] ┃
+              reminderBlock += `┃  ${icon} ${contentText.padEnd(44)} [${r.id}] ┃
 `;
               if (r.overdue_seconds && r.overdue_seconds > 0) {
                 const mins = Math.round(r.overdue_seconds / 60);
@@ -6701,7 +6853,7 @@ Detected entities: ${entities.map((e) => `"${e.name}" (${e.entity_type})`).join(
         const feedbackNote = result.feedback_processed ? `
 [Feedback loop: ${result.feedback_processed.memories_evaluated} evaluated, ${result.feedback_processed.reinforced.length} reinforced, ${result.feedback_processed.weakened.length} weakened]` : "";
         const ingestNote = result.ingested_memory_id ? `
-[Context ingested: ${result.ingested_memory_id.slice(0, 8)}]` : "";
+[Context ingested: ${result.ingested_memory_id}]` : "";
         const summaryParts = [];
         if (memories.length > 0)
           summaryParts.push(`${memories.length} memories`);
@@ -6716,7 +6868,7 @@ Detected entities: ${entities.map((e) => `"${e.name}" (${e.entity_type})`).join(
 
 ${formattedWithTime}${entitySummary}${factsBlock}${reminderBlock}${todoBlock}${feedbackNote}${ingestNote}
 
-[Latency: ${result.latency_ms.toFixed(1)}ms | Threshold: ${(semantic_threshold * 100).toFixed(0)}%]`;
+[Latency: ${(result.latency_ms ?? 0).toFixed(1)}ms | Threshold: ${(semantic_threshold * 100).toFixed(0)}%]`;
         lastProactiveResponse = responseText;
         return {
           content: [{ type: "text", text: responseText }]
@@ -6855,7 +7007,7 @@ ${formattedWithTime}${entitySummary}${factsBlock}${reminderBlock}${todoBlock}${f
         };
       }
       case "set_reminder": {
-        const { content, trigger_type, trigger_at, after_seconds, keywords, priority = 3, tags = [] } = args;
+        const { content, trigger_type, trigger_at, after_seconds, keywords, priority = 3, tags = [], threshold } = args;
         if (!content || content.length === 0) {
           return { content: [{ type: "text", text: "Error: 'content' is required and cannot be empty" }], isError: true };
         }
@@ -6892,7 +7044,8 @@ ${formattedWithTime}${entitySummary}${factsBlock}${reminderBlock}${todoBlock}${f
                 isError: true
               };
             }
-            trigger = { type: "context", keywords, threshold: 0.7 };
+            const ctxThreshold = threshold !== undefined && threshold >= 0 && threshold <= 1 ? threshold : 0.7;
+            trigger = { type: "context", keywords, threshold: ctxThreshold };
             break;
           default:
             return {
@@ -6911,7 +7064,7 @@ ${formattedWithTime}${entitySummary}${factsBlock}${reminderBlock}${todoBlock}${f
 `;
         response += `━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 `;
-        response += `ID: ${result.id.slice(0, 8)}...
+        response += `ID: ${result.id}
 `;
         response += `Content: ${content}
 `;
@@ -6954,7 +7107,7 @@ ${formattedWithTime}${entitySummary}${factsBlock}${reminderBlock}${todoBlock}${f
           const statusBadge = r.status === "triggered" ? " [TRIGGERED]" : "";
           response += `${icon} ${r.content.slice(0, 50)}${r.content.length > 50 ? "..." : ""}${statusBadge}
 `;
-          response += `   Type: ${r.trigger_type} | Priority: ${"★".repeat(r.priority)} | ID: ${r.id.slice(0, 8)}...
+          response += `   Type: ${r.trigger_type} | Priority: ${"★".repeat(r.priority)} | ID: ${r.id}
 `;
           if (r.due_at) {
             response += `   Due: ${new Date(r.due_at).toLocaleString()}
@@ -6981,7 +7134,7 @@ ${formattedWithTime}${entitySummary}${factsBlock}${reminderBlock}${todoBlock}${f
           content: [
             {
               type: "text",
-              text: result.success ? `✓ Reminder dismissed: ${reminder_id.slice(0, 8)}...` : `⚠️ ${result.message}`
+              text: result.success ? `✓ Reminder dismissed: ${reminder_id}` : `⚠️ ${result.message || "No message returned"}`
             }
           ]
         };
@@ -7199,7 +7352,13 @@ ${formattedWithTime}${entitySummary}${factsBlock}${reminderBlock}${todoBlock}${f
         };
       }
       case "read_memory": {
-        const { memory_id } = args;
+        const memory_id = args.memory_id || args.id;
+        if (!memory_id || typeof memory_id !== "string" || memory_id.trim().length === 0) {
+          return {
+            content: [{ type: "text", text: "Error: 'memory_id' is required. Pass the full UUID or 8+ character prefix from recall results." }],
+            isError: true
+          };
+        }
         let memory = null;
         try {
           memory = await apiCall(`/api/memory/${memory_id}?user_id=${encodeURIComponent(USER_ID)}`, "GET");
@@ -7222,11 +7381,11 @@ ${formattedWithTime}${entitySummary}${factsBlock}${reminderBlock}${todoBlock}${f
         response += `Tier: ${memory.tier || "Unknown"} | Created: ${created} | Importance: ${(memory.importance * 100).toFixed(0)}%
 `;
         if (memory.parent_id) {
-          response += `Parent: ${memory.parent_id.slice(0, 8)}...
+          response += `Parent: ${memory.parent_id}
 `;
         }
         if (memory.children_count > 0) {
-          response += `Children: ${memory.children_count} (${memory.children_ids.map((id) => id.slice(0, 8)).join(", ")})
+          response += `Children: ${memory.children_count} (${memory.children_ids.join(", ")})
 `;
         }
         response += `━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
@@ -7878,14 +8037,14 @@ function getBinaryPath() {
     wrapperName = "shodh-memory";
     fallbackName = "shodh-memory-server";
   }
-  const wrapperPath = path.join(binDir, wrapperName);
-  if (fs.existsSync(wrapperPath)) {
-    return wrapperPath;
-  }
   const binaryPath = path.join(binDir, fallbackName);
   if (fs.existsSync(binaryPath)) {
     return binaryPath;
   }
+  const wrapperPath = path.join(binDir, wrapperName);
+  if (fs.existsSync(wrapperPath)) {
+    return wrapperPath;
+  }
   return null;
 }
 async function isServerRunning() {
@@ -7910,9 +8069,32 @@ async function waitForServer(maxAttempts = 30) {
   }
   return false;
 }
+async function validateApiKey() {
+  try {
+    const controller = new AbortController;
+    const timeout = setTimeout(() => controller.abort(), 3000);
+    const response = await fetch(`${API_URL}/api/health`, {
+      headers: { "X-API-Key": API_KEY },
+      signal: controller.signal
+    });
+    clearTimeout(timeout);
+    return response.ok;
+  } catch {
+    return false;
+  }
+}
 async function ensureServerRunning() {
   if (await isServerRunning()) {
     console.error("[shodh-memory] Backend server already running at", API_URL);
+    if (!process.env.SHODH_API_KEY && isLocalServer()) {
+      const keyWorks = await validateApiKey();
+      if (!keyWorks) {
+        console.error("[shodh-memory] WARNING: Auto-generated key rejected by running server.");
+        console.error("[shodh-memory] The server was started with a different API key.");
+        console.error("[shodh-memory] Set SHODH_API_KEY to match the server's key, or restart");
+        console.error("[shodh-memory] the server without SHODH_DEV_API_KEY to use auto-generated keys.");
+      }
+    }
     return;
   }
   if (!AUTO_SPAWN_ENABLED) {
@@ -7930,6 +8112,13 @@ async function ensureServerRunning() {
     console.error("[shodh-memory] Or download from: https://github.com/varun29ankuS/shodh-memory/releases");
     return;
   }
+  const expectedBinDir = fs.realpathSync(path.join(__dirname2, "..", "bin"));
+  const resolvedBinary = fs.realpathSync(binaryPath);
+  if (!resolvedBinary.startsWith(expectedBinDir + path.sep) && resolvedBinary !== expectedBinDir) {
+    console.error(`[shodh-memory] WARNING: Binary path resolves outside expected directory: ${resolvedBinary}`);
+    console.error(`[shodh-memory] Expected: ${expectedBinDir}`);
+    return;
+  }
   console.error("[shodh-memory] Starting backend server...");
   const serverEnv = {};
   const SERVER_ENV_ALLOWLIST = new Set([
@@ -7966,10 +8155,12 @@ async function ensureServerRunning() {
     }
   }
   serverEnv["SHODH_DEV_API_KEY"] = API_KEY;
+  const isBat = binaryPath.endsWith(".bat");
   serverProcess = spawn(binaryPath, [], {
     detached: true,
     stdio: "ignore",
-    env: serverEnv
+    env: serverEnv,
+    ...isBat && { shell: true }
   });
   serverProcess.unref();
   console.error("[shodh-memory] Waiting for server to start...");
@@ -8005,14 +8196,23 @@ process.on("SIGTERM", () => {
   cleanupServer();
   process.exit(0);
 });
+function createSandboxServer() {
+  process.env.SMITHERY_SANDBOX = "true";
+  return server;
+}
 async function main() {
+  if (SANDBOX_MODE)
+    return;
   await ensureServerRunning();
   const transport = new StdioServerTransport;
   await server.connect(transport);
-  console.error("Shodh-Memory MCP server v0.1.80 running");
+  console.error("Shodh-Memory MCP server v0.1.90 running");
   console.error(`Connecting to: ${API_URL}`);
   console.error(`User ID: ${USER_ID}`);
   console.error(`Streaming: ${STREAM_ENABLED ? "enabled" : "disabled"}`);
   console.error(`Proactive surfacing: ${PROACTIVE_SURFACING ? "enabled" : "disabled (SHODH_PROACTIVE=false)"}`);
 }
 main().catch(console.error);
+export {
+  createSandboxServer
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shodh/memory-mcp",
-  "version": "0.1.80",
+  "version": "0.1.90",
   "mcpName": "io.github.varun29ankuS/shodh-memory",
   "description": "MCP server for persistent AI memory - store and recall context across sessions",
   "type": "module",
@@ -11,6 +11,9 @@
   "scripts": {
     "start": "bun run index.ts",
     "build": "bun build index.ts --outdir dist --target node",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage",
     "postinstall": "node scripts/postinstall.cjs",
     "prepublishOnly": "npm run build"
   },
@@ -22,6 +25,10 @@
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.24.0"
   },
+  "devDependencies": {
+    "@vitest/coverage-v8": "^2.1.9",
+    "vitest": "^2.1.8"
+  },
   "keywords": [
     "mcp",
     "model-context-protocol",

package/scripts/postinstall.cjs

@@ -11,7 +11,7 @@ const path = require('path');
 const https = require('https');
 const { execSync } = require('child_process');
 
-const VERSION = '0.1.74';
+const VERSION = require('../package.json').version;
 const REPO = 'varun29ankuS/shodh-memory';
 const BIN_DIR = path.join(__dirname, '..', 'bin');