@shodh/memory-mcp 0.1.90 → 0.2.0

package/dist/index.js

@@ -4909,10 +4909,41 @@ function nextReconnectDelay(currentDelayMs, maxDelayMs) {
   return Math.min(safeCurrent * 2, maxDelayMs);
 }
 
+// string-utils.ts
+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;
+}
+
 // 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";
+function resolveApiUrl() {
+  if (process.env.SHODH_API_URL)
+    return process.env.SHODH_API_URL;
+  const host = process.env.SHODH_HOST;
+  const port = process.env.SHODH_PORT;
+  if (host) {
+    const scheme = port === "443" ? "https" : "http";
+    const portSuffix = port && port !== "443" && port !== "80" ? `:${port}` : "";
+    return `${scheme}://${host}${portSuffix}`;
+  }
+  if (port)
+    return `http://127.0.0.1:${port}`;
+  return "http://127.0.0.1:3030";
+}
+var API_URL = resolveApiUrl();
 var WS_URL = API_URL.replace(/^http/, "ws") + "/api/stream";
 var USER_ID = process.env.SHODH_USER_ID || "claude-code";
 function isLocalServer() {
@@ -4925,10 +4956,25 @@ function isLocalServer() {
   }
 }
 var SANDBOX_MODE = process.env.SMITHERY_SANDBOX === "true";
-var API_KEY = process.env.SHODH_API_KEY || (SANDBOX_MODE ? "sandbox" : "");
+var API_KEY = "";
+var apiKeySource = "";
+if (process.env.SHODH_API_KEY) {
+  API_KEY = process.env.SHODH_API_KEY;
+  apiKeySource = "SHODH_API_KEY";
+} else if (process.env.SHODH_DEV_API_KEY) {
+  API_KEY = process.env.SHODH_DEV_API_KEY;
+  apiKeySource = "SHODH_DEV_API_KEY";
+} else if (process.env.SHODH_API_KEYS?.split(",")[0]?.trim()) {
+  API_KEY = process.env.SHODH_API_KEYS.split(",")[0].trim();
+  apiKeySource = "SHODH_API_KEYS";
+} else if (SANDBOX_MODE) {
+  API_KEY = "sandbox";
+  apiKeySource = "sandbox";
+}
 if (!API_KEY) {
   if (isLocalServer()) {
     API_KEY = crypto.randomBytes(32).toString("hex");
+    apiKeySource = "auto-generated";
     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.");
@@ -4941,6 +4987,11 @@ if (!API_KEY) {
     process.exit(1);
   }
 }
+if (apiKeySource === "SHODH_DEV_API_KEY") {
+  console.error("[shodh-memory] WARNING: API key loaded from SHODH_DEV_API_KEY — this is a development key. Use SHODH_API_KEY for production.");
+} else if (apiKeySource && apiKeySource !== "auto-generated" && apiKeySource !== "sandbox") {
+  console.error(`[shodh-memory] API key loaded from ${apiKeySource}.`);
+}
 var RETRY_ATTEMPTS = 3;
 var RETRY_DELAY_MS = 1000;
 var REQUEST_TIMEOUT_MS = 1e4;
@@ -4977,22 +5028,9 @@ 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 lastUserContext = "";
+var proactiveCallInFlight = false;
 var streamSocket = null;
 var streamConnecting = false;
 var streamReconnectTimer = null;
@@ -5135,10 +5173,12 @@ async function surfaceRelevant(context, maxResults = 3) {
       }),
       signal: controller.signal
     });
-    clearTimeout(timeoutId);
-    if (!response.ok)
+    if (!response.ok) {
+      clearTimeout(timeoutId);
       return null;
+    }
     const result = await response.json();
+    clearTimeout(timeoutId);
     return result.memories || null;
   } catch (e) {
     console.error("[Proactive] Failed to surface memories:", e);
@@ -5192,10 +5232,15 @@ async function apiCall(endpoint, method = "GET", body) {
         const errorText = await response.text().catch(() => "Unknown error");
         throw new Error(`API error ${response.status}: ${errorText}`);
       }
-      return await response.json();
+      try {
+        return await response.json();
+      } catch {
+        throw new Error(`API returned invalid JSON from ${endpoint}`);
+      }
     } catch (error) {
       lastError = error instanceof Error ? error : new Error(String(error));
-      if (lastError.message.includes("API error 4")) {
+      const statusMatch = lastError.message.match(/API error (\d+)/);
+      if (statusMatch && parseInt(statusMatch[1], 10) >= 400 && parseInt(statusMatch[1], 10) < 500) {
         throw lastError;
       }
       if (attempt < RETRY_ATTEMPTS) {
@@ -5297,6 +5342,57 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
             parent_id: {
               type: "string",
               description: "Parent memory ID for hierarchical organization. Creates memory trees (e.g., '71-research' -> 'algebraic' -> '21×27≡-1')"
+            },
+            importance: {
+              type: "number",
+              description: "Optional importance override (0.0-1.0). Bypasses auto-calculation. Use for memories where importance is known: Decision=0.8, Learning=0.7, Error=0.7, Discovery=0.6, Observation=0.3"
+            },
+            robot_id: {
+              type: "string",
+              description: "Robot/drone identifier for multi-robot systems"
+            },
+            mission_id: {
+              type: "string",
+              description: "Mission identifier for grouping experiences"
+            },
+            geo_location: {
+              type: "array",
+              items: { type: "number" },
+              minItems: 3,
+              maxItems: 3,
+              description: "GPS coordinates [latitude, longitude, altitude] in WGS84"
+            },
+            local_position: {
+              type: "array",
+              items: { type: "number" },
+              minItems: 3,
+              maxItems: 3,
+              description: "Local position [x, y, z] in meters (robot-local frame)"
+            },
+            heading: {
+              type: "number",
+              description: "Heading in degrees (0-360)"
+            },
+            action_type: {
+              type: "string",
+              description: "Action type name (e.g., 'navigate', 'grasp', 'dock')"
+            },
+            reward: {
+              type: "number",
+              description: "Reinforcement learning reward signal (-1.0 to 1.0)"
+            },
+            sensor_data: {
+              type: "object",
+              additionalProperties: { type: "number" },
+              description: "Raw sensor readings (e.g., {battery: 72.5, temperature: 23.1})"
+            },
+            outcome_type: {
+              type: "string",
+              description: "Outcome type: success, failure, partial, aborted, timeout"
+            },
+            terrain_type: {
+              type: "string",
+              description: "Terrain type: indoor, outdoor, urban, rural, water, aerial"
             }
           },
           required: ["content"]
@@ -5304,7 +5400,7 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
       },
       {
         name: "recall",
-        description: "Search memories AND todos using semantic similarity. Returns both relevant memories and matching todos. Use this to find past experiences, decisions, context, or pending work. Modes: 'semantic' (vector similarity), 'associative' (graph traversal), 'hybrid' (combined).",
+        description: "Search memories AND todos using semantic similarity. Returns both relevant memories and matching todos. Use this to find past experiences, decisions, context, or pending work. Modes: 'semantic' (vector similarity), 'associative' (graph traversal), 'temporal' (time-based retrieval), 'hybrid' (combined), 'spatial' (geo-location based), 'mission' (mission context), 'action_outcome' (reward-based learning).",
         inputSchema: {
           type: "object",
           properties: {
@@ -5319,14 +5415,87 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
             },
             mode: {
               type: "string",
-              enum: ["semantic", "associative", "hybrid"],
-              description: "Retrieval mode: 'semantic' for pure vector similarity, 'associative' for graph-based traversal (follows learned connections), 'hybrid' for density-dependent combination (default)",
+              enum: ["semantic", "associative", "temporal", "hybrid", "spatial", "mission", "action_outcome"],
+              description: "Retrieval mode: 'semantic' for pure vector similarity, 'associative' for graph-based traversal (follows learned connections), 'temporal' for time-based retrieval, 'hybrid' for density-dependent combination (default), 'spatial' for geo-location based, 'mission' for mission context, 'action_outcome' for reward-based learning",
               default: "hybrid"
+            },
+            session_id: {
+              type: "string",
+              description: "Session ID for session-scoped retrieval. When provided, retrieves memories from that session's time window. Forces temporal mode."
+            },
+            robot_id: {
+              type: "string",
+              description: "Filter by robot/drone identifier (for multi-robot systems)"
+            },
+            mission_id: {
+              type: "string",
+              description: "Filter by mission identifier"
+            },
+            geo_lat: {
+              type: "number",
+              description: "Spatial filter: center latitude (-90 to 90). Requires geo_lon and geo_radius_meters."
+            },
+            geo_lon: {
+              type: "number",
+              description: "Spatial filter: center longitude (-180 to 180). Requires geo_lat and geo_radius_meters."
+            },
+            geo_radius_meters: {
+              type: "number",
+              description: "Spatial filter: search radius in meters. Requires geo_lat and geo_lon."
+            },
+            action_type: {
+              type: "string",
+              description: "Filter by action type (e.g., 'navigate', 'grasp', 'dock')"
+            },
+            reward_min: {
+              type: "number",
+              description: "Filter by minimum reward value (-1.0 to 1.0)"
+            },
+            reward_max: {
+              type: "number",
+              description: "Filter by maximum reward value (-1.0 to 1.0)"
+            },
+            outcome_type: {
+              type: "string",
+              description: "Filter by outcome type: success, failure, partial, aborted, timeout"
+            },
+            failures_only: {
+              type: "boolean",
+              description: "If true, only return failure/error experiences"
+            },
+            terrain_type: {
+              type: "string",
+              description: "Filter by terrain type: indoor, outdoor, urban, rural, water, aerial"
+            },
+            tags: {
+              type: "array",
+              items: { type: "string" },
+              description: "Filter by tags (any match)"
             }
           },
           required: ["query"]
         }
       },
+      {
+        name: "recall_by_tags",
+        description: "Find memories by tags. Returns memories matching ANY of the provided tags. Useful for finding memories by category (e.g., 'tool:Edit', 'file:src/main.rs', 'source:hook', 'error', 'session-summary').",
+        inputSchema: {
+          type: "object",
+          properties: {
+            tags: {
+              type: "array",
+              items: { type: "string" },
+              description: "Tags to search for (returns memories matching ANY of these tags)"
+            },
+            limit: {
+              type: "number",
+              description: "Maximum number of results (default: 50)",
+              default: 50
+            }
+          },
+          required: ["tags"]
+        }
+      },
       {
         name: "context_summary",
         description: "Get a condensed summary of recent learnings, decisions, and context. Use this at the start of a session to quickly understand what you've learned before.",
@@ -5522,6 +5691,21 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
               type: "boolean",
               description: "Automatically store the context as a Conversation memory (default: true). Set to false to only surface memories without storing.",
               default: true
+            },
+            tool_actions: {
+              type: "array",
+              items: {
+                type: "object",
+                properties: {
+                  tool_name: { type: "string", description: "Tool or actuator name (e.g., 'Edit', 'Bash', 'navigate', 'grasp')" },
+                  inputs: { type: "object", additionalProperties: { type: "string" }, description: "Key-value input parameters" },
+                  success: { type: "boolean", description: "Whether the action succeeded" },
+                  output_snippet: { type: "string", description: "First 200 chars of output" },
+                  reward: { type: "number", description: "Reward signal for robotics (-1.0 to 1.0)" }
+                },
+                required: ["tool_name", "success"]
+              },
+              description: "Tool/actuator actions performed since last proactive_context call. Used for causal feedback attribution."
             }
           },
           required: ["context"]
@@ -6059,7 +6243,18 @@ To start: cd shodh-memory && cargo run`
           episode_id,
           sequence_number,
           preceding_memory_id,
-          parent_id
+          parent_id,
+          importance,
+          robot_id,
+          mission_id,
+          geo_location,
+          local_position,
+          heading,
+          action_type,
+          reward,
+          sensor_data,
+          outcome_type,
+          terrain_type
         } = args;
         if (!content || content.length === 0) {
           return { content: [{ type: "text", text: "Error: 'content' is required and cannot be empty" }], isError: true };
@@ -6081,7 +6276,18 @@ To start: cd shodh-memory && cargo run`
           ...episode_id && { episode_id },
           ...sequence_number !== undefined && { sequence_number },
           ...preceding_memory_id && { preceding_memory_id },
-          ...parent_id && { parent_id }
+          ...parent_id && { parent_id },
+          ...importance !== undefined && { importance },
+          ...robot_id && { robot_id },
+          ...mission_id && { mission_id },
+          ...geo_location && geo_location.length === 3 && { geo_location },
+          ...local_position && local_position.length === 3 && { local_position },
+          ...heading !== undefined && { heading },
+          ...action_type && { action_type },
+          ...reward !== undefined && { reward },
+          ...sensor_data && Object.keys(sensor_data).length > 0 && { sensor_data },
+          ...outcome_type && { outcome_type },
+          ...terrain_type && { terrain_type }
         });
         let response = `\uD83D\uDC18 Memory Stored
 `;
@@ -6102,14 +6308,31 @@ ID: ${result.id}`;
         };
       }
       case "recall": {
-        const { query, limit: rawLimit = 5, mode = "hybrid" } = args;
+        const {
+          query,
+          limit: rawLimit = 5,
+          mode = "hybrid",
+          session_id,
+          robot_id,
+          mission_id,
+          geo_lat,
+          geo_lon,
+          geo_radius_meters,
+          action_type,
+          reward_min,
+          reward_max,
+          outcome_type,
+          failures_only,
+          terrain_type,
+          tags
+        } = args;
         if (!query || query.length === 0) {
           return { content: [{ type: "text", text: "Error: 'query' is required and cannot be empty" }], isError: true };
         }
         if (query.length > MAX_QUERY_LENGTH) {
           return { content: [{ type: "text", text: `Error: 'query' exceeds maximum length of ${MAX_QUERY_LENGTH} characters` }], isError: true };
         }
-        const validModes = ["semantic", "associative", "hybrid"];
+        const validModes = ["semantic", "associative", "temporal", "hybrid", "spatial", "mission", "action_outcome"];
         if (!validModes.includes(mode)) {
           return { content: [{ type: "text", text: `Error: 'mode' must be one of: ${validModes.join(", ")}` }], isError: true };
         }
@@ -6118,7 +6341,20 @@ ID: ${result.id}`;
           user_id: USER_ID,
           query,
           limit,
-          mode
+          mode,
+          ...session_id ? { session_id } : {},
+          ...robot_id ? { robot_id } : {},
+          ...mission_id ? { mission_id } : {},
+          ...geo_lat !== undefined ? { geo_lat } : {},
+          ...geo_lon !== undefined ? { geo_lon } : {},
+          ...geo_radius_meters !== undefined ? { geo_radius_meters } : {},
+          ...action_type ? { action_type } : {},
+          ...reward_min !== undefined ? { reward_min } : {},
+          ...reward_max !== undefined ? { reward_max } : {},
+          ...outcome_type ? { outcome_type } : {},
+          ...failures_only !== undefined ? { failures_only } : {},
+          ...terrain_type ? { terrain_type } : {},
+          ...tags && tags.length > 0 ? { tags } : {}
         });
         const memories = result.memories || [];
         const todos = result.todos || [];
@@ -6166,14 +6402,17 @@ ID: ${result.id}`;
             return d.toLocaleDateString([], { month: "short", day: "numeric" });
           }
         };
+        const memoryDisplayScores = memories.map((m) => m.score || 0);
+        const todoDisplayScores = todos.map((t) => t.score || 0);
         if (memories.length > 0) {
           response += `\uD83D\uDCDD MEMORIES
 `;
           for (let i = 0;i < memories.length; i++) {
             const m = memories[i];
             const content = getContent(m);
-            const score = ((m.score || 0) * 100).toFixed(0);
-            const filled = Math.max(0, Math.min(10, Math.round((m.score || 0) * 10)));
+            const displayScore = memoryDisplayScores[i];
+            const score = (displayScore * 100).toFixed(0);
+            const filled = Math.max(0, Math.min(10, Math.round(displayScore * 10)));
             const matchBar = "█".repeat(filled) + "░".repeat(10 - filled);
             const timeStr = formatTime(m.created_at);
             response += `• ${matchBar} ${score}% │ ${timeStr}
@@ -6195,8 +6434,9 @@ ID: ${result.id}`;
 `;
           for (let i = 0;i < todos.length; i++) {
             const t = todos[i];
-            const score = ((t.score || 0) * 100).toFixed(0);
-            const filled = Math.max(0, Math.min(10, Math.round((t.score || 0) * 10)));
+            const displayScore = todoDisplayScores[i];
+            const score = (displayScore * 100).toFixed(0);
+            const filled = Math.max(0, Math.min(10, Math.round(displayScore * 10)));
             const matchBar = "█".repeat(filled) + "░".repeat(10 - filled);
             const statusIcon = t.status === "done" ? "✓" : t.status === "in_progress" ? "▶" : t.status === "blocked" ? "⊗" : "○";
             const timeStr = formatTime(t.created_at);
@@ -6254,6 +6494,47 @@ ID: ${result.id}`;
           content: [{ type: "text", text: response }]
         };
       }
+      case "recall_by_tags": {
+        const { tags, limit: rawTagLimit = 50 } = args;
+        if (!tags || tags.length === 0) {
+          return {
+            content: [{ type: "text", text: "Error: 'tags' is required and must contain at least one tag" }],
+            isError: true
+          };
+        }
+        const tagLimit = Math.max(1, Math.min(Math.floor(rawTagLimit), MAX_LIMIT));
+        const tagResult = await apiCall("/api/recall/tags", "POST", {
+          user_id: USER_ID,
+          tags,
+          limit: tagLimit
+        });
+        const tagMemories = tagResult.memories || [];
+        if (tagMemories.length === 0) {
+          return {
+            content: [{ type: "text", text: `No memories found matching tags: ${tags.join(", ")}` }]
+          };
+        }
+        let tagResponse = `\uD83C\uDFF7️ Recall by Tags: ${tags.join(", ")}
+`;
+        tagResponse += `━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+`;
+        tagResponse += `Found ${tagMemories.length} memories
+
+`;
+        for (let i = 0;i < tagMemories.length; i++) {
+          const m = tagMemories[i];
+          const content = getContent(m);
+          const memTags = (m.experience?.tags || []).join(", ");
+          tagResponse += `${String(i + 1).padStart(2)}. ${content.slice(0, 150)}${content.length > 150 ? "..." : ""}
+`;
+          tagResponse += `    ┗━ ${getType(m)} │ tags: [${memTags}] │ ${m.id}
+
+`;
+        }
+        return {
+          content: [{ type: "text", text: tagResponse.trimEnd() }]
+        };
+      }
       case "context_summary": {
         const {
           include_decisions = true,
@@ -6698,7 +6979,8 @@ By Type:
           recency_weight = 0.2,
           max_results = 5,
           memory_types = [],
-          auto_ingest = true
+          auto_ingest = true,
+          tool_actions = []
         } = args;
         const cleanedContext = stripSystemNoise(context).slice(0, MAX_CONTEXT_LENGTH);
         if (cleanedContext.length < PROACTIVE_MIN_CONTEXT_LENGTH) {
@@ -6708,6 +6990,10 @@ By Type:
 [Latency: 0.0ms]` }]
           };
         }
+        const skipFeedback = proactiveCallInFlight;
+        proactiveCallInFlight = true;
+        const previousUserContext = skipFeedback ? "" : lastUserContext;
+        lastUserContext = cleanedContext;
         const result = await apiCall("/api/proactive_context", "POST", {
           user_id: USER_ID,
           context: cleanedContext,
@@ -6717,8 +7003,9 @@ By Type:
           recency_weight,
           memory_types,
           auto_ingest,
-          previous_response: lastProactiveResponse || undefined,
-          user_followup: lastProactiveResponse ? cleanedContext : undefined
+          previous_response: skipFeedback ? undefined : lastProactiveResponse || undefined,
+          user_followup: skipFeedback || !lastProactiveResponse ? undefined : previousUserContext || undefined,
+          ...tool_actions.length > 0 ? { tool_actions } : {}
         });
         const memories = result.memories || [];
         const entities = result.detected_entities || [];
@@ -6729,10 +7016,13 @@ By Type:
 Detected entities: ${entities.map((e) => `"${e.name}" (${e.entity_type})`).join(", ")}` : "";
           const feedbackNote2 = result.feedback_processed ? `
 [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}
+          const temporalNote2 = result.temporal_credits_applied ? `
+[Temporal credits: ${result.temporal_credits_applied} multi-turn signals applied]` : "";
+          const emptyText = `No relevant memories surfaced for this context.${entityList}${feedbackNote2}${temporalNote2}
 
 [Latency: ${(result.latency_ms ?? 0).toFixed(1)}ms]`;
           lastProactiveResponse = emptyText;
+          proactiveCallInFlight = false;
           return {
             content: [{ type: "text", text: emptyText }]
           };
@@ -6852,6 +7142,8 @@ 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 temporalNote = result.temporal_credits_applied ? `
+[Temporal credits: ${result.temporal_credits_applied} multi-turn signals applied]` : "";
         const ingestNote = result.ingested_memory_id ? `
 [Context ingested: ${result.ingested_memory_id}]` : "";
         const summaryParts = [];
@@ -6866,10 +7158,13 @@ Detected entities: ${entities.map((e) => `"${e.name}" (${e.entity_type})`).join(
         const summary = summaryParts.length > 0 ? `Surfaced ${summaryParts.join(", ")}` : "No relevant context found";
         const responseText = `${temporalHeader}${summary}:
 
-${formattedWithTime}${entitySummary}${factsBlock}${reminderBlock}${todoBlock}${feedbackNote}${ingestNote}
+${formattedWithTime}${entitySummary}${factsBlock}${reminderBlock}${todoBlock}${feedbackNote}${temporalNote}${ingestNote}
 
 [Latency: ${(result.latency_ms ?? 0).toFixed(1)}ms | Threshold: ${(semantic_threshold * 100).toFixed(0)}%]`;
-        lastProactiveResponse = responseText;
+        const cleanContent = memories.map((m) => m.content || "").filter((c) => c.length > 0).join(`
+`);
+        lastProactiveResponse = cleanContent || responseText;
+        proactiveCallInFlight = false;
         return {
           content: [{ type: "text", text: responseText }]
         };
@@ -7420,13 +7715,13 @@ ${formattedWithTime}${entitySummary}${factsBlock}${reminderBlock}${todoBlock}${f
       const context = contextParts.join(" ").slice(0, 1000);
       if (context.length >= PROACTIVE_MIN_CONTEXT_LENGTH) {
         const surfaced = await surfaceRelevant(context, 3);
-        if (surfaced && surfaced.length > 0) {
+        if (surfaced && surfaced.length > 0 && result.content.length > 0) {
           const surfacedText = formatSurfacedMemories(surfaced);
           result.content[result.content.length - 1].text += surfacedText;
         }
       }
     }
-    if (tokenStatus.alert) {
+    if (tokenStatus.alert && result.content.length > 0) {
       const percentUsed = Math.round(tokenStatus.percent * 100);
       const warning = `⚠️ CONTEXT ALERT: ${percentUsed}% of token budget used (${tokenStatus.tokens.toLocaleString()}/${tokenStatus.budget.toLocaleString()}). Consider starting a new session or running consolidation.
 
@@ -8172,16 +8467,31 @@ async function ensureServerRunning() {
   }
 }
 function cleanupServer() {
+  if (streamReconnectTimer) {
+    clearTimeout(streamReconnectTimer);
+    streamReconnectTimer = null;
+  }
+  STREAM_ENABLED = false;
+  if (streamSocket) {
+    try {
+      streamSocket.close();
+    } catch (_) {}
+    streamSocket = null;
+  }
   if (serverProcess && !serverProcess.killed) {
     if (process.platform !== "win32" && serverProcess.pid) {
       try {
         process.kill(-serverProcess.pid, "SIGTERM");
       } catch (e) {
         console.error("[Cleanup] Process group kill failed, falling back to direct kill:", e);
-        serverProcess.kill("SIGTERM");
+        try {
+          serverProcess.kill("SIGTERM");
+        } catch (_) {}
       }
     } else {
-      serverProcess.kill();
+      try {
+        serverProcess.kill();
+      } catch (_) {}
     }
   }
 }
@@ -8196,6 +8506,25 @@ process.on("SIGTERM", () => {
   cleanupServer();
   process.exit(0);
 });
+var shuttingDown = false;
+function gracefulShutdown(reason, code = 0) {
+  if (shuttingDown)
+    return;
+  shuttingDown = true;
+  console.error(`[shodh-memory] ${reason}`);
+  cleanupServer();
+  setTimeout(() => process.exit(code), 100);
+}
+process.stdin.on("end", () => gracefulShutdown("stdin closed (MCP session ended), shutting down..."));
+process.stdin.on("close", () => gracefulShutdown("stdin pipe closed, shutting down..."));
+process.on("uncaughtException", (err) => {
+  console.error("[shodh-memory] Uncaught exception:", err);
+  gracefulShutdown("Shutting down after uncaught exception", 1);
+});
+process.on("unhandledRejection", (reason) => {
+  console.error("[shodh-memory] Unhandled rejection:", reason);
+  gracefulShutdown("Shutting down after unhandled rejection", 1);
+});
 function createSandboxServer() {
   process.env.SMITHERY_SANDBOX = "true";
   return server;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shodh/memory-mcp",
-  "version": "0.1.90",
+  "version": "0.2.0",
   "mcpName": "io.github.varun29ankuS/shodh-memory",
   "description": "MCP server for persistent AI memory - store and recall context across sessions",
   "type": "module",

package/scripts/postinstall.cjs

@@ -9,7 +9,7 @@
 const fs = require('fs');
 const path = require('path');
 const https = require('https');
-const { execSync } = require('child_process');
+const { execFileSync } = require('child_process');
 
 const VERSION = require('../package.json').version;
 const REPO = 'varun29ankuS/shodh-memory';
@@ -71,10 +71,10 @@ function download(url, dest) {
 // Extract archive
 function extract(archive, dest, platformInfo) {
   if (platformInfo.ext === '.tar.gz') {
-    execSync(`tar -xzf "${archive}" -C "${dest}"`, { stdio: 'inherit' });
+    execFileSync('tar', ['-xzf', archive, '-C', dest], { stdio: 'inherit' });
   } else if (platformInfo.ext === '.zip') {
     // Use PowerShell on Windows
-    execSync(`powershell -Command "Expand-Archive -Path '${archive}' -DestinationPath '${dest}' -Force"`, { stdio: 'inherit' });
+    execFileSync('powershell', ['-Command', `Expand-Archive -Path '${archive}' -DestinationPath '${dest}' -Force`], { stdio: 'inherit' });
   }
 }