@shodh/memory-mcp 0.1.61 → 0.1.70

package/dist/index.js

@@ -4903,6 +4903,26 @@ if (!API_KEY) {
 var RETRY_ATTEMPTS = 3;
 var RETRY_DELAY_MS = 1000;
 var REQUEST_TIMEOUT_MS = 1e4;
+var TOKEN_BUDGET = parseInt(process.env.SHODH_TOKEN_BUDGET || "100000", 10);
+var ALERT_THRESHOLD = parseFloat(process.env.SHODH_ALERT_THRESHOLD || "0.9");
+var sessionTokens = 0;
+var sessionStartTime = Date.now();
+function estimateTokens(text) {
+  return Math.ceil(text.length / 4);
+}
+function getTokenStatus() {
+  const percent = sessionTokens / TOKEN_BUDGET;
+  return {
+    tokens: sessionTokens,
+    budget: TOKEN_BUDGET,
+    percent: Math.round(percent * 100) / 100,
+    alert: percent >= ALERT_THRESHOLD ? `context_${Math.round(ALERT_THRESHOLD * 100)}_percent` : null
+  };
+}
+function resetTokenSession() {
+  sessionTokens = 0;
+  sessionStartTime = Date.now();
+}
 var STREAM_ENABLED = process.env.SHODH_STREAM !== "false";
 var STREAM_MIN_CONTENT_LENGTH = 50;
 var PROACTIVE_SURFACING = process.env.SHODH_PROACTIVE !== "false";
@@ -5122,11 +5142,12 @@ async function isServerAvailable() {
 }
 var server = new Server({
   name: "shodh-memory",
-  version: "0.1.51"
+  version: "0.1.61"
 }, {
   capabilities: {
     tools: {},
-    resources: {}
+    resources: {},
+    prompts: {}
   }
 });
 server.setRequestHandler(ListToolsRequestSchema, async () => {
@@ -5196,17 +5217,17 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
       },
       {
         name: "recall",
-        description: "Search memories using different retrieval modes. Use this to find relevant past experiences, decisions, or context. Modes: 'semantic' (vector similarity), 'associative' (graph traversal - follows learned connections between memories), 'hybrid' (combines both with density-dependent weighting).",
+        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).",
         inputSchema: {
           type: "object",
           properties: {
             query: {
               type: "string",
-              description: "Natural language search query"
+              description: "Natural language search query - searches both memories and todos"
             },
             limit: {
               type: "number",
-              description: "Maximum number of results (default: 5)",
+              description: "Maximum number of memory results (default: 5). Todos limited to 5.",
               default: 5
             },
             mode: {
@@ -5301,79 +5322,47 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
         }
       },
       {
-        name: "recall_by_tags",
-        description: "Search memories by tags. Returns memories matching ANY of the provided tags.",
+        name: "backup_create",
+        description: "Create a backup of all memories. Returns backup metadata including ID, size, and checksum. Backups are stored locally and can be restored later.",
         inputSchema: {
           type: "object",
-          properties: {
-            tags: {
-              type: "array",
-              items: { type: "string" },
-              description: "Tags to search for (returns memories matching ANY tag)"
-            },
-            limit: {
-              type: "number",
-              description: "Maximum number of results (default: 20)",
-              default: 20
-            }
-          },
-          required: ["tags"]
+          properties: {}
         }
       },
       {
-        name: "recall_by_date",
-        description: "Search memories within a date range.",
+        name: "backup_list",
+        description: "List all available backups for this user. Returns backup history with IDs, timestamps, and sizes.",
         inputSchema: {
           type: "object",
-          properties: {
-            start: {
-              type: "string",
-              description: "Start date (ISO 8601 format, e.g., '2024-01-01T00:00:00Z')"
-            },
-            end: {
-              type: "string",
-              description: "End date (ISO 8601 format, e.g., '2024-12-31T23:59:59Z')"
-            },
-            limit: {
-              type: "number",
-              description: "Maximum number of results (default: 20)",
-              default: 20
-            }
-          },
-          required: ["start", "end"]
+          properties: {}
         }
       },
       {
-        name: "forget_by_tags",
-        description: "Delete memories matching ANY of the provided tags.",
+        name: "backup_verify",
+        description: "Verify backup integrity using SHA-256 checksum. Use to check if a backup is corrupted before restoring.",
         inputSchema: {
           type: "object",
           properties: {
-            tags: {
-              type: "array",
-              items: { type: "string" },
-              description: "Tags to match for deletion"
+            backup_id: {
+              type: "number",
+              description: "The backup ID to verify"
             }
           },
-          required: ["tags"]
+          required: ["backup_id"]
         }
       },
       {
-        name: "forget_by_date",
-        description: "Delete memories within a date range.",
+        name: "backup_purge",
+        description: "Purge old backups, keeping only the most recent N. Useful for managing disk space.",
         inputSchema: {
           type: "object",
           properties: {
-            start: {
-              type: "string",
-              description: "Start date (ISO 8601 format)"
-            },
-            end: {
-              type: "string",
-              description: "End date (ISO 8601 format)"
+            keep_count: {
+              type: "number",
+              description: "Number of backups to keep (default: 7)",
+              default: 7
             }
-          },
-          required: ["start", "end"]
+          }
         }
       },
       {
@@ -5438,457 +5427,1087 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
         }
       },
       {
-        name: "streaming_status",
-        description: "Check the status of WebSocket streaming connection. Use this to diagnose if streaming memory ingestion is working.",
+        name: "token_status",
+        description: "Get current token usage status for this session. Returns tokens used, budget remaining, and percentage consumed. Use this to check context window health.",
         inputSchema: {
           type: "object",
           properties: {}
         }
-      }
-    ]
-  };
-});
-function autoStreamContext(toolName, args) {
-  if (["proactive_context", "streaming_status"].includes(toolName))
-    return;
-  let context = "";
-  if (args.query && typeof args.query === "string") {
-    context = `Query: ${args.query}`;
-  } else if (args.content && typeof args.content === "string") {
-    context = args.content;
-  } else if (args.context && typeof args.context === "string") {
-    context = args.context;
-  }
-  if (context.length >= 20) {
-    streamMemory(context, ["auto-context", toolName], "user");
-  }
-}
-server.setRequestHandler(CallToolRequestSchema, async (request) => {
-  const { name, arguments: args } = request.params;
-  if (STREAM_ENABLED && (!streamSocket || streamSocket.readyState !== WebSocket.OPEN)) {
-    connectStream().catch(() => {});
-  }
-  autoStreamContext(name, args);
-  const serverUp = await isServerAvailable();
-  if (!serverUp) {
-    return {
-      content: [
-        {
-          type: "text",
-          text: `Memory server unavailable at ${API_URL}. Please ensure shodh-memory-server is running.
-
-To start: cd shodh-memory && cargo run`
+      },
+      {
+        name: "reset_token_session",
+        description: "Reset the token counter for a new session. Call this when starting a new conversation or after context has been compressed/summarized.",
+        inputSchema: {
+          type: "object",
+          properties: {}
         }
-      ],
-      isError: true
-    };
-  }
-  const executeTool = async () => {
-    switch (name) {
-      case "remember": {
-        const {
-          content,
-          type = "Observation",
-          tags = [],
-          created_at,
-          emotional_valence,
-          emotional_arousal,
-          emotion,
-          source_type,
-          credibility,
-          episode_id,
-          sequence_number,
-          preceding_memory_id
-        } = args;
-        const result = await apiCall("/api/remember", "POST", {
-          user_id: USER_ID,
-          content,
-          memory_type: type,
-          tags,
-          ...created_at && { created_at },
-          ...emotional_valence !== undefined && { emotional_valence },
-          ...emotional_arousal !== undefined && { emotional_arousal },
-          ...emotion && { emotion },
-          ...source_type && { source_type },
-          ...credibility !== undefined && { credibility },
-          ...episode_id && { episode_id },
-          ...sequence_number !== undefined && { sequence_number },
-          ...preceding_memory_id && { preceding_memory_id }
-        });
-        return {
-          content: [
-            {
-              type: "text",
-              text: `Remembered: "${content.slice(0, 50)}${content.length > 50 ? "..." : ""}"
-Memory ID: ${result.id}`
+      },
+      {
+        name: "set_reminder",
+        description: "Set a reminder for the future. Triggers on time (at specific time or after duration) or context match (when keywords appear in conversation). Reminders will surface automatically when conditions are met.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            content: {
+              type: "string",
+              description: "What to remember/remind about"
+            },
+            trigger_type: {
+              type: "string",
+              enum: ["time", "duration", "context"],
+              description: "When to trigger: 'time' (at specific ISO timestamp), 'duration' (after N seconds), 'context' (when keywords match)"
+            },
+            trigger_at: {
+              type: "string",
+              description: "ISO 8601 timestamp for 'time' trigger (e.g., '2025-12-23T18:00:00Z')"
+            },
+            after_seconds: {
+              type: "number",
+              description: "Seconds from now for 'duration' trigger"
+            },
+            keywords: {
+              type: "array",
+              items: { type: "string" },
+              description: "Keywords for 'context' trigger - reminder surfaces when any keyword appears"
+            },
+            priority: {
+              type: "number",
+              description: "Priority 1-5 (5 = highest, default: 3)",
+              default: 3
+            },
+            tags: {
+              type: "array",
+              items: { type: "string" },
+              description: "Optional tags for categorization"
             }
-          ]
-        };
-      }
-      case "recall": {
-        const { query, limit = 5, mode = "hybrid" } = args;
-        const result = await apiCall("/api/recall", "POST", {
-          user_id: USER_ID,
-          query,
-          limit,
-          mode
-        });
-        const memories = result.memories || [];
-        const stats = result.retrieval_stats;
-        if (memories.length === 0) {
-          return {
-            content: [
-              {
-                type: "text",
-                text: `No memories found for: "${query}" (mode: ${mode})`
-              }
-            ]
-          };
-        }
-        const formatted = memories.map((m, i) => {
-          const content = getContent(m);
-          const score = ((m.score || 0) * 100).toFixed(0);
-          return `${i + 1}. [${score}% match] ${content}
-   Type: ${getType(m)} | ID: ${m.id.slice(0, 8)}...`;
-        }).join(`
-
-`);
-        let statsText = "";
-        if (stats && (mode === "associative" || mode === "hybrid")) {
-          const graphPct = (stats.graph_weight * 100).toFixed(0);
-          const semPct = (stats.semantic_weight * 100).toFixed(0);
-          statsText = `
-
-[Stats: ${stats.mode} mode | graph=${graphPct}% semantic=${semPct}% | density=${stats.graph_density.toFixed(2)} | ${stats.graph_candidates} graph + ${stats.semantic_candidates} semantic candidates | ${stats.entities_activated} entities | ${(stats.retrieval_time_us / 1000).toFixed(1)}ms]`;
+          },
+          required: ["content", "trigger_type"]
         }
-        return {
-          content: [
-            {
-              type: "text",
-              text: `Found ${memories.length} relevant memories (${mode} mode):
-
-${formatted}${statsText}`
+      },
+      {
+        name: "list_reminders",
+        description: "List all pending reminders. Use to check what reminders are scheduled.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            status: {
+              type: "string",
+              enum: ["pending", "triggered", "dismissed", "all"],
+              description: "Filter by status (default: pending)",
+              default: "pending"
             }
-          ]
-        };
-      }
-      case "context_summary": {
-        const {
-          include_decisions = true,
-          include_learnings = true,
-          include_context = true,
-          max_items = 5
-        } = args;
-        const result = await apiCall("/api/memories", "POST", {
-          user_id: USER_ID
-        });
-        const memories = result.memories || [];
-        if (memories.length === 0) {
-          return {
-            content: [
-              {
-                type: "text",
-                text: "No memories stored yet. Start remembering things to build context!"
-              }
-            ]
-          };
-        }
-        const decisions = [];
-        const learnings = [];
-        const context = [];
-        const patterns = [];
-        const errors2 = [];
-        for (const m of memories) {
-          const type = getType(m);
-          switch (type) {
-            case "Decision":
-              decisions.push(m);
-              break;
-            case "Learning":
-              learnings.push(m);
-              break;
-            case "Context":
-              context.push(m);
-              break;
-            case "Pattern":
-              patterns.push(m);
-              break;
-            case "Error":
-              errors2.push(m);
-              break;
           }
         }
-        const sections = [];
-        if (include_context && context.length > 0) {
-          const items = context.slice(0, max_items).map((m) => `  - ${getContent(m).slice(0, 100)}`);
-          sections.push(`PROJECT CONTEXT:
-${items.join(`
-`)}`);
-        }
-        if (include_decisions && decisions.length > 0) {
-          const items = decisions.slice(0, max_items).map((m) => `  - ${getContent(m).slice(0, 100)}`);
-          sections.push(`DECISIONS MADE:
-${items.join(`
-`)}`);
-        }
-        if (include_learnings && learnings.length > 0) {
-          const items = learnings.slice(0, max_items).map((m) => `  - ${getContent(m).slice(0, 100)}`);
-          sections.push(`LEARNINGS:
-${items.join(`
-`)}`);
-        }
-        if (patterns.length > 0) {
-          const items = patterns.slice(0, max_items).map((m) => `  - ${getContent(m).slice(0, 100)}`);
-          sections.push(`PATTERNS NOTICED:
-${items.join(`
-`)}`);
-        }
-        if (errors2.length > 0) {
-          const items = errors2.slice(0, Math.min(3, max_items)).map((m) => `  - ${getContent(m).slice(0, 100)}`);
-          sections.push(`ERRORS TO AVOID:
-${items.join(`
-`)}`);
-        }
-        const summary = sections.length > 0 ? sections.join(`
-
-`) : `${memories.length} memories stored, but none categorized as decisions, learnings, or context. Consider using those types when remembering.`;
-        return {
-          content: [
-            {
-              type: "text",
-              text: `CONTEXT SUMMARY (${memories.length} total memories)
-${"=".repeat(40)}
-
-${summary}`
+      },
+      {
+        name: "dismiss_reminder",
+        description: "Dismiss/acknowledge a triggered reminder. Call this after you've handled a reminder.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            reminder_id: {
+              type: "string",
+              description: "ID of the reminder to dismiss"
             }
-          ]
-        };
-      }
-      case "list_memories": {
-        const { limit = 20 } = args;
-        const result = await apiCall("/api/memories", "POST", {
-          user_id: USER_ID
-        });
-        const memories = (result.memories || []).slice(0, limit);
+          },
+          required: ["reminder_id"]
+        }
+      },
+      {
+        name: "add_todo",
+        description: "Add a task to your todo list. Supports GTD workflow with projects, contexts (@computer, @phone), priorities, due dates, and subtasks (via parent_id).",
+        inputSchema: {
+          type: "object",
+          properties: {
+            content: {
+              type: "string",
+              description: "What needs to be done"
+            },
+            status: {
+              type: "string",
+              enum: ["backlog", "todo", "in_progress", "blocked"],
+              description: "Initial status (default: todo)",
+              default: "todo"
+            },
+            priority: {
+              type: "string",
+              enum: ["urgent", "high", "medium", "low", "none"],
+              description: "Priority level (default: medium)",
+              default: "medium"
+            },
+            project: {
+              type: "string",
+              description: "Project name (created if doesn't exist)"
+            },
+            contexts: {
+              type: "array",
+              items: { type: "string" },
+              description: "Contexts like @computer, @phone, @errands"
+            },
+            due_date: {
+              type: "string",
+              description: "Due date - ISO format or 'today', 'tomorrow', 'monday', etc."
+            },
+            tags: {
+              type: "array",
+              items: { type: "string" },
+              description: "Optional tags for categorization"
+            },
+            blocked_on: {
+              type: "string",
+              description: "Who/what you're waiting on (sets status to blocked)"
+            },
+            notes: {
+              type: "string",
+              description: "Additional notes"
+            },
+            recurrence: {
+              type: "string",
+              enum: ["daily", "weekly", "monthly"],
+              description: "Recurrence pattern for repeating tasks"
+            }
+          },
+          required: ["content"]
+        }
+      },
+      {
+        name: "list_todos",
+        description: "List or search todos. Supports semantic search via query parameter, or GTD-style filtering. Returns Linear-style formatted output grouped by status.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            query: {
+              type: "string",
+              description: "Semantic search query - when provided, uses vector similarity to find matching todos instead of listing all"
+            },
+            status: {
+              type: "array",
+              items: { type: "string", enum: ["backlog", "todo", "in_progress", "blocked", "done", "cancelled"] },
+              description: "Filter by status(es)"
+            },
+            project: {
+              type: "string",
+              description: "Filter by project name"
+            },
+            context: {
+              type: "string",
+              description: "Filter by context (e.g., @computer)"
+            },
+            priority: {
+              type: "string",
+              enum: ["urgent", "high", "medium", "low"],
+              description: "Filter by priority"
+            },
+            due: {
+              type: "string",
+              enum: ["today", "overdue", "this_week", "all"],
+              description: "Filter by due date"
+            },
+            limit: {
+              type: "number",
+              description: "Maximum results (default: 50)",
+              default: 50
+            },
+            offset: {
+              type: "number",
+              description: "Skip first N items for pagination (default: 0)",
+              default: 0
+            }
+          }
+        }
+      },
+      {
+        name: "update_todo",
+        description: "Update a todo's properties. Use short ID prefix (e.g., SHO-1a2b) or full ID.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            todo_id: {
+              type: "string",
+              description: "Todo ID or short prefix"
+            },
+            content: {
+              type: "string",
+              description: "New content"
+            },
+            status: {
+              type: "string",
+              enum: ["backlog", "todo", "in_progress", "blocked", "done", "cancelled"],
+              description: "New status"
+            },
+            priority: {
+              type: "string",
+              enum: ["urgent", "high", "medium", "low", "none"],
+              description: "New priority"
+            },
+            project: {
+              type: "string",
+              description: "New project name"
+            },
+            contexts: {
+              type: "array",
+              items: { type: "string" },
+              description: "New contexts"
+            },
+            due_date: {
+              type: "string",
+              description: "New due date"
+            },
+            blocked_on: {
+              type: "string",
+              description: "Who/what you're waiting on"
+            },
+            notes: {
+              type: "string",
+              description: "Additional notes"
+            },
+            tags: {
+              type: "array",
+              items: { type: "string" },
+              description: "New tags"
+            },
+            parent_id: {
+              type: "string",
+              description: "Parent todo ID or short prefix to make this a subtask. Pass empty string to remove parent."
+            }
+          },
+          required: ["todo_id"]
+        }
+      },
+      {
+        name: "complete_todo",
+        description: "Mark a todo as complete. For recurring tasks, automatically creates the next occurrence.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            todo_id: {
+              type: "string",
+              description: "Todo ID or short prefix"
+            }
+          },
+          required: ["todo_id"]
+        }
+      },
+      {
+        name: "delete_todo",
+        description: "Delete a todo permanently.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            todo_id: {
+              type: "string",
+              description: "Todo ID or short prefix"
+            }
+          },
+          required: ["todo_id"]
+        }
+      },
+      {
+        name: "reorder_todo",
+        description: "Move a todo up or down within its status group. Use to prioritize tasks manually.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            todo_id: {
+              type: "string",
+              description: "Todo ID or short prefix"
+            },
+            direction: {
+              type: "string",
+              enum: ["up", "down"],
+              description: "Direction to move the todo"
+            }
+          },
+          required: ["todo_id", "direction"]
+        }
+      },
+      {
+        name: "add_project",
+        description: "Create a new project to group todos. Use parent to create a sub-project under another project.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            name: {
+              type: "string",
+              description: "Project name"
+            },
+            prefix: {
+              type: "string",
+              description: "Custom prefix for todo IDs (e.g., 'BOLT', 'MEM'). Auto-derived from name if not provided."
+            },
+            description: {
+              type: "string",
+              description: "Project description"
+            },
+            parent: {
+              type: "string",
+              description: "Parent project name or ID to create a sub-project"
+            }
+          },
+          required: ["name"]
+        }
+      },
+      {
+        name: "list_projects",
+        description: "List all projects with todo counts and status breakdown.",
+        inputSchema: {
+          type: "object",
+          properties: {}
+        }
+      },
+      {
+        name: "archive_project",
+        description: "Archive a project. Archived projects are hidden by default but can be restored.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            project: {
+              type: "string",
+              description: "Project name or ID to archive"
+            }
+          },
+          required: ["project"]
+        }
+      },
+      {
+        name: "delete_project",
+        description: "Permanently delete a project. Use delete_todos=true to also delete all todos in the project.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            project: {
+              type: "string",
+              description: "Project name or ID to delete"
+            },
+            delete_todos: {
+              type: "boolean",
+              description: "Also delete all todos in this project (default: false)"
+            }
+          },
+          required: ["project"]
+        }
+      },
+      {
+        name: "todo_stats",
+        description: "Get statistics about your todos - counts by status, overdue items, etc.",
+        inputSchema: {
+          type: "object",
+          properties: {}
+        }
+      },
+      {
+        name: "list_subtasks",
+        description: "List subtasks of a parent todo. Use add_todo with parent_id to create subtasks.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            parent_id: {
+              type: "string",
+              description: "Parent todo ID or short prefix"
+            }
+          },
+          required: ["parent_id"]
+        }
+      },
+      {
+        name: "add_todo_comment",
+        description: "Add a comment to a todo. Use to track progress, notes, or resolution details.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            todo_id: {
+              type: "string",
+              description: "Todo ID or short prefix (e.g., 'BOLT-1', 'MEM-2')"
+            },
+            content: {
+              type: "string",
+              description: "Comment content (supports markdown)"
+            },
+            comment_type: {
+              type: "string",
+              enum: ["comment", "progress", "resolution", "activity"],
+              description: "Type of comment: comment (default), progress (updates), resolution (fix details), activity (system)"
+            }
+          },
+          required: ["todo_id", "content"]
+        }
+      },
+      {
+        name: "list_todo_comments",
+        description: "List all comments and activity history for a specific todo.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            todo_id: {
+              type: "string",
+              description: "Todo ID or short prefix (e.g., 'BOLT-1', 'MEM-2')"
+            }
+          },
+          required: ["todo_id"]
+        }
+      },
+      {
+        name: "update_todo_comment",
+        description: "Update an existing comment on a todo.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            todo_id: {
+              type: "string",
+              description: "Todo ID or short prefix"
+            },
+            comment_id: {
+              type: "string",
+              description: "Comment ID (UUID)"
+            },
+            content: {
+              type: "string",
+              description: "New comment content"
+            }
+          },
+          required: ["todo_id", "comment_id", "content"]
+        }
+      },
+      {
+        name: "delete_todo_comment",
+        description: "Delete a comment from a todo.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            todo_id: {
+              type: "string",
+              description: "Todo ID or short prefix"
+            },
+            comment_id: {
+              type: "string",
+              description: "Comment ID (UUID)"
+            }
+          },
+          required: ["todo_id", "comment_id"]
+        }
+      },
+      {
+        name: "read_memory",
+        description: "Read the FULL content of a specific memory by ID. Use this when you need to see the complete text of a memory that was truncated in search results.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            memory_id: {
+              type: "string",
+              description: "The memory ID (full UUID or short prefix like '5581cd02')"
+            }
+          },
+          required: ["memory_id"]
+        }
+      }
+    ]
+  };
+});
+function autoStreamContext(toolName, args) {
+  if (["proactive_context", "streaming_status", "token_status", "reset_token_session"].includes(toolName))
+    return;
+  let context = "";
+  if (args.query && typeof args.query === "string") {
+    context = `Query: ${args.query}`;
+  } else if (args.content && typeof args.content === "string") {
+    context = args.content;
+  } else if (args.context && typeof args.context === "string") {
+    context = args.context;
+  }
+  if (context.length >= 20) {
+    streamMemory(context, ["auto-context", toolName], "user");
+  }
+}
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+  const { name, arguments: args } = request.params;
+  if (STREAM_ENABLED && (!streamSocket || streamSocket.readyState !== WebSocket.OPEN)) {
+    connectStream().catch(() => {});
+  }
+  autoStreamContext(name, args);
+  const serverUp = await isServerAvailable();
+  if (!serverUp) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Memory server unavailable at ${API_URL}. Please ensure shodh-memory-server is running.
+
+To start: cd shodh-memory && cargo run`
+        }
+      ],
+      isError: true
+    };
+  }
+  const executeTool = async () => {
+    switch (name) {
+      case "remember": {
+        const {
+          content,
+          type = "Observation",
+          tags = [],
+          created_at,
+          emotional_valence,
+          emotional_arousal,
+          emotion,
+          source_type,
+          credibility,
+          episode_id,
+          sequence_number,
+          preceding_memory_id
+        } = args;
+        const result = await apiCall("/api/remember", "POST", {
+          user_id: USER_ID,
+          content,
+          memory_type: type,
+          tags,
+          ...created_at && { created_at },
+          ...emotional_valence !== undefined && { emotional_valence },
+          ...emotional_arousal !== undefined && { emotional_arousal },
+          ...emotion && { emotion },
+          ...source_type && { source_type },
+          ...credibility !== undefined && { credibility },
+          ...episode_id && { episode_id },
+          ...sequence_number !== undefined && { sequence_number },
+          ...preceding_memory_id && { preceding_memory_id }
+        });
+        let response = `\uD83D\uDC18 Memory Stored
+`;
+        response += `━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+`;
+        response += `\uD83D\uDCDD ${content.slice(0, 60)}${content.length > 60 ? "..." : ""}
+`;
+        response += `━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+`;
+        response += `Type: ${type}`;
+        if (tags.length > 0) {
+          response += ` │ Tags: ${tags.join(", ")}`;
+        }
+        response += `
+ID: ${result.id.slice(0, 8)}...`;
+        return {
+          content: [{ type: "text", text: response }]
+        };
+      }
+      case "recall": {
+        const { query, limit = 5, mode = "hybrid" } = args;
+        const result = await apiCall("/api/recall", "POST", {
+          user_id: USER_ID,
+          query,
+          limit,
+          mode
+        });
+        const memories = result.memories || [];
+        const todos = result.todos || [];
+        const stats = result.retrieval_stats;
+        if (memories.length === 0 && todos.length === 0) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: `\uD83D\uDC18 No memories or todos found for: "${query}"
+   Mode: ${mode}`
+              }
+            ]
+          };
+        }
+        const totalCount = memories.length + todos.length;
+        let response = `\uD83D\uDC18 Recalled ${totalCount} Results`;
+        if (memories.length > 0 && todos.length > 0) {
+          response += ` (${memories.length} memories, ${todos.length} todos)`;
+        }
+        response += `
+`;
+        response += `━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+`;
+        response += `Query: "${query.slice(0, 40)}${query.length > 40 ? "..." : ""}" │ Mode: ${mode}
+`;
+        response += `━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+`;
+        const formatTime = (ts) => {
+          if (!ts)
+            return "";
+          const d = new Date(ts);
+          const now = new Date;
+          const diffMs = now.getTime() - d.getTime();
+          const diffDays = Math.floor(diffMs / (1000 * 60 * 60 * 24));
+          if (diffDays === 0) {
+            return d.toLocaleTimeString([], { hour: "2-digit", minute: "2-digit" });
+          } else if (diffDays === 1) {
+            return "Yesterday";
+          } else if (diffDays < 7) {
+            return `${diffDays}d ago`;
+          } else {
+            return d.toLocaleDateString([], { month: "short", day: "numeric" });
+          }
+        };
+        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 matchBar = "█".repeat(filled) + "░".repeat(10 - filled);
+            const timeStr = formatTime(m.created_at);
+            response += `• ${matchBar} ${score}% │ ${timeStr}
+`;
+            response += `  ${content.slice(0, 200)}${content.length > 200 ? "..." : ""}
+`;
+            response += `  ┗━ ${getType(m)} │ ${m.id.slice(0, 8)}...
+`;
+            if (i < memories.length - 1)
+              response += `
+`;
+          }
+        }
+        if (todos.length > 0) {
+          if (memories.length > 0)
+            response += `
+`;
+          response += `✅ TODOS
+`;
+          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 matchBar = "█".repeat(filled) + "░".repeat(10 - filled);
+            const statusIcon = t.status === "done" ? "✓" : t.status === "in_progress" ? "▶" : t.status === "blocked" ? "⊗" : "○";
+            const timeStr = formatTime(t.created_at);
+            response += `• ${matchBar} ${score}% │ ${timeStr}
+`;
+            response += `  ${statusIcon} ${t.content.slice(0, 180)}${t.content.length > 180 ? "..." : ""}
+`;
+            response += `  ┗━ ${t.short_id} │ ${t.status} │ ${t.priority}`;
+            if (t.project)
+              response += ` │ ${t.project}`;
+            response += `
+`;
+            if (i < todos.length - 1)
+              response += `
+`;
+          }
+        }
+        if (stats && (mode === "associative" || mode === "hybrid")) {
+          response += `
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+`;
+          response += `\uD83D\uDCCA Retrieval Stats
+`;
+          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 += `   Candidates: ${stats.graph_candidates} graph + ${stats.semantic_candidates} semantic
+`;
+          response += `   Entities: ${stats.entities_activated} │ Time: ${(stats.retrieval_time_us / 1000).toFixed(1)}ms`;
+        }
+        return {
+          content: [{ type: "text", text: response }]
+        };
+      }
+      case "context_summary": {
+        const {
+          include_decisions = true,
+          include_learnings = true,
+          include_context = true,
+          max_items = 5
+        } = args;
+        const result = await apiCall("/api/memories", "POST", {
+          user_id: USER_ID
+        });
+        const memories = result.memories || [];
         if (memories.length === 0) {
+          let response2 = `\uD83D\uDC18 Context Summary
+`;
+          response2 += `━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+`;
+          response2 += `No memories stored yet.
+`;
+          response2 += `Start remembering to build context!`;
           return {
-            content: [
-              {
-                type: "text",
-                text: "No memories stored yet."
-              }
-            ]
+            content: [{ type: "text", text: response2 }]
           };
         }
-        const formatted = memories.map((m, i) => {
-          const content = getContent(m);
-          return `${i + 1}. ${content.slice(0, 80)}${content.length > 80 ? "..." : ""}
-   Type: ${getType(m)} | ID: ${m.id.slice(0, 8)}...`;
-        }).join(`
+        const decisions = [];
+        const learnings = [];
+        const context = [];
+        const patterns = [];
+        const errors2 = [];
+        for (const m of memories) {
+          const type = getType(m);
+          switch (type) {
+            case "Decision":
+              decisions.push(m);
+              break;
+            case "Learning":
+              learnings.push(m);
+              break;
+            case "Context":
+              context.push(m);
+              break;
+            case "Pattern":
+              patterns.push(m);
+              break;
+            case "Error":
+              errors2.push(m);
+              break;
+          }
+        }
+        let response = `\uD83D\uDC18 Context Summary
+`;
+        response += `━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+`;
+        response += `Total: ${memories.length} memories │ `;
+        response += `\uD83D\uDCCB ${decisions.length} │ \uD83D\uDCA1 ${learnings.length} │ \uD83D\uDCC1 ${context.length} │ \uD83D\uDD04 ${patterns.length} │ ⚠️ ${errors2.length}
+`;
+        response += `━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
-`);
+`;
+        if (include_context && context.length > 0) {
+          response += `\uD83D\uDCC1 PROJECT CONTEXT
+`;
+          for (const m of context.slice(0, max_items)) {
+            response += `   • ${getContent(m).slice(0, 70)}${getContent(m).length > 70 ? "..." : ""}
+`;
+          }
+          response += `
+`;
+        }
+        if (include_decisions && decisions.length > 0) {
+          response += `\uD83D\uDCCB DECISIONS
+`;
+          for (const m of decisions.slice(0, max_items)) {
+            response += `   • ${getContent(m).slice(0, 70)}${getContent(m).length > 70 ? "..." : ""}
+`;
+          }
+          response += `
+`;
+        }
+        if (include_learnings && learnings.length > 0) {
+          response += `\uD83D\uDCA1 LEARNINGS
+`;
+          for (const m of learnings.slice(0, max_items)) {
+            response += `   • ${getContent(m).slice(0, 70)}${getContent(m).length > 70 ? "..." : ""}
+`;
+          }
+          response += `
+`;
+        }
+        if (patterns.length > 0) {
+          response += `\uD83D\uDD04 PATTERNS
+`;
+          for (const m of patterns.slice(0, max_items)) {
+            response += `   • ${getContent(m).slice(0, 70)}${getContent(m).length > 70 ? "..." : ""}
+`;
+          }
+          response += `
+`;
+        }
+        if (errors2.length > 0) {
+          response += `⚠️ ERRORS TO AVOID
+`;
+          for (const m of errors2.slice(0, Math.min(3, max_items))) {
+            response += `   • ${getContent(m).slice(0, 70)}${getContent(m).length > 70 ? "..." : ""}
+`;
+          }
+        }
+        if (decisions.length === 0 && learnings.length === 0 && context.length === 0) {
+          response += `ℹ️  Tip: Use types like Decision, Learning, Context when remembering
+`;
+          response += `   to build richer context summaries.`;
+        }
         return {
-          content: [
-            {
-              type: "text",
-              text: `${memories.length} memories:
+          content: [{ type: "text", text: response.trimEnd() }]
+        };
+      }
+      case "list_memories": {
+        const { limit = 20 } = args;
+        const result = await apiCall("/api/memories", "POST", {
+          user_id: USER_ID
+        });
+        const memories = (result.memories || []).slice(0, limit);
+        if (memories.length === 0) {
+          let response2 = `\uD83D\uDC18 Memory List
+`;
+          response2 += `━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+`;
+          response2 += `No memories stored yet.`;
+          return {
+            content: [{ type: "text", text: response2 }]
+          };
+        }
+        const typeCounts = {};
+        for (const m of memories) {
+          const type = getType(m);
+          typeCounts[type] = (typeCounts[type] || 0) + 1;
+        }
+        let response = `\uD83D\uDC18 Memory List
+`;
+        response += `━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+`;
+        response += `Showing ${memories.length} memories
+`;
+        response += `Types: ${Object.entries(typeCounts).map(([t, c]) => `${t}(${c})`).join(" │ ")}
+`;
+        response += `━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
-${formatted}`
-            }
-          ]
+`;
+        for (let i = 0;i < memories.length; i++) {
+          const m = memories[i];
+          const content = getContent(m);
+          const typeIcon = {
+            Decision: "\uD83D\uDCCB",
+            Learning: "\uD83D\uDCA1",
+            Context: "\uD83D\uDCC1",
+            Pattern: "\uD83D\uDD04",
+            Error: "⚠️",
+            Observation: "\uD83D\uDC41️",
+            Discovery: "\uD83D\uDD0D",
+            Task: "✅",
+            CodeEdit: "\uD83D\uDCDD",
+            FileAccess: "\uD83D\uDCC4",
+            Search: "\uD83D\uDD0E",
+            Command: "⚡",
+            Conversation: "\uD83D\uDCAC"
+          }[getType(m)] || "\uD83D\uDCE6";
+          response += `${String(i + 1).padStart(2)}. ${typeIcon} ${content.slice(0, 150)}${content.length > 150 ? "..." : ""}
+`;
+          response += `    ┗━ ${getType(m)} │ ${m.id.slice(0, 8)}...
+`;
+        }
+        return {
+          content: [{ type: "text", text: response.trimEnd() }]
         };
       }
       case "forget": {
         const { id } = args;
         await apiCall(`/api/memory/${id}?user_id=${USER_ID}`, "DELETE");
+        let response = `\uD83D\uDC18 Memory Deleted
+`;
+        response += `━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+`;
+        response += `✓ Removed: ${id.slice(0, 8)}...`;
         return {
-          content: [
-            {
-              type: "text",
-              text: `Deleted memory: ${id}`
-            }
-          ]
+          content: [{ type: "text", text: response }]
         };
       }
       case "memory_stats": {
         const result = await apiCall(`/api/users/${USER_ID}/stats`, "GET");
+        const indexedCount = result.vector_index_count ?? result.indexed_vectors ?? 0;
+        const avgImportance = result.average_importance ?? result.avg_importance ?? 0;
+        let response = `\uD83D\uDC18 Memory Statistics
+`;
+        response += `━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+`;
+        response += `Total Memories: ${result.total_memories || 0}
+`;
+        response += `Graph: ${result.graph_nodes || 0} nodes │ ${result.graph_edges || 0} edges
+`;
+        response += `Indexed Vectors: ${indexedCount}
+`;
+        response += `Avg Importance: ${avgImportance.toFixed(2)}
+`;
+        response += `━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+`;
+        if (result.memory_types && Object.keys(result.memory_types).length > 0) {
+          response += `
+By Type:
+`;
+          const typeIcons = {
+            Decision: "\uD83D\uDCCB",
+            Learning: "\uD83D\uDCA1",
+            Context: "\uD83D\uDCC1",
+            Pattern: "\uD83D\uDD04",
+            Error: "⚠️",
+            Observation: "\uD83D\uDC41️",
+            Discovery: "\uD83D\uDD0D",
+            Task: "✅",
+            CodeEdit: "\uD83D\uDCDD",
+            FileAccess: "\uD83D\uDCC4",
+            Search: "\uD83D\uDD0E",
+            Command: "⚡",
+            Conversation: "\uD83D\uDCAC"
+          };
+          for (const [type, count] of Object.entries(result.memory_types)) {
+            const icon = typeIcons[type] || "\uD83D\uDCE6";
+            const bar = "█".repeat(Math.min(20, Math.round(count / (result.total_memories || 1) * 20)));
+            response += `   ${icon} ${type.padEnd(12)} ${bar} ${count}
+`;
+          }
+        }
         return {
-          content: [
-            {
-              type: "text",
-              text: `Memory Statistics:
-${JSON.stringify(result, null, 2)}`
-            }
-          ]
+          content: [{ type: "text", text: response.trimEnd() }]
         };
       }
       case "verify_index": {
         const result = await apiCall("/api/index/verify", "POST", {
           user_id: USER_ID
         });
-        const statusIcon = result.is_healthy ? "✓" : "⚠";
-        const healthText = result.is_healthy ? "Healthy" : "Unhealthy - orphaned memories detected";
-        let response = `Index Integrity Report
+        const statusIcon = result.is_healthy ? "✓" : "⚠️";
+        const healthText = result.is_healthy ? "HEALTHY" : "UNHEALTHY";
+        let response = `\uD83D\uDC18 Index Verification
 `;
-        response += `━━━━━━━━━━━━━━━━━━━━━━━━━
+        response += `━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 `;
-        response += `Status: ${statusIcon} ${healthText}
+        response += `${statusIcon} ${healthText}
 `;
-        response += `Total in storage: ${result.total_storage}
+        response += `━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 `;
-        response += `Total indexed: ${result.total_indexed}
+        response += `Storage: ${result.total_storage} memories
 `;
-        response += `Orphaned count: ${result.orphaned_count}
+        response += `Indexed: ${result.total_indexed} vectors
+`;
+        response += `Orphaned: ${result.orphaned_count}
 `;
         if (result.orphaned_count > 0) {
-          response += `
-Recommendation: Run repair_index to fix orphaned memories.`;
+          response += `━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+`;
+          response += `⚠️ Run repair_index to fix orphaned memories`;
         }
         return {
-          content: [
-            {
-              type: "text",
-              text: response
-            }
-          ]
+          content: [{ type: "text", text: response }]
         };
       }
       case "repair_index": {
         const result = await apiCall("/api/index/repair", "POST", {
           user_id: USER_ID
         });
-        const statusIcon = result.is_healthy ? "✓" : "⚠";
-        let response = `Index Repair Results
+        const statusIcon = result.is_healthy ? "✓" : "⚠️";
+        const statusText = result.success ? "SUCCESS" : "PARTIAL";
+        let response = `\uD83D\uDC18 Index Repair
 `;
-        response += `━━━━━━━━━━━━━━━━━━━━━
+        response += `━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 `;
-        response += `Status: ${statusIcon} ${result.success ? "Success" : "Partial success"}
+        response += `${statusIcon} ${statusText}
 `;
-        response += `Total in storage: ${result.total_storage}
+        response += `━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 `;
-        response += `Total indexed: ${result.total_indexed}
+        response += `Storage: ${result.total_storage} memories
+`;
+        response += `Indexed: ${result.total_indexed} vectors
 `;
         response += `Repaired: ${result.repaired}
 `;
         response += `Failed: ${result.failed}
-`;
-        response += `Index healthy: ${result.is_healthy ? "Yes" : "No"}
 `;
         if (result.failed > 0) {
-          response += `
-Note: ${result.failed} memories could not be repaired (embedding generation failed).`;
+          response += `━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+`;
+          response += `⚠️ ${result.failed} could not be repaired`;
         }
         return {
-          content: [
-            {
-              type: "text",
-              text: response
-            }
-          ]
+          content: [{ type: "text", text: response }]
         };
       }
-      case "recall_by_tags": {
-        const { tags, limit = 20 } = args;
-        const result = await apiCall("/api/recall/tags", "POST", {
-          user_id: USER_ID,
-          tags,
-          limit
+      case "backup_create": {
+        const result = await apiCall("/api/backup/create", "POST", {
+          user_id: USER_ID
         });
-        const memories = result.memories || [];
-        if (memories.length === 0) {
-          return {
-            content: [
-              {
-                type: "text",
-                text: `No memories found with tags: ${tags.join(", ")}`
-              }
-            ]
-          };
+        let response = `\uD83D\uDC18 Backup Created
+`;
+        response += `━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+`;
+        if (result.success && result.backup) {
+          const b = result.backup;
+          const sizeMB = (b.size_bytes / (1024 * 1024)).toFixed(2);
+          response += `✓ Backup ID: ${b.backup_id}
+`;
+          response += `━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+`;
+          response += `Type: ${b.backup_type}
+`;
+          response += `Memories: ${b.memory_count}
+`;
+          response += `Size: ${sizeMB} MB
+`;
+          response += `Checksum: ${b.checksum.slice(0, 16)}...
+`;
+          response += `Created: ${new Date(b.created_at).toLocaleString()}
+`;
+        } else {
+          response += `✗ Failed: ${result.message}
+`;
         }
-        const formatted = memories.map((m, i) => {
-          const content = getContent(m);
-          return `${i + 1}. ${content.slice(0, 80)}${content.length > 80 ? "..." : ""}
-   Type: ${getType(m)} | ID: ${m.id.slice(0, 8)}...`;
-        }).join(`
-
-`);
         return {
-          content: [
-            {
-              type: "text",
-              text: `Found ${memories.length} memories with tags [${tags.join(", ")}]:
-
-${formatted}`
-            }
-          ]
+          content: [{ type: "text", text: response }]
         };
       }
-      case "recall_by_date": {
-        const { start, end, limit = 20 } = args;
-        const result = await apiCall("/api/recall/date", "POST", {
-          user_id: USER_ID,
-          start,
-          end,
-          limit
+      case "backup_list": {
+        const result = await apiCall("/api/backups", "POST", {
+          user_id: USER_ID
         });
-        const memories = result.memories || [];
-        if (memories.length === 0) {
-          return {
-            content: [
-              {
-                type: "text",
-                text: `No memories found between ${start} and ${end}`
-              }
-            ]
-          };
-        }
-        const formatted = memories.map((m, i) => {
-          const content = getContent(m);
-          return `${i + 1}. ${content.slice(0, 80)}${content.length > 80 ? "..." : ""}
-   Type: ${getType(m)} | Created: ${m.created_at || "unknown"}`;
-        }).join(`
+        let response = `\uD83D\uDC18 Available Backups
+`;
+        response += `━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+`;
+        if (result.backups.length === 0) {
+          response += `No backups available.
+`;
+          response += `Use backup_create to create your first backup.`;
+        } else {
+          response += `Found: ${result.count} backup(s)
+`;
+          response += `━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
-`);
-        return {
-          content: [
-            {
-              type: "text",
-              text: `Found ${memories.length} memories between ${start} and ${end}:
+`;
+          for (const b of result.backups) {
+            const sizeMB = (b.size_bytes / (1024 * 1024)).toFixed(2);
+            const date = new Date(b.created_at).toLocaleString();
+            response += `\uD83D\uDCE6 Backup #${b.backup_id}
+`;
+            response += `   Type: ${b.backup_type} │ Memories: ${b.memory_count} │ Size: ${sizeMB} MB
+`;
+            response += `   Created: ${date}
 
-${formatted}`
-            }
-          ]
+`;
+          }
+        }
+        return {
+          content: [{ type: "text", text: response.trimEnd() }]
         };
       }
-      case "forget_by_tags": {
-        const { tags } = args;
-        const result = await apiCall("/api/forget/tags", "POST", {
+      case "backup_verify": {
+        const { backup_id } = args;
+        const result = await apiCall("/api/backup/verify", "POST", {
           user_id: USER_ID,
-          tags
+          backup_id
         });
+        const statusIcon = result.is_valid ? "✓" : "✗";
+        const statusText = result.is_valid ? "VALID" : "INVALID";
+        let response = `\uD83D\uDC18 Backup Verification
+`;
+        response += `━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+`;
+        response += `${statusIcon} Backup #${backup_id}: ${statusText}
+`;
+        response += `━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+`;
+        response += result.message;
         return {
-          content: [
-            {
-              type: "text",
-              text: `Deleted ${result.deleted_count} memories with tags: ${tags.join(", ")}`
-            }
-          ]
+          content: [{ type: "text", text: response }]
         };
       }
-      case "forget_by_date": {
-        const { start, end } = args;
-        const result = await apiCall("/api/forget/date", "POST", {
+      case "backup_purge": {
+        const { keep_count = 7 } = args;
+        const result = await apiCall("/api/backups/purge", "POST", {
           user_id: USER_ID,
-          start,
-          end
+          keep_count
         });
+        let response = `\uD83D\uDC18 Backup Purge
+`;
+        response += `━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+`;
+        if (result.purged_count === 0) {
+          response += `No backups purged (keeping ${keep_count}, none exceeded limit)`;
+        } else {
+          response += `✓ Purged ${result.purged_count} old backup(s)
+`;
+          response += `Kept ${keep_count} most recent backup(s)`;
+        }
         return {
-          content: [
-            {
-              type: "text",
-              text: `Deleted ${result.deleted_count} memories between ${start} and ${end}`
-            }
-          ]
+          content: [{ type: "text", text: response }]
         };
       }
       case "proactive_context": {
@@ -5948,132 +6567,601 @@ ${entityList}
             ]
           };
         }
-        const formatted = memories.map((m, i) => {
+        const entitySummary = entities.length > 0 ? `
+
+Detected entities: ${entities.map((e) => `"${e.text}" (${e.entity_type})`).join(", ")}` : "";
+        let reminderBlock = "";
+        try {
+          const dueResult = await apiCall("/api/reminders/due", "POST", {
+            user_id: USER_ID,
+            mark_triggered: false
+          });
+          const contextResult = await apiCall("/api/reminders/context", "POST", {
+            user_id: USER_ID,
+            context,
+            mark_triggered: false
+          });
+          const allReminders = [...dueResult.reminders, ...contextResult.reminders];
+          const uniqueReminders = allReminders.filter((r, i, arr) => arr.findIndex((x) => x.id === r.id) === i);
+          if (uniqueReminders.length > 0) {
+            reminderBlock = `
+
+`;
+            reminderBlock += `\uD83D\uDC18━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\uD83E\uDDE0
+`;
+            reminderBlock += `┃  SHODH MEMORY                    REMINDERS (${String(uniqueReminders.length).padStart(2)})  ┃
+`;
+            reminderBlock += `┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫
+`;
+            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)}] ┃
+`;
+              if (r.overdue_seconds && r.overdue_seconds > 0) {
+                const mins = Math.round(r.overdue_seconds / 60);
+                const overdueText = mins > 60 ? `⚠️  OVERDUE by ${Math.round(mins / 60)}h ${mins % 60}m` : `⚠️  OVERDUE by ${mins}m`;
+                reminderBlock += `┃     ${overdueText.padEnd(47)} ┃
+`;
+              } else if (r.due_at) {
+                const dueText = `Due: ${new Date(r.due_at).toLocaleString()}`;
+                reminderBlock += `┃     ${dueText.padEnd(47)} ┃
+`;
+              }
+            }
+            reminderBlock += `┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
+`;
+            reminderBlock += `
+\uD83D\uDCA1 Use dismiss_reminder with the [id] shown above`;
+          }
+        } catch (e) {
+          console.error("[proactive_context] Reminder check failed:", e);
+        }
+        let todoBlock = "";
+        try {
+          const dueTodosResult = await apiCall("/api/todos/due", "POST", {
+            user_id: USER_ID
+          });
+          if (dueTodosResult.count > 0) {
+            todoBlock = `
+
+` + dueTodosResult.formatted;
+          }
+        } catch (e) {
+          console.error("[proactive_context] Todo check failed:", e);
+        }
+        const now = new Date;
+        const dayNames = ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"];
+        const monthNames = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];
+        const temporalHeader = `\uD83D\uDCC5 ${dayNames[now.getDay()]}, ${monthNames[now.getMonth()]} ${now.getDate()}, ${now.getFullYear()} at ${now.toLocaleTimeString([], { hour: "2-digit", minute: "2-digit" })}
+
+`;
+        const formattedWithTime = memories.map((m, i) => {
           const score = (m.relevance_score * 100).toFixed(0);
           const entityMatchStr = m.matched_entities && m.matched_entities.length > 0 ? `
    Entity matches: ${m.matched_entities.join(", ")}` : "";
           const semScore = (m.semantic_similarity * 100).toFixed(0);
-          return `${i + 1}. [${score}% relevant] ${m.content.slice(0, 100)}${m.content.length > 100 ? "..." : ""}
+          let timeStr = "";
+          if (m.created_at) {
+            const d = new Date(m.created_at);
+            const diffMs = now.getTime() - d.getTime();
+            const diffDays = Math.floor(diffMs / (1000 * 60 * 60 * 24));
+            if (diffDays === 0) {
+              timeStr = ` (today at ${d.toLocaleTimeString([], { hour: "2-digit", minute: "2-digit" })})`;
+            } else if (diffDays === 1) {
+              timeStr = ` (yesterday)`;
+            } else if (diffDays < 7) {
+              timeStr = ` (${diffDays}d ago)`;
+            } else {
+              timeStr = ` (${d.toLocaleDateString([], { month: "short", day: "numeric" })})`;
+            }
+          }
+          return `• [${score}%]${timeStr} ${m.content.slice(0, 100)}${m.content.length > 100 ? "..." : ""}
    Type: ${m.memory_type} | semantic=${semScore}% | reason: ${m.relevance_reason}${entityMatchStr}`;
         }).join(`
 
 `);
-        const entitySummary = entities.length > 0 ? `
+        return {
+          content: [
+            {
+              type: "text",
+              text: `${temporalHeader}Surfaced ${memories.length} relevant memories:
 
-Detected entities: ${entities.map((e) => `"${e.text}" (${e.entity_type})`).join(", ")}` : "";
+${formattedWithTime}${entitySummary}${reminderBlock}${todoBlock}
+
+[Latency: ${result.latency_ms.toFixed(1)}ms | Threshold: ${(semantic_threshold * 100).toFixed(0)}%]`
+            }
+          ]
+        };
+      }
+      case "token_status": {
+        const status = getTokenStatus();
+        const sessionDuration = Math.round((Date.now() - sessionStartTime) / 1000 / 60);
+        const remaining = status.budget - status.tokens;
+        const percentUsed = Math.round(status.percent * 100);
+        const barLength = 20;
+        const filledLength = Math.round(percentUsed / 100 * barLength);
+        const bar = "█".repeat(filledLength) + "░".repeat(barLength - filledLength);
+        let response = `\uD83D\uDC18 Token Status
+`;
+        response += `━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+`;
+        response += `${bar} ${percentUsed}%
+`;
+        response += `━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+`;
+        response += `Used: ${status.tokens.toLocaleString()} tokens
+`;
+        response += `Budget: ${status.budget.toLocaleString()} tokens
+`;
+        response += `Remaining: ${remaining.toLocaleString()} tokens
+`;
+        response += `Session: ${sessionDuration} min
+`;
+        response += `━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+`;
+        response += status.alert ? `⚠️ ALERT: ${percentUsed}% used - Consider new session` : `✓ Context window healthy`;
+        return {
+          content: [{ type: "text", text: response }]
+        };
+      }
+      case "reset_token_session": {
+        const previousTokens = sessionTokens;
+        resetTokenSession();
+        let response = `\uD83D\uDC18 Token Session Reset
+`;
+        response += `━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+`;
+        response += `Previous: ${previousTokens.toLocaleString()} tokens
+`;
+        response += `Current: 0 tokens
+`;
+        response += `Budget: ${TOKEN_BUDGET.toLocaleString()} tokens
+`;
+        response += `━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+`;
+        response += `✓ Counter cleared`;
+        return {
+          content: [{ type: "text", text: response }]
+        };
+      }
+      case "consolidation_report": {
+        const { since, until } = args;
+        const result = await apiCall("/api/consolidation/report", "POST", {
+          user_id: USER_ID,
+          since,
+          until
+        });
+        const stats = result.statistics;
+        const eventCount = result.strengthened_memories.length + result.decayed_memories.length + result.formed_associations.length + result.strengthened_associations.length + result.potentiated_associations.length + result.pruned_associations.length + result.extracted_facts.length + result.reinforced_facts.length;
+        const startDate = new Date(result.period.start).toLocaleString();
+        const endDate = new Date(result.period.end).toLocaleString();
+        let response = `\uD83D\uDC18 Consolidation Report
+`;
+        response += `━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+`;
+        response += `Period: ${startDate} → ${endDate}
+`;
+        response += `Events: ${eventCount} │ Memories: ${stats.total_memories}
+`;
+        response += `━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+`;
+        if (stats.memories_strengthened > 0 || stats.memories_decayed > 0 || stats.memories_at_risk > 0) {
+          response += `\uD83E\uDDE0 MEMORY DYNAMICS
+`;
+          if (stats.memories_strengthened > 0)
+            response += `   ↑ ${stats.memories_strengthened} strengthened
+`;
+          if (stats.memories_decayed > 0)
+            response += `   ↓ ${stats.memories_decayed} decayed
+`;
+          if (stats.memories_at_risk > 0)
+            response += `   ⚠️ ${stats.memories_at_risk} at risk
+`;
+          response += `
+`;
+        }
+        if (stats.edges_formed > 0 || stats.edges_strengthened > 0 || stats.edges_potentiated > 0 || stats.edges_pruned > 0) {
+          response += `\uD83D\uDD17 ASSOCIATIONS (Hebbian)
+`;
+          if (stats.edges_formed > 0)
+            response += `   + ${stats.edges_formed} formed
+`;
+          if (stats.edges_strengthened > 0)
+            response += `   ↑ ${stats.edges_strengthened} strengthened
+`;
+          if (stats.edges_potentiated > 0)
+            response += `   ★ ${stats.edges_potentiated} permanent (LTP)
+`;
+          if (stats.edges_pruned > 0)
+            response += `   ✂ ${stats.edges_pruned} pruned
+`;
+          response += `
+`;
+        }
+        if (stats.facts_extracted > 0 || stats.facts_reinforced > 0) {
+          response += `\uD83D\uDCDA FACTS
+`;
+          if (stats.facts_extracted > 0)
+            response += `   + ${stats.facts_extracted} extracted
+`;
+          if (stats.facts_reinforced > 0)
+            response += `   ↑ ${stats.facts_reinforced} reinforced
+`;
+          response += `
+`;
+        }
+        if (stats.maintenance_cycles > 0) {
+          const durationSec = (stats.total_maintenance_duration_ms / 1000).toFixed(2);
+          response += `⚙️ MAINTENANCE: ${stats.maintenance_cycles} cycles (${durationSec}s)
+`;
+        }
+        if (eventCount === 0) {
+          response += `ℹ️ No consolidation activity in this period.
+`;
+          response += `   Store and access memories to trigger learning.`;
+        }
+        return {
+          content: [{ type: "text", text: response.trimEnd() }]
+        };
+      }
+      case "set_reminder": {
+        const { content, trigger_type, trigger_at, after_seconds, keywords, priority = 3, tags = [] } = args;
+        let trigger;
+        switch (trigger_type) {
+          case "time":
+            if (!trigger_at) {
+              return {
+                content: [{ type: "text", text: "Error: 'trigger_at' is required for time-based reminders" }],
+                isError: true
+              };
+            }
+            trigger = { type: "time", at: trigger_at };
+            break;
+          case "duration":
+            if (!after_seconds || after_seconds <= 0) {
+              return {
+                content: [{ type: "text", text: "Error: 'after_seconds' must be positive for duration-based reminders" }],
+                isError: true
+              };
+            }
+            trigger = { type: "duration", after_seconds };
+            break;
+          case "context":
+            if (!keywords || keywords.length === 0) {
+              return {
+                content: [{ type: "text", text: "Error: 'keywords' is required for context-based reminders" }],
+                isError: true
+              };
+            }
+            trigger = { type: "context", keywords, threshold: 0.7 };
+            break;
+          default:
+            return {
+              content: [{ type: "text", text: `Error: Invalid trigger_type: ${trigger_type}` }],
+              isError: true
+            };
+        }
+        const result = await apiCall("/api/remind", "POST", {
+          user_id: USER_ID,
+          content,
+          trigger,
+          priority,
+          tags
+        });
+        let response = `\uD83D\uDC18 Reminder Set
+`;
+        response += `━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+`;
+        response += `ID: ${result.id.slice(0, 8)}...
+`;
+        response += `Content: ${content}
+`;
+        response += `Trigger: ${trigger_type}`;
+        if (trigger_type === "time" && result.due_at) {
+          response += ` (${new Date(result.due_at).toLocaleString()})`;
+        } else if (trigger_type === "duration" && after_seconds) {
+          const mins = Math.round(after_seconds / 60);
+          response += ` (in ${mins > 60 ? Math.round(mins / 60) + "h" : mins + "m"})`;
+        } else if (trigger_type === "context" && keywords) {
+          response += ` (keywords: ${keywords.join(", ")})`;
+        }
+        response += `
+`;
+        if (priority !== 3) {
+          response += `Priority: ${"★".repeat(priority)}${"☆".repeat(5 - priority)}
+`;
+        }
+        return {
+          content: [{ type: "text", text: response }]
+        };
+      }
+      case "list_reminders": {
+        const { status = "pending" } = args;
+        const result = await apiCall("/api/reminders", "POST", {
+          user_id: USER_ID,
+          status: status === "all" ? null : status
+        });
+        if (result.count === 0) {
+          return {
+            content: [{ type: "text", text: `No ${status === "all" ? "" : status + " "}reminders found.` }]
+          };
+        }
+        let response = `\uD83D\uDC18 SHODH REMINDERS (${result.count})
+`;
+        response += `━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+`;
+        for (const r of result.reminders) {
+          const icon = r.overdue_seconds && r.overdue_seconds > 0 ? "⏰" : "\uD83D\uDCCC";
+          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)}...
+`;
+          if (r.due_at) {
+            response += `   Due: ${new Date(r.due_at).toLocaleString()}
+`;
+          }
+          if (r.overdue_seconds && r.overdue_seconds > 0) {
+            const mins = Math.round(r.overdue_seconds / 60);
+            response += `   ⚠️ Overdue by ${mins > 60 ? Math.round(mins / 60) + "h" : mins + "m"}
+`;
+          }
+          response += `
+`;
+        }
+        return {
+          content: [{ type: "text", text: response }]
+        };
+      }
+      case "dismiss_reminder": {
+        const { reminder_id } = args;
+        const result = await apiCall(`/api/reminders/${reminder_id}/dismiss`, "POST", {
+          user_id: USER_ID
+        });
+        return {
+          content: [
+            {
+              type: "text",
+              text: result.success ? `✓ Reminder dismissed: ${reminder_id.slice(0, 8)}...` : `⚠️ ${result.message}`
+            }
+          ]
+        };
+      }
+      case "add_todo": {
+        const {
+          content: todoContent,
+          status = "todo",
+          priority = "medium",
+          project,
+          contexts = [],
+          due_date,
+          tags = [],
+          blocked_on,
+          notes,
+          recurrence
+        } = args;
+        const result = await apiCall("/api/todos/add", "POST", {
+          user_id: USER_ID,
+          content: todoContent,
+          status,
+          priority,
+          project,
+          contexts,
+          due_date,
+          tags,
+          blocked_on,
+          notes,
+          recurrence
+        });
+        return {
+          content: [{ type: "text", text: result.formatted }]
+        };
+      }
+      case "list_todos": {
+        const {
+          query,
+          status: statusFilter,
+          project,
+          context,
+          priority,
+          due,
+          limit = 50,
+          offset = 0
+        } = args;
+        const result = await apiCall("/api/todos/list", "POST", {
+          user_id: USER_ID,
+          query,
+          status: statusFilter,
+          project,
+          context,
+          priority,
+          due,
+          limit,
+          offset
+        });
+        return {
+          content: [{ type: "text", text: result.formatted }]
+        };
+      }
+      case "update_todo": {
+        const {
+          todo_id,
+          content: newContent,
+          status,
+          priority,
+          project,
+          contexts,
+          due_date,
+          blocked_on,
+          notes,
+          tags,
+          parent_id
+        } = args;
+        const result = await apiCall(`/api/todos/${todo_id}/update`, "POST", {
+          user_id: USER_ID,
+          content: newContent,
+          status,
+          priority,
+          project,
+          contexts,
+          due_date,
+          blocked_on,
+          notes,
+          tags,
+          parent_id
+        });
+        return {
+          content: [{ type: "text", text: result.formatted }]
+        };
+      }
+      case "complete_todo": {
+        const { todo_id } = args;
+        const result = await apiCall(`/api/todos/${todo_id}/complete`, "POST", {
+          user_id: USER_ID
+        });
+        return {
+          content: [{ type: "text", text: result.formatted }]
+        };
+      }
+      case "delete_todo": {
+        const { todo_id } = args;
+        const result = await apiCall(`/api/todos/${todo_id}?user_id=${USER_ID}`, "DELETE");
+        return {
+          content: [{ type: "text", text: result.formatted }]
+        };
+      }
+      case "reorder_todo": {
+        const { todo_id, direction } = args;
+        const result = await apiCall(`/api/todos/${todo_id}/reorder`, "POST", {
+          user_id: USER_ID,
+          direction
+        });
+        return {
+          content: [{ type: "text", text: result.formatted }]
+        };
+      }
+      case "add_project": {
+        const { name: name2, prefix, description, parent } = args;
+        const result = await apiCall("/api/projects", "POST", {
+          user_id: USER_ID,
+          name: name2,
+          prefix,
+          description,
+          parent
+        });
+        return {
+          content: [{ type: "text", text: result.formatted }]
+        };
+      }
+      case "list_projects": {
+        const result = await apiCall("/api/projects/list", "POST", {
+          user_id: USER_ID
+        });
+        return {
+          content: [{ type: "text", text: result.formatted }]
+        };
+      }
+      case "archive_project": {
+        const { project } = args;
+        const result = await apiCall(`/api/projects/${encodeURIComponent(project)}/update`, "POST", {
+          user_id: USER_ID,
+          status: "archived"
+        });
+        return {
+          content: [{ type: "text", text: result.formatted }]
+        };
+      }
+      case "delete_project": {
+        const { project, delete_todos } = args;
+        const result = await apiCall(`/api/projects/${encodeURIComponent(project)}`, "DELETE", {
+          user_id: USER_ID,
+          delete_todos: delete_todos ?? false
+        });
+        return {
+          content: [{ type: "text", text: result.formatted }]
+        };
+      }
+      case "todo_stats": {
+        const result = await apiCall("/api/todos/stats", "POST", {
+          user_id: USER_ID
+        });
+        return {
+          content: [{ type: "text", text: result.formatted }]
+        };
+      }
+      case "list_subtasks": {
+        const { parent_id } = args;
+        const result = await apiCall(`/api/todos/${parent_id}/subtasks?user_id=${USER_ID}`, "GET");
+        return {
+          content: [{ type: "text", text: result.formatted }]
+        };
+      }
+      case "add_todo_comment": {
+        const { todo_id, content, comment_type } = args;
+        const result = await apiCall(`/api/todos/${todo_id}/comments`, "POST", {
+          user_id: USER_ID,
+          content,
+          comment_type
+        });
         return {
-          content: [
-            {
-              type: "text",
-              text: `Surfaced ${memories.length} relevant memories:
-
-${formatted}${entitySummary}
-
-[Latency: ${result.latency_ms.toFixed(1)}ms | Threshold: ${(semantic_threshold * 100).toFixed(0)}%]`
-            }
-          ]
+          content: [{ type: "text", text: result.formatted }]
         };
       }
-      case "streaming_status": {
-        const wsState = streamSocket?.readyState;
-        const stateNames = ["CONNECTING", "OPEN", "CLOSING", "CLOSED"];
-        const stateName = wsState !== undefined ? stateNames[wsState] || "UNKNOWN" : "NULL";
-        const status = {
-          enabled: STREAM_ENABLED,
-          ws_url: WS_URL,
-          socket_state: stateName,
-          handshake_complete: streamHandshakeComplete,
-          buffer_size: streamBuffer.length,
-          connecting: streamConnecting,
-          reconnect_pending: streamReconnectTimer !== null
+      case "list_todo_comments": {
+        const { todo_id } = args;
+        const result = await apiCall(`/api/todos/${todo_id}/comments?user_id=${USER_ID}`, "GET");
+        return {
+          content: [{ type: "text", text: result.formatted }]
         };
-        if (!streamSocket || streamSocket.readyState !== WebSocket.OPEN) {
-          connectStream().catch(() => {});
-        }
+      }
+      case "update_todo_comment": {
+        const { todo_id, comment_id, content } = args;
+        const result = await apiCall(`/api/todos/${todo_id}/comments/${comment_id}/update`, "POST", {
+          user_id: USER_ID,
+          content
+        });
         return {
-          content: [
-            {
-              type: "text",
-              text: `Streaming Status:
-
-` + `Enabled: ${status.enabled}
-` + `WebSocket URL: ${status.ws_url}
-` + `Socket State: ${status.socket_state}
-` + `Handshake Complete: ${status.handshake_complete}
-` + `Buffer Size: ${status.buffer_size}
-` + `Currently Connecting: ${status.connecting}
-` + `Reconnect Pending: ${status.reconnect_pending}
-
-` + (status.handshake_complete ? "✓ Streaming is ACTIVE" : "✗ Streaming is NOT ACTIVE - attempting reconnect...")
-            }
-          ]
+          content: [{ type: "text", text: result.formatted }]
         };
       }
-      case "consolidation_report": {
-        const { since, until } = args;
-        const result = await apiCall("/api/consolidation/report", "POST", {
+      case "delete_todo_comment": {
+        const { todo_id, comment_id } = args;
+        const result = await apiCall(`/api/todos/${todo_id}/comments/${comment_id}?user_id=${USER_ID}`, "DELETE");
+        return {
+          content: [{ type: "text", text: result.formatted }]
+        };
+      }
+      case "read_memory": {
+        const { memory_id } = args;
+        const result = await apiCall("/api/recall", "POST", {
           user_id: USER_ID,
-          since,
-          until
+          query: memory_id,
+          limit: 20
         });
-        const stats = result.statistics;
-        const sections = [];
-        const eventCount = result.strengthened_memories.length + result.decayed_memories.length + result.formed_associations.length + result.strengthened_associations.length + result.potentiated_associations.length + result.pruned_associations.length + result.extracted_facts.length + result.reinforced_facts.length;
-        sections.push(`CONSOLIDATION REPORT (${eventCount} events)`);
-        sections.push(`Period: ${result.period.start} to ${result.period.end}`);
-        sections.push("=".repeat(50));
-        if (stats.memories_strengthened > 0 || stats.memories_decayed > 0 || stats.memories_at_risk > 0) {
-          const memoryLines = [];
-          if (stats.memories_strengthened > 0)
-            memoryLines.push(`  + ${stats.memories_strengthened} memories strengthened`);
-          if (stats.memories_decayed > 0)
-            memoryLines.push(`  - ${stats.memories_decayed} memories decayed`);
-          if (stats.memories_at_risk > 0)
-            memoryLines.push(`  ! ${stats.memories_at_risk} memories at risk of forgetting`);
-          sections.push(`MEMORY CHANGES:
-${memoryLines.join(`
-`)}`);
-        }
-        if (stats.edges_formed > 0 || stats.edges_strengthened > 0 || stats.edges_potentiated > 0 || stats.edges_pruned > 0) {
-          const edgeLines = [];
-          if (stats.edges_formed > 0)
-            edgeLines.push(`  + ${stats.edges_formed} new associations formed`);
-          if (stats.edges_strengthened > 0)
-            edgeLines.push(`  + ${stats.edges_strengthened} associations strengthened`);
-          if (stats.edges_potentiated > 0)
-            edgeLines.push(`  * ${stats.edges_potentiated} associations became permanent (LTP)`);
-          if (stats.edges_pruned > 0)
-            edgeLines.push(`  - ${stats.edges_pruned} weak associations pruned`);
-          sections.push(`ASSOCIATIONS (Hebbian Learning):
-${edgeLines.join(`
-`)}`);
-        }
-        if (stats.facts_extracted > 0 || stats.facts_reinforced > 0) {
-          const factLines = [];
-          if (stats.facts_extracted > 0)
-            factLines.push(`  + ${stats.facts_extracted} facts extracted`);
-          if (stats.facts_reinforced > 0)
-            factLines.push(`  + ${stats.facts_reinforced} facts reinforced`);
-          sections.push(`FACTS:
-${factLines.join(`
-`)}`);
-        }
-        if (stats.maintenance_cycles > 0) {
-          const durationSec = (stats.total_maintenance_duration_ms / 1000).toFixed(2);
-          sections.push(`MAINTENANCE: ${stats.maintenance_cycles} cycle(s) completed (${durationSec}s total)`);
-        }
-        if (eventCount === 0) {
-          sections.push("No consolidation activity in this period. Store and access memories to trigger learning.");
+        const memory = result.memories.find((m) => m.id.toLowerCase().startsWith(memory_id.toLowerCase()));
+        if (!memory) {
+          return {
+            content: [{ type: "text", text: `❌ Memory not found: ${memory_id}` }]
+          };
         }
-        return {
-          content: [
-            {
-              type: "text",
-              text: sections.join(`
+        const tags = memory.experience.tags?.join(", ") || "none";
+        const created = new Date(memory.created_at).toLocaleString();
+        let response = `\uD83D\uDC18 Memory: ${memory.id}
+`;
+        response += `━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+`;
+        response += `Type: ${memory.experience.memory_type} │ Tags: ${tags}
+`;
+        response += `Created: ${created} │ Importance: ${(memory.importance * 100).toFixed(0)}%
+`;
+        response += `━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
-`)
-            }
-          ]
+`;
+        response += memory.experience.content;
+        return {
+          content: [{ type: "text", text: response }]
         };
       }
       default:
@@ -6085,6 +7173,9 @@ ${factLines.join(`
     const resultText = result.content.map((c) => c.text).join(`
 `);
     streamToolCall(name, args, resultText);
+    const responseTokens = estimateTokens(resultText);
+    sessionTokens += responseTokens;
+    const tokenStatus = getTokenStatus();
     if (PROACTIVE_SURFACING && !["remember", "recall", "forget", "list_memories", "proactive_context", "context_summary", "memory_stats"].includes(name)) {
       const contextParts = [];
       if (args && typeof args === "object") {
@@ -6103,7 +7194,19 @@ ${factLines.join(`
         }
       }
     }
-    return result;
+    if (tokenStatus.alert) {
+      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.
+
+`;
+      result.content[0].text = warning + result.content[0].text;
+    }
+    return {
+      ...result,
+      _meta: {
+        token_status: tokenStatus
+      }
+    };
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
     let helpText = "";
@@ -6133,30 +7236,191 @@ Endpoint not found. The server may be running an older version.`;
   }
 });
 server.setRequestHandler(ListResourcesRequestSchema, async () => {
+  const staticResources = [
+    {
+      uri: "shodh://commands",
+      name: "Available Commands",
+      mimeType: "text/markdown",
+      description: "List all shodh-memory commands and their usage"
+    },
+    {
+      uri: "shodh://summary",
+      name: "Session Summary",
+      mimeType: "text/plain",
+      description: "Recent learnings, decisions, and context"
+    },
+    {
+      uri: "shodh://todos",
+      name: "Pending Work",
+      mimeType: "text/plain",
+      description: "Your todo list and incomplete tasks"
+    },
+    {
+      uri: "shodh://stats",
+      name: "Memory Stats",
+      mimeType: "application/json",
+      description: "Memory system statistics and health"
+    }
+  ];
   try {
     const result = await apiCall("/api/memories", "POST", {
       user_id: USER_ID
     });
     const memories = result.memories || [];
+    const memoryResources = memories.slice(0, 30).map((m) => {
+      const content = getContent(m);
+      return {
+        uri: `memory://${m.id}`,
+        name: content.slice(0, 50) + (content.length > 50 ? "..." : ""),
+        mimeType: "text/plain",
+        description: `Type: ${getType(m)}`
+      };
+    });
     return {
-      resources: memories.slice(0, 50).map((m) => {
-        const content = getContent(m);
-        return {
-          uri: `memory://${m.id}`,
-          name: content.slice(0, 50) + (content.length > 50 ? "..." : ""),
-          mimeType: "text/plain",
-          description: `Type: ${getType(m)}`
-        };
-      })
+      resources: [...staticResources, ...memoryResources]
     };
   } catch {
-    return { resources: [] };
+    return { resources: staticResources };
   }
 });
 server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
   const uri = request.params.uri;
-  const memoryId = uri.replace("memory://", "");
   try {
+    if (uri.startsWith("shodh://")) {
+      const resource = uri.replace("shodh://", "");
+      switch (resource) {
+        case "commands": {
+          const commandList = `# Shodh-Memory Commands
+
+## Memory Tools
+- **remember** - Store a memory (observation, decision, learning, etc.)
+- **recall** - Search memories (semantic, associative, or hybrid mode)
+- **recall_by_tags** - Find memories by tags
+- **recall_by_date** - Find memories in a date range
+- **forget** - Delete a specific memory
+- **context_summary** - Get recent learnings, decisions, and context
+- **proactive_context** - Surface relevant memories for current context
+- **list_memories** - List all stored memories
+- **memory_stats** - Get memory system statistics
+
+## Todo Tools
+- **add_todo** - Add a task to your todo list
+- **list_todos** - View pending tasks
+- **update_todo** - Modify a todo
+- **complete_todo** - Mark a todo as done
+- **delete_todo** - Remove a todo
+- **list_projects** - View project hierarchy
+- **add_project** - Create a new project
+- **todo_stats** - Get todo statistics
+
+## System Tools
+- **verify_index** - Check memory index health
+- **repair_index** - Fix orphaned memories
+- **streaming_status** - Check streaming connection
+- **token_status** - Check context window usage
+- **reset_token_session** - Reset token tracking
+
+## Reminders
+- **set_reminder** - Set a future reminder
+- **list_reminders** - View pending reminders
+- **dismiss_reminder** - Mark reminder as handled
+
+## Slash Commands (type / in chat)
+- **/mcp__shodh-memory__quick_recall** - Search memories
+- **/mcp__shodh-memory__session_summary** - Session overview
+- **/mcp__shodh-memory__what_i_know** - Everything about a topic
+- **/mcp__shodh-memory__pending_work** - View todos
+- **/mcp__shodh-memory__recent_memories** - Recent memories
+- **/mcp__shodh-memory__memory_health** - System status
+`;
+          return {
+            contents: [{ uri, mimeType: "text/markdown", text: commandList }]
+          };
+        }
+        case "summary": {
+          const result2 = await apiCall("/api/context_summary", "POST", {
+            user_id: USER_ID,
+            include_learnings: true,
+            include_decisions: true,
+            include_context: true,
+            max_items: 5
+          });
+          const parts = [`Session Summary
+`];
+          if (result2.learnings?.length) {
+            parts.push(`
+Recent Learnings:`);
+            result2.learnings.forEach((m) => parts.push(`- ${getContent(m)}`));
+          }
+          if (result2.decisions?.length) {
+            parts.push(`
+Recent Decisions:`);
+            result2.decisions.forEach((m) => parts.push(`- ${getContent(m)}`));
+          }
+          if (result2.context?.length) {
+            parts.push(`
+Current Context:`);
+            result2.context.forEach((m) => parts.push(`- ${getContent(m)}`));
+          }
+          return {
+            contents: [{
+              uri,
+              mimeType: "text/plain",
+              text: parts.length > 1 ? parts.join(`
+`) : "No recent memories."
+            }]
+          };
+        }
+        case "todos": {
+          const result2 = await apiCall("/api/todos", "POST", {
+            user_id: USER_ID,
+            status: ["backlog", "todo", "in_progress", "blocked"]
+          });
+          const todos = result2.todos || [];
+          if (todos.length === 0) {
+            return {
+              contents: [{ uri, mimeType: "text/plain", text: "No pending tasks." }]
+            };
+          }
+          const byStatus = {};
+          todos.forEach((t) => {
+            if (!byStatus[t.status])
+              byStatus[t.status] = [];
+            byStatus[t.status].push(t);
+          });
+          const parts = [`Pending Work
+`];
+          ["in_progress", "blocked", "todo", "backlog"].forEach((status) => {
+            if (byStatus[status]?.length) {
+              parts.push(`
+${status.replace("_", " ").toUpperCase()}:`);
+              byStatus[status].forEach((t) => {
+                const priority = t.priority !== "medium" ? ` [${t.priority}]` : "";
+                const project = t.project ? ` (${t.project})` : "";
+                parts.push(`- ${t.content}${priority}${project}`);
+              });
+            }
+          });
+          return {
+            contents: [{ uri, mimeType: "text/plain", text: parts.join(`
+`) }]
+          };
+        }
+        case "stats": {
+          const stats = await apiCall(`/api/users/${USER_ID}/stats`, "GET");
+          return {
+            contents: [{
+              uri,
+              mimeType: "application/json",
+              text: JSON.stringify(stats, null, 2)
+            }]
+          };
+        }
+        default:
+          throw new Error(`Unknown resource: ${resource}`);
+      }
+    }
+    const memoryId = uri.replace("memory://", "");
     const result = await apiCall("/api/memories", "POST", {
       user_id: USER_ID
     });
@@ -6180,9 +7444,352 @@ ID: ${memory.id}`
     };
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
-    throw new Error(`Failed to read memory: ${message}`);
+    throw new Error(`Failed to read resource: ${message}`);
+  }
+});
+var SHODH_PROMPTS = [
+  {
+    name: "quick_recall",
+    description: "Search your memories for relevant context",
+    arguments: [
+      {
+        name: "query",
+        description: "What to search for in memories",
+        required: true
+      }
+    ]
+  },
+  {
+    name: "session_summary",
+    description: "Get a summary of recent learnings, decisions, and context",
+    arguments: []
+  },
+  {
+    name: "what_i_know",
+    description: "Surface everything related to a topic",
+    arguments: [
+      {
+        name: "topic",
+        description: "The topic to explore",
+        required: true
+      }
+    ]
+  },
+  {
+    name: "pending_work",
+    description: "Show todos and incomplete tasks",
+    arguments: []
+  },
+  {
+    name: "recent_memories",
+    description: "Show recently created memories",
+    arguments: [
+      {
+        name: "count",
+        description: "Number of memories (default: 10)",
+        required: false
+      }
+    ]
+  },
+  {
+    name: "memory_health",
+    description: "Check memory system status and statistics",
+    arguments: []
+  }
+];
+server.setRequestHandler(ListPromptsRequestSchema, async () => {
+  return {
+    prompts: SHODH_PROMPTS.map((p) => ({
+      name: p.name,
+      description: p.description,
+      arguments: p.arguments
+    }))
+  };
+});
+server.setRequestHandler(GetPromptRequestSchema, async (request) => {
+  const promptName = request.params.name;
+  const args = request.params.arguments || {};
+  try {
+    switch (promptName) {
+      case "quick_recall": {
+        const query = args.query;
+        if (!query) {
+          return {
+            messages: [
+              {
+                role: "user",
+                content: { type: "text", text: "Please provide a search query." }
+              }
+            ]
+          };
+        }
+        const result = await apiCall("/api/recall", "POST", {
+          user_id: USER_ID,
+          query,
+          mode: "hybrid",
+          limit: 5
+        });
+        const memories = result.memories || [];
+        const memoryText = memories.length > 0 ? memories.map((m) => `- ${getContent(m)} (${getType(m)})`).join(`
+`) : "No memories found.";
+        return {
+          messages: [
+            {
+              role: "user",
+              content: {
+                type: "text",
+                text: `Here's what I found about "${query}":
+
+${memoryText}`
+              }
+            }
+          ]
+        };
+      }
+      case "session_summary": {
+        const result = await apiCall("/api/context_summary", "POST", {
+          user_id: USER_ID,
+          include_learnings: true,
+          include_decisions: true,
+          include_context: true,
+          max_items: 5
+        });
+        const parts = [];
+        if (result.learnings?.length) {
+          parts.push("**Recent Learnings:**");
+          result.learnings.forEach((m) => parts.push(`- ${getContent(m)}`));
+        }
+        if (result.decisions?.length) {
+          parts.push(`
+**Recent Decisions:**`);
+          result.decisions.forEach((m) => parts.push(`- ${getContent(m)}`));
+        }
+        if (result.context?.length) {
+          parts.push(`
+**Current Context:**`);
+          result.context.forEach((m) => parts.push(`- ${getContent(m)}`));
+        }
+        const summaryText = parts.length > 0 ? parts.join(`
+`) : "No recent memories.";
+        return {
+          messages: [
+            {
+              role: "user",
+              content: { type: "text", text: `Session Summary:
+
+${summaryText}` }
+            }
+          ]
+        };
+      }
+      case "what_i_know": {
+        const topic = args.topic;
+        if (!topic) {
+          return {
+            messages: [
+              {
+                role: "user",
+                content: { type: "text", text: "Please specify a topic to explore." }
+              }
+            ]
+          };
+        }
+        const result = await apiCall("/api/recall", "POST", {
+          user_id: USER_ID,
+          query: topic,
+          mode: "hybrid",
+          limit: 10
+        });
+        const memories = result.memories || [];
+        const grouped = {};
+        memories.forEach((m) => {
+          const type = getType(m);
+          if (!grouped[type])
+            grouped[type] = [];
+          grouped[type].push(m);
+        });
+        const parts = [`Everything I know about "${topic}":
+`];
+        Object.entries(grouped).forEach(([type, mems]) => {
+          parts.push(`
+**${type}s:**`);
+          mems.forEach((m) => parts.push(`- ${getContent(m)}`));
+        });
+        return {
+          messages: [
+            {
+              role: "user",
+              content: {
+                type: "text",
+                text: memories.length > 0 ? parts.join(`
+`) : `No memories found about "${topic}".`
+              }
+            }
+          ]
+        };
+      }
+      case "pending_work": {
+        const result = await apiCall("/api/todos", "POST", {
+          user_id: USER_ID,
+          status: ["backlog", "todo", "in_progress", "blocked"]
+        });
+        const todos = result.todos || [];
+        if (todos.length === 0) {
+          return {
+            messages: [
+              {
+                role: "user",
+                content: { type: "text", text: "No pending tasks. You're all caught up!" }
+              }
+            ]
+          };
+        }
+        const byStatus = {};
+        todos.forEach((t) => {
+          if (!byStatus[t.status])
+            byStatus[t.status] = [];
+          byStatus[t.status].push(t);
+        });
+        const parts = [`**Pending Work:**
+`];
+        ["in_progress", "blocked", "todo", "backlog"].forEach((status) => {
+          if (byStatus[status]?.length) {
+            parts.push(`
+*${status.replace("_", " ").toUpperCase()}:*`);
+            byStatus[status].forEach((t) => {
+              const priority = t.priority !== "medium" ? ` [${t.priority}]` : "";
+              const project = t.project ? ` (${t.project})` : "";
+              parts.push(`- ${t.content}${priority}${project}`);
+            });
+          }
+        });
+        return {
+          messages: [
+            {
+              role: "user",
+              content: { type: "text", text: parts.join(`
+`) }
+            }
+          ]
+        };
+      }
+      case "recent_memories": {
+        const count = parseInt(args.count || "10", 10);
+        const result = await apiCall("/api/memories", "POST", {
+          user_id: USER_ID,
+          limit: count
+        });
+        const memories = result.memories || [];
+        if (memories.length === 0) {
+          return {
+            messages: [
+              {
+                role: "user",
+                content: { type: "text", text: "No memories found." }
+              }
+            ]
+          };
+        }
+        const parts = [`**${memories.length} Recent Memories:**
+`];
+        memories.forEach((m) => {
+          const content = getContent(m);
+          const type = getType(m);
+          const preview = content.length > 100 ? content.slice(0, 100) + "..." : content;
+          parts.push(`- [${type}] ${preview}`);
+        });
+        return {
+          messages: [
+            {
+              role: "user",
+              content: { type: "text", text: parts.join(`
+`) }
+            }
+          ]
+        };
+      }
+      case "memory_health": {
+        const statsResult = await apiCall(`/api/users/${USER_ID}/stats`, "GET");
+        const verifyResult = await apiCall("/api/index/verify", "POST", { user_id: USER_ID });
+        const parts = [`**Memory System Health:**
+`];
+        parts.push(`Total memories: ${statsResult.total_memories || 0}`);
+        parts.push(`Last 24h: ${statsResult.memories_last_24h || 0}`);
+        parts.push(`Last 7 days: ${statsResult.memories_last_7d || 0}`);
+        parts.push(`
+Index status: ${verifyResult.healthy ? "✓ Healthy" : "⚠ Needs repair"}`);
+        if (verifyResult.orphaned_count > 0) {
+          parts.push(`Orphaned entries: ${verifyResult.orphaned_count}`);
+        }
+        if (statsResult.memories_by_type) {
+          parts.push(`
+**By Type:**`);
+          Object.entries(statsResult.memories_by_type).forEach(([type, count]) => {
+            parts.push(`- ${type}: ${count}`);
+          });
+        }
+        return {
+          messages: [
+            {
+              role: "user",
+              content: { type: "text", text: parts.join(`
+`) }
+            }
+          ]
+        };
+      }
+      default:
+        return {
+          messages: [
+            {
+              role: "user",
+              content: { type: "text", text: `Unknown prompt: ${promptName}` }
+            }
+          ]
+        };
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return {
+      messages: [
+        {
+          role: "user",
+          content: { type: "text", text: `Error: ${message}` }
+        }
+      ]
+    };
   }
 });
+server.setRequestHandler(ListResourceTemplatesRequestSchema, async () => {
+  return {
+    resourceTemplates: [
+      {
+        uriTemplate: "memory://{id}",
+        name: "Memory by ID",
+        description: "Access a specific memory by its ID",
+        mimeType: "text/plain"
+      },
+      {
+        uriTemplate: "shodh://stats",
+        name: "Memory Statistics",
+        description: "Current memory system statistics",
+        mimeType: "application/json"
+      },
+      {
+        uriTemplate: "shodh://todos",
+        name: "Todo List",
+        description: "Your pending tasks and work items",
+        mimeType: "text/plain"
+      },
+      {
+        uriTemplate: "shodh://search/{query}",
+        name: "Search Memories",
+        description: "Search memories for a specific query",
+        mimeType: "text/plain"
+      }
+    ]
+  };
+});
 var AUTO_SPAWN_ENABLED = process.env.SHODH_NO_AUTO_SPAWN !== "true";
 var serverProcess = null;
 function getBinaryPath() {