@stackmemoryai/stackmemory 1.2.7 → 1.2.9

package/dist/src/integrations/mcp/server.js

@@ -13,7 +13,15 @@ import {
   AddAnchorSchema,
   CreateTaskSchema
 } from "./schemas.js";
-import { readFileSync, existsSync, mkdirSync, writeFileSync } from "fs";
+import {
+  readFileSync,
+  readdirSync,
+  existsSync,
+  mkdirSync,
+  writeFileSync,
+  appendFileSync
+} from "fs";
+import { homedir } from "os";
 import { compactPlan } from "../../orchestrators/multimodal/utils.js";
 import { filterPending } from "./pending-utils.js";
 import { join, dirname } from "path";
@@ -31,6 +39,12 @@ import { LLMContextRetrieval } from "../../core/retrieval/index.js";
 import { DiscoveryHandlers } from "./handlers/discovery-handlers.js";
 import { DiffMemHandlers } from "./handlers/diffmem-handlers.js";
 import { GreptileHandlers } from "./handlers/greptile-handlers.js";
+import { CordHandlers } from "./handlers/cord-handlers.js";
+import { TeamHandlers } from "./handlers/team-handlers.js";
+import { SQLiteAdapter } from "../../core/database/sqlite-adapter.js";
+import {
+  generateChronologicalDigest
+} from "../../core/digest/chronological-digest.js";
 import { fuzzyEdit } from "../../utils/fuzzy-edit.js";
 import { v4 as uuidv4 } from "uuid";
 import {
@@ -66,6 +80,8 @@ class LocalStackMemoryMCP {
   diffMemHandlers;
   greptileHandlers;
   providerHandlers = null;
+  cordHandlers = null;
+  teamHandlers = null;
   pendingPlans = /* @__PURE__ */ new Map();
   constructor() {
     this.projectRoot = this.findProjectRoot();
@@ -139,6 +155,7 @@ class LocalStackMemoryMCP {
     });
     this.diffMemHandlers = new DiffMemHandlers();
     this.greptileHandlers = new GreptileHandlers();
+    this.initCordTeamHandlers();
     this.initProviderHandlers();
     this.setupHandlers();
     this.loadInitialContext();
@@ -261,6 +278,27 @@ ${summary}...`, 0.8);
       this.contexts.set(ctx.id, ctx);
     });
   }
+  async initCordTeamHandlers() {
+    try {
+      const dbPath = join(this.projectRoot, ".stackmemory", "context.db");
+      const adapter = new SQLiteAdapter(this.projectId, {
+        dbPath,
+        walMode: true
+      });
+      await adapter.connect();
+      this.cordHandlers = new CordHandlers({
+        frameManager: this.frameManager,
+        dbAdapter: adapter
+      });
+      this.teamHandlers = new TeamHandlers({
+        frameManager: this.frameManager,
+        dbAdapter: adapter
+      });
+      logger.info("Cord and Team handlers initialized");
+    } catch (error) {
+      logger.warn("Failed to initialize Cord/Team handlers", { error });
+    }
+  }
   async initProviderHandlers() {
     if (!isFeatureEnabled("multiProvider")) return;
     try {
@@ -296,199 +334,180 @@ ${summary}...`, 0.8);
                 }
               }
             },
-            {
-              name: "plan_and_code",
-              description: "Generate a plan (Claude), attempt implementation (Codex/Claude), and return JSON result. Quiet by default.",
-              inputSchema: {
-                type: "object",
-                properties: {
-                  task: { type: "string", description: "Task description" },
-                  implementer: {
-                    type: "string",
-                    enum: ["codex", "claude"],
-                    default: "codex",
-                    description: "Which agent implements code"
-                  },
-                  maxIters: {
-                    type: "number",
-                    default: 2,
-                    description: "Retry loop iterations"
-                  },
-                  execute: {
-                    type: "boolean",
-                    default: false,
-                    description: "Actually call implementer (otherwise dry-run)"
+            // Planning tools (only when ANTHROPIC_API_KEY is set)
+            ...process.env.ANTHROPIC_API_KEY ? [
+              {
+                name: "plan_gate",
+                description: "Phase 1: Generate a plan and return an approvalId for later execution",
+                inputSchema: {
+                  type: "object",
+                  properties: {
+                    task: {
+                      type: "string",
+                      description: "Task description"
+                    },
+                    plannerModel: {
+                      type: "string",
+                      description: "Claude model (optional)"
+                    }
                   },
-                  record: {
-                    type: "boolean",
-                    default: false,
-                    description: "Record plan & critique into StackMemory context"
+                  required: ["task"]
+                }
+              },
+              {
+                name: "approve_plan",
+                description: "Phase 2: Execute a previously generated plan by approvalId",
+                inputSchema: {
+                  type: "object",
+                  properties: {
+                    approvalId: {
+                      type: "string",
+                      description: "Id from plan_gate"
+                    },
+                    implementer: {
+                      type: "string",
+                      enum: ["codex", "claude"],
+                      default: "codex",
+                      description: "Which agent implements code"
+                    },
+                    maxIters: { type: "number", default: 2 },
+                    recordFrame: { type: "boolean", default: true },
+                    execute: { type: "boolean", default: true }
                   },
-                  recordFrame: {
-                    type: "boolean",
-                    default: false,
-                    description: "Record as real frame with anchors"
+                  required: ["approvalId"]
+                }
+              },
+              {
+                name: "pending_list",
+                description: "List pending approval-gated plans (supports filters)",
+                inputSchema: {
+                  type: "object",
+                  properties: {
+                    taskContains: {
+                      type: "string",
+                      description: "Filter tasks containing this substring"
+                    },
+                    olderThanMs: {
+                      type: "number",
+                      description: "Only items older than this age (ms)"
+                    },
+                    newerThanMs: {
+                      type: "number",
+                      description: "Only items newer than this age (ms)"
+                    },
+                    sort: {
+                      type: "string",
+                      enum: ["asc", "desc"],
+                      description: "Sort by createdAt"
+                    },
+                    limit: {
+                      type: "number",
+                      description: "Max items to return"
+                    }
                   }
-                },
-                required: ["task"]
-              }
-            },
-            {
-              name: "plan_gate",
-              description: "Phase 1: Generate a plan and return an approvalId for later execution",
-              inputSchema: {
-                type: "object",
-                properties: {
-                  task: { type: "string", description: "Task description" },
-                  plannerModel: {
-                    type: "string",
-                    description: "Claude model (optional)"
+                }
+              },
+              {
+                name: "pending_clear",
+                description: "Clear pending approval-gated plans (by id, all, or olderThanMs)",
+                inputSchema: {
+                  type: "object",
+                  properties: {
+                    approvalId: {
+                      type: "string",
+                      description: "Clear a single approval by id"
+                    },
+                    all: {
+                      type: "boolean",
+                      description: "Clear all pending approvals",
+                      default: false
+                    },
+                    olderThanMs: {
+                      type: "number",
+                      description: "Clear approvals older than this age (ms)"
+                    }
                   }
-                },
-                required: ["task"]
-              }
-            },
-            {
-              name: "approve_plan",
-              description: "Phase 2: Execute a previously generated plan by approvalId (runs implement + critique)",
-              inputSchema: {
-                type: "object",
-                properties: {
-                  approvalId: {
-                    type: "string",
-                    description: "Id from plan_gate"
-                  },
-                  implementer: {
-                    type: "string",
-                    enum: ["codex", "claude"],
-                    default: "codex",
-                    description: "Which agent implements code"
-                  },
-                  maxIters: { type: "number", default: 2 },
-                  recordFrame: { type: "boolean", default: true },
-                  execute: { type: "boolean", default: true }
-                },
-                required: ["approvalId"]
-              }
-            },
-            {
-              name: "pending_list",
-              description: "List pending approval-gated plans (supports filters)",
-              inputSchema: {
-                type: "object",
-                properties: {
-                  taskContains: {
-                    type: "string",
-                    description: "Filter tasks containing this substring"
-                  },
-                  olderThanMs: {
-                    type: "number",
-                    description: "Only items older than this age (ms)"
-                  },
-                  newerThanMs: {
-                    type: "number",
-                    description: "Only items newer than this age (ms)"
-                  },
-                  sort: {
-                    type: "string",
-                    enum: ["asc", "desc"],
-                    description: "Sort by createdAt"
-                  },
-                  limit: { type: "number", description: "Max items to return" }
                 }
-              }
-            },
-            {
-              name: "pending_clear",
-              description: "Clear pending approval-gated plans (by id, all, or olderThanMs)",
-              inputSchema: {
-                type: "object",
-                properties: {
-                  approvalId: {
-                    type: "string",
-                    description: "Clear a single approval by id"
+              },
+              {
+                name: "pending_show",
+                description: "Show a pending plan by approvalId",
+                inputSchema: {
+                  type: "object",
+                  properties: {
+                    approvalId: {
+                      type: "string",
+                      description: "Approval id from plan_gate"
+                    }
                   },
-                  all: {
-                    type: "boolean",
-                    description: "Clear all pending approvals",
-                    default: false
+                  required: ["approvalId"]
+                }
+              },
+              {
+                name: "plan_only",
+                description: "Generate an implementation plan (Claude) and return JSON only",
+                inputSchema: {
+                  type: "object",
+                  properties: {
+                    task: {
+                      type: "string",
+                      description: "Task description"
+                    },
+                    plannerModel: {
+                      type: "string",
+                      description: "Claude model for planning (optional)"
+                    }
                   },
-                  olderThanMs: {
-                    type: "number",
-                    description: "Clear approvals older than this age (ms)"
-                  }
+                  required: ["task"]
                 }
-              }
-            },
-            {
-              name: "pending_show",
-              description: "Show a pending plan by approvalId",
-              inputSchema: {
-                type: "object",
-                properties: {
-                  approvalId: {
-                    type: "string",
-                    description: "Approval id from plan_gate"
-                  }
-                },
-                required: ["approvalId"]
-              }
-            },
-            {
-              name: "plan_only",
-              description: "Generate an implementation plan (Claude) and return JSON only",
-              inputSchema: {
-                type: "object",
-                properties: {
-                  task: { type: "string", description: "Task description" },
-                  plannerModel: {
-                    type: "string",
-                    description: "Claude model for planning (optional)"
-                  }
-                },
-                required: ["task"]
-              }
-            },
-            {
-              name: "call_codex",
-              description: "Invoke Codex via codex-sm with a prompt and args; dry-run by default",
-              inputSchema: {
-                type: "object",
-                properties: {
-                  prompt: { type: "string", description: "Prompt for Codex" },
-                  args: {
-                    type: "array",
-                    items: { type: "string" },
-                    description: "Additional CLI args for codex-sm"
+              },
+              {
+                name: "call_codex",
+                description: "Invoke Codex via codex-sm with a prompt and args; dry-run by default",
+                inputSchema: {
+                  type: "object",
+                  properties: {
+                    prompt: {
+                      type: "string",
+                      description: "Prompt for Codex"
+                    },
+                    args: {
+                      type: "array",
+                      items: { type: "string" },
+                      description: "Additional CLI args for codex-sm"
+                    },
+                    execute: {
+                      type: "boolean",
+                      default: false,
+                      description: "Actually run codex-sm (otherwise dry-run)"
+                    }
                   },
-                  execute: {
-                    type: "boolean",
-                    default: false,
-                    description: "Actually run codex-sm (otherwise dry-run)"
-                  }
-                },
-                required: ["prompt"]
-              }
-            },
-            {
-              name: "call_claude",
-              description: "Invoke Claude with a prompt (Anthropic SDK)",
-              inputSchema: {
-                type: "object",
-                properties: {
-                  prompt: { type: "string", description: "Prompt for Claude" },
-                  model: {
-                    type: "string",
-                    description: "Claude model (optional)"
+                  required: ["prompt"]
+                }
+              },
+              {
+                name: "call_claude",
+                description: "Invoke Claude with a prompt (Anthropic SDK)",
+                inputSchema: {
+                  type: "object",
+                  properties: {
+                    prompt: {
+                      type: "string",
+                      description: "Prompt for Claude"
+                    },
+                    model: {
+                      type: "string",
+                      description: "Claude model (optional)"
+                    },
+                    system: {
+                      type: "string",
+                      description: "System prompt (optional)"
+                    }
                   },
-                  system: {
-                    type: "string",
-                    description: "System prompt (optional)"
-                  }
-                },
-                required: ["prompt"]
+                  required: ["prompt"]
+                }
               }
-            },
+            ] : [],
             {
               name: "add_decision",
               description: "Record a decision or important information",
@@ -953,109 +972,190 @@ ${summary}...`, 0.8);
                 required: ["query"]
               }
             },
-            // DiffMem tools for user memory management
+            // DiffMem tools (only when DIFFMEM_ENDPOINT or DIFFMEM_ENABLED is set)
+            ...process.env.DIFFMEM_ENDPOINT || process.env.DIFFMEM_ENABLED === "true" ? this.diffMemHandlers.getToolDefinitions() : [],
+            // Cord task orchestration tools
             {
-              name: "diffmem_get_user_context",
-              description: "Fetch user knowledge and preferences from memory. Use to personalize responses based on learned user patterns.",
+              name: "cord_spawn",
+              description: "Create a subtask with clean context (spawn). Child sees only its prompt and completed blocker results.",
               inputSchema: {
                 type: "object",
                 properties: {
-                  categories: {
+                  goal: {
+                    type: "string",
+                    description: "What this task should accomplish"
+                  },
+                  prompt: {
+                    type: "string",
+                    description: "Detailed instructions for the task"
+                  },
+                  blocked_by: {
                     type: "array",
-                    items: {
-                      type: "string",
-                      enum: [
-                        "preference",
-                        "expertise",
-                        "project_knowledge",
-                        "pattern",
-                        "correction"
-                      ]
-                    },
-                    description: "Filter by memory categories"
+                    items: { type: "string" },
+                    description: "Task IDs that must complete first"
                   },
-                  limit: {
-                    type: "number",
-                    default: 10,
-                    description: "Maximum memories to return"
-                  }
-                }
+                  parent_id: { type: "string", description: "Parent task ID" }
+                },
+                required: ["goal"]
               }
             },
             {
-              name: "diffmem_store_learning",
-              description: "Store a new insight about the user (preference, expertise, pattern, or correction)",
+              name: "cord_fork",
+              description: "Create a subtask with full sibling context (fork). Child sees prompt, blocker results, AND completed sibling results.",
               inputSchema: {
                 type: "object",
                 properties: {
-                  content: {
+                  goal: {
                     type: "string",
-                    description: "The insight to store"
+                    description: "What this task should accomplish"
                   },
-                  category: {
+                  prompt: {
                     type: "string",
-                    enum: [
-                      "preference",
-                      "expertise",
-                      "project_knowledge",
-                      "pattern",
-                      "correction"
-                    ],
-                    description: "Category of the insight"
+                    description: "Detailed instructions for the task"
                   },
-                  confidence: {
-                    type: "number",
-                    minimum: 0,
-                    maximum: 1,
-                    default: 0.7,
-                    description: "Confidence level (0-1)"
+                  blocked_by: {
+                    type: "array",
+                    items: { type: "string" },
+                    description: "Task IDs that must complete first"
                   },
-                  context: {
-                    type: "object",
-                    description: "Additional context for the insight"
-                  }
+                  parent_id: { type: "string", description: "Parent task ID" }
                 },
-                required: ["content", "category"]
+                required: ["goal"]
               }
             },
             {
-              name: "diffmem_search",
-              description: "Semantic search across user memories. Find relevant past insights and preferences.",
+              name: "cord_complete",
+              description: "Mark a cord task as completed with a result. Automatically unblocks dependent tasks.",
               inputSchema: {
                 type: "object",
                 properties: {
-                  query: {
+                  task_id: {
                     type: "string",
-                    description: "Search query"
+                    description: "Task ID to complete"
                   },
-                  timeRange: {
+                  result: {
                     type: "string",
-                    enum: ["day", "week", "month", "all"],
-                    default: "all",
-                    description: "Time range filter"
+                    description: "The result/output of this task"
+                  }
+                },
+                required: ["task_id", "result"]
+              }
+            },
+            {
+              name: "cord_ask",
+              description: "Create an ask task \u2014 a question that needs an answer before dependent tasks can proceed.",
+              inputSchema: {
+                type: "object",
+                properties: {
+                  question: {
+                    type: "string",
+                    description: "The question to ask"
                   },
-                  minConfidence: {
-                    type: "number",
-                    minimum: 0,
-                    maximum: 1,
-                    default: 0.5,
-                    description: "Minimum confidence threshold"
+                  options: {
+                    type: "array",
+                    items: { type: "string" },
+                    description: "Optional list of answer choices"
+                  },
+                  parent_id: { type: "string", description: "Parent task ID" }
+                },
+                required: ["question"]
+              }
+            },
+            {
+              name: "cord_tree",
+              description: "View the cord task tree with context scoping. Shows active, blocked, or completed tasks.",
+              inputSchema: {
+                type: "object",
+                properties: {
+                  task_id: {
+                    type: "string",
+                    description: "Root task ID to show subtree (omit for full tree)"
                   },
+                  include_results: {
+                    type: "boolean",
+                    default: false,
+                    description: "Include task results in output"
+                  }
+                }
+              }
+            },
+            // Team collaboration tools
+            {
+              name: "team_context_get",
+              description: "Get context from other agents working on the same project. Returns recent frames and shared anchors.",
+              inputSchema: {
+                type: "object",
+                properties: {
                   limit: {
                     type: "number",
                     default: 10,
-                    description: "Maximum results"
+                    description: "Max frames to return"
+                  },
+                  types: {
+                    type: "array",
+                    items: { type: "string" },
+                    description: "Filter by frame types"
+                  },
+                  since: {
+                    type: "number",
+                    description: "Only frames created after this timestamp (epoch ms)"
+                  }
+                }
+              }
+            },
+            {
+              name: "team_context_share",
+              description: "Share a piece of context with other agents. Creates a high-priority anchor visible to team_context_get.",
+              inputSchema: {
+                type: "object",
+                properties: {
+                  content: {
+                    type: "string",
+                    description: "The context to share"
+                  },
+                  type: {
+                    type: "string",
+                    enum: [
+                      "FACT",
+                      "DECISION",
+                      "CONSTRAINT",
+                      "INTERFACE_CONTRACT",
+                      "TODO",
+                      "RISK"
+                    ],
+                    default: "FACT",
+                    description: "Type of context"
+                  },
+                  priority: {
+                    type: "number",
+                    minimum: 1,
+                    maximum: 10,
+                    default: 8,
+                    description: "Priority level (1-10)"
                   }
                 },
-                required: ["query"]
+                required: ["content"]
               }
             },
             {
-              name: "diffmem_status",
-              description: "Check DiffMem connection status and memory statistics",
+              name: "team_search",
+              description: "Search across all agents' context in the project. Uses full-text search across all sessions.",
               inputSchema: {
                 type: "object",
-                properties: {}
+                properties: {
+                  query: { type: "string", description: "Search query" },
+                  limit: {
+                    type: "number",
+                    default: 20,
+                    description: "Maximum results to return"
+                  },
+                  include_events: {
+                    type: "boolean",
+                    default: false,
+                    description: "Include events in results"
+                  }
+                },
+                required: ["query"]
               }
             },
             // Greptile tools (only active when GREPTILE_API_KEY is set)
@@ -1160,7 +1260,23 @@ ${summary}...`, 0.8);
                   required: ["batchId"]
                 }
               }
-            ] : []
+            ] : [],
+            // Digest tool
+            {
+              name: "sm_digest",
+              description: "Generate a chronological activity digest for a time period (today/yesterday/week)",
+              inputSchema: {
+                type: "object",
+                properties: {
+                  period: {
+                    type: "string",
+                    enum: ["today", "yesterday", "week"],
+                    description: "Time period for the digest"
+                  }
+                },
+                required: ["period"]
+              }
+            }
           ]
         };
       }
@@ -1330,6 +1446,104 @@ ${summary}...`, 0.8);
             case "sm_edit":
               result = await this.handleSmEdit(args);
               break;
+            // Cord task orchestration
+            case "cord_spawn":
+              if (!this.cordHandlers) {
+                result = {
+                  content: [
+                    { type: "text", text: "Cord handlers not initialized." }
+                  ],
+                  is_error: true
+                };
+              } else {
+                result = await this.cordHandlers.handleCordSpawn(args);
+              }
+              break;
+            case "cord_fork":
+              if (!this.cordHandlers) {
+                result = {
+                  content: [
+                    { type: "text", text: "Cord handlers not initialized." }
+                  ],
+                  is_error: true
+                };
+              } else {
+                result = await this.cordHandlers.handleCordFork(args);
+              }
+              break;
+            case "cord_complete":
+              if (!this.cordHandlers) {
+                result = {
+                  content: [
+                    { type: "text", text: "Cord handlers not initialized." }
+                  ],
+                  is_error: true
+                };
+              } else {
+                result = await this.cordHandlers.handleCordComplete(args);
+              }
+              break;
+            case "cord_ask":
+              if (!this.cordHandlers) {
+                result = {
+                  content: [
+                    { type: "text", text: "Cord handlers not initialized." }
+                  ],
+                  is_error: true
+                };
+              } else {
+                result = await this.cordHandlers.handleCordAsk(args);
+              }
+              break;
+            case "cord_tree":
+              if (!this.cordHandlers) {
+                result = {
+                  content: [
+                    { type: "text", text: "Cord handlers not initialized." }
+                  ],
+                  is_error: true
+                };
+              } else {
+                result = await this.cordHandlers.handleCordTree(args);
+              }
+              break;
+            // Team collaboration
+            case "team_context_get":
+              if (!this.teamHandlers) {
+                result = {
+                  content: [
+                    { type: "text", text: "Team handlers not initialized." }
+                  ],
+                  is_error: true
+                };
+              } else {
+                result = await this.teamHandlers.handleTeamContextGet(args);
+              }
+              break;
+            case "team_context_share":
+              if (!this.teamHandlers) {
+                result = {
+                  content: [
+                    { type: "text", text: "Team handlers not initialized." }
+                  ],
+                  is_error: true
+                };
+              } else {
+                result = await this.teamHandlers.handleTeamContextShare(args);
+              }
+              break;
+            case "team_search":
+              if (!this.teamHandlers) {
+                result = {
+                  content: [
+                    { type: "text", text: "Team handlers not initialized." }
+                  ],
+                  is_error: true
+                };
+              } else {
+                result = await this.teamHandlers.handleTeamSearch(args);
+              }
+              break;
             // Provider tools
             case "delegate_to_model":
               if (!this.providerHandlers) {
@@ -1339,7 +1553,8 @@ ${summary}...`, 0.8);
                       type: "text",
                       text: "Multi-provider routing is disabled."
                     }
-                  ]
+                  ],
+                  is_error: true
                 };
               } else {
                 result = await this.providerHandlers.handleDelegateToModel(
@@ -1355,7 +1570,8 @@ ${summary}...`, 0.8);
                       type: "text",
                       text: "Multi-provider routing is disabled."
                     }
-                  ]
+                  ],
+                  is_error: true
                 };
               } else {
                 result = await this.providerHandlers.handleBatchSubmit(
@@ -1371,7 +1587,8 @@ ${summary}...`, 0.8);
                       type: "text",
                       text: "Multi-provider routing is disabled."
                     }
-                  ]
+                  ],
+                  is_error: true
                 };
               } else {
                 result = await this.providerHandlers.handleBatchCheck(
@@ -1379,12 +1596,19 @@ ${summary}...`, 0.8);
                 );
               }
               break;
+            case "sm_digest":
+              result = await this.handleSmDigest(args);
+              break;
+            case "sm_desire_paths":
+              result = this.handleDesirePaths(args);
+              break;
             default:
               throw new Error(`Unknown tool: ${name}`);
           }
         } catch (err) {
           error = err instanceof Error ? err : new Error(String(err));
           toolCall.error = error.message;
+          this.logDesirePath(name, args, error.message);
           throw err;
         } finally {
           const endTime = Date.now();
@@ -2851,6 +3075,153 @@ ${typeBreakdown}`
       matchedText: editResult.match.matchedText.length > 200 ? editResult.match.matchedText.slice(0, 200) + "..." : editResult.match.matchedText
     };
   }
+  /** Log failed tool calls to desire path JSONL for product prioritization */
+  logDesirePath(tool, args, errorMsg) {
+    try {
+      const home = process.env["HOME"] || "/tmp";
+      const dir = join(home, ".stackmemory", "desire-paths");
+      if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+      const category = /unknown tool/i.test(errorMsg) ? "unknown_tool" : /invalid param|missing.*param/i.test(errorMsg) ? "invalid_params" : "handler_error";
+      const sanitized = {};
+      for (const [k, v] of Object.entries(args)) {
+        sanitized[k] = typeof v === "string" && v.length > 200 ? v.slice(0, 200) + "...[truncated]" : v;
+      }
+      const date = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+      const entry = {
+        ts: (/* @__PURE__ */ new Date()).toISOString(),
+        tool,
+        input: sanitized,
+        error: errorMsg.slice(0, 500),
+        category,
+        source: "mcp-server"
+      };
+      appendFileSync(
+        join(dir, `desire-server-${date}.jsonl`),
+        JSON.stringify(entry) + "\n"
+      );
+    } catch {
+    }
+  }
+  /** Handle sm_desire_paths tool — read and aggregate desire path logs */
+  handleDesirePaths(args) {
+    const mode = String(args.mode || "summary");
+    const days = Number(args.days || 7);
+    const limit = Number(args.limit || 20);
+    const categoryFilter = args.category ? String(args.category) : void 0;
+    const desireDir = join(homedir(), ".stackmemory", "desire-paths");
+    if (!existsSync(desireDir)) {
+      return {
+        content: [{ type: "text", text: "No desire path data found." }]
+      };
+    }
+    const cutoff = Date.now() - days * 24 * 60 * 60 * 1e3;
+    const files = readdirSync(desireDir).filter(
+      (f) => f.startsWith("desire-") && f.endsWith(".jsonl")
+    );
+    const entries = [];
+    for (const file of files) {
+      const lines = readFileSync(join(desireDir, file), "utf-8").split("\n").filter(Boolean);
+      for (const line of lines) {
+        try {
+          const entry = JSON.parse(line);
+          if (new Date(entry.ts).getTime() < cutoff) continue;
+          if (categoryFilter && entry.category !== categoryFilter) continue;
+          entries.push(entry);
+        } catch {
+        }
+      }
+    }
+    if (entries.length === 0) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: `No desire path data in the last ${days} day(s).`
+          }
+        ]
+      };
+    }
+    if (mode === "list") {
+      const recent = entries.sort((a, b) => b.ts.localeCompare(a.ts)).slice(0, limit);
+      const lines = recent.map(
+        (e) => `${e.ts.slice(0, 19)} ${e.tool} [${e.category}]
+  ${e.error.slice(0, 120)}`
+      );
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Recent desire paths (${recent.length}/${entries.length}):
+
+${lines.join("\n\n")}`
+          }
+        ]
+      };
+    }
+    const byTool = /* @__PURE__ */ new Map();
+    for (const e of entries) {
+      const existing = byTool.get(e.tool);
+      if (!existing || e.ts > existing.lastSeen) {
+        byTool.set(e.tool, {
+          count: (existing?.count || 0) + 1,
+          category: e.category,
+          lastSeen: e.ts
+        });
+      } else {
+        existing.count++;
+      }
+    }
+    const sorted = [...byTool.entries()].sort(
+      (a, b) => b[1].count - a[1].count
+    );
+    const byCat = /* @__PURE__ */ new Map();
+    for (const e of entries) {
+      byCat.set(e.category, (byCat.get(e.category) || 0) + 1);
+    }
+    const toolLines = sorted.map(
+      ([tool, data]) => `${tool}: ${data.count}x [${data.category}] (last: ${data.lastSeen.slice(0, 10)})`
+    );
+    const catLines = [...byCat.entries()].sort((a, b) => b[1] - a[1]).map(([cat, count]) => `  ${cat}: ${count}`);
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Desire Path Summary (last ${days}d, ${entries.length} total failures)
+
+By Tool:
+${toolLines.join("\n")}
+
+By Category:
+${catLines.join("\n")}`
+        }
+      ]
+    };
+  }
+  async handleSmDigest(args) {
+    const period = String(args.period || "today");
+    if (!["today", "yesterday", "week"].includes(period)) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Invalid period "${period}". Use: today, yesterday, week`
+          }
+        ],
+        isError: true
+      };
+    }
+    const markdown = generateChronologicalDigest(
+      this.db,
+      period,
+      this.projectId
+    );
+    const outputPath = join(this.projectRoot, ".stackmemory", `${period}.md`);
+    writeFileSync(outputPath, markdown);
+    return {
+      content: [{ type: "text", text: markdown }],
+      isError: false
+    };
+  }
   async start() {
     const transport = new StdioServerTransport();
     await this.server.connect(transport);