@stackmemoryai/stackmemory 1.10.5 → 1.14.0

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

@@ -23,26 +23,32 @@ import {
 } from "fs";
 import { homedir } from "os";
 import { compactPlan } from "../../orchestrators/multimodal/utils.js";
-import { filterPending } from "./pending-utils.js";
+import {
+  parseMasterTasks,
+  getNextTask,
+  addTaskToFile,
+  updateTaskInFile
+} from "../../core/tasks/md-task-parser.js";
 import { join, dirname } from "path";
 import { execSync } from "child_process";
 import { FrameManager } from "../../core/context/index.js";
 import { logger } from "../../core/monitoring/logger.js";
 import { isFeatureEnabled } from "../../core/config/feature-flags.js";
+import { ContentCache } from "../../core/cache/index.js";
+import { TraceEventStore } from "../../core/trace/trace-event-store.js";
 import { BrowserMCPIntegration } from "../../features/browser/browser-mcp.js";
 import { TraceDetector } from "../../core/trace/trace-detector.js";
 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 {
+  resolveToolAlias,
+  resolveParamAliases
+} from "./tool-alias-registry.js";
 import {
   DEFAULT_PLANNER_MODEL,
   DEFAULT_IMPLEMENTER,
@@ -59,6 +65,28 @@ function _getEnv(key, defaultValue) {
 function _getOptionalEnv(key) {
   return process.env[key];
 }
+const CACHEABLE_TOOLS = /* @__PURE__ */ new Set([
+  "get_context",
+  "get_hot_stack",
+  "get_active_tasks",
+  "get_task_metrics",
+  "get_traces",
+  "get_trace_statistics",
+  "smart_context",
+  "get_summary",
+  "sm_discover",
+  "sm_related_files",
+  "sm_session_summary",
+  "sm_search",
+  "sm_cross_search",
+  "sm_cross_discover",
+  "sm_cross_list",
+  "linear_get_tasks",
+  "linear_status",
+  "provenant_search",
+  "provenant_status",
+  "provenant_contradictions"
+]);
 class LocalStackMemoryMCP {
   server;
   db;
@@ -73,12 +101,13 @@ class LocalStackMemoryMCP {
   traceDetector;
   contextRetrieval;
   discoveryHandlers;
-  diffMemHandlers;
-  greptileHandlers;
   providerHandlers = null;
-  cordHandlers = null;
-  teamHandlers = null;
-  pendingPlans = /* @__PURE__ */ new Map();
+  contentCache;
+  traceEventStore;
+  sessionId;
+  sessionTokensSaved = 0;
+  sessionCacheHits = 0;
+  sessionCacheMisses = 0;
   constructor() {
     this.projectRoot = this.findProjectRoot();
     this.projectId = this.getProjectId();
@@ -120,6 +149,9 @@ class LocalStackMemoryMCP {
       );
       CREATE INDEX IF NOT EXISTS idx_edit_telemetry_ts ON edit_telemetry(timestamp);
     `);
+    this.contentCache = new ContentCache(this.db);
+    this.traceEventStore = new TraceEventStore(this.db);
+    this.sessionId = uuidv4();
     this.frameManager = new FrameManager(this.db, this.projectId);
     this.initLinearIfEnabled();
     this.server = new Server(
@@ -149,10 +181,6 @@ class LocalStackMemoryMCP {
       db: this.db,
       projectRoot: this.projectRoot
     });
-    this.diffMemHandlers = new DiffMemHandlers();
-    this.greptileHandlers = new GreptileHandlers();
-    this.initCordTeamHandlers();
-    this.initProviderHandlers();
     this.setupHandlers();
     this.loadInitialContext();
     this.loadPendingPlans();
@@ -166,6 +194,105 @@ class LocalStackMemoryMCP {
       projectId: this.projectId
     });
   }
+  // ------------------------------------------------------------------
+  // Content-hash cache helpers
+  // ------------------------------------------------------------------
+  /**
+   * Build a deterministic cache key from tool name + sorted args.
+   * Returns null for non-cacheable tools or empty args.
+   */
+  buildCacheKey(tool, args) {
+    if (!CACHEABLE_TOOLS.has(tool)) return null;
+    const sorted = JSON.stringify(args, Object.keys(args).sort());
+    return `${tool}:${sorted}`;
+  }
+  handleCacheStats() {
+    const stats = this.contentCache.getStats();
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({
+            session: {
+              cacheHits: this.sessionCacheHits,
+              cacheMisses: this.sessionCacheMisses,
+              tokensSaved: this.sessionTokensSaved,
+              hitRate: this.sessionCacheHits + this.sessionCacheMisses > 0 ? this.sessionCacheHits / (this.sessionCacheHits + this.sessionCacheMisses) : 0
+            },
+            lifetime: stats
+          })
+        }
+      ],
+      isError: false
+    };
+  }
+  handleCacheLookup(args) {
+    const content = String(args.content ?? "");
+    if (!content) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({ error: "content is required" })
+          }
+        ],
+        isError: true
+      };
+    }
+    const result = this.contentCache.lookup(content, String(args.source ?? ""));
+    if (result.hit) {
+      this.sessionCacheHits++;
+      this.sessionTokensSaved += result.tokensSaved;
+    }
+    return {
+      content: [{ type: "text", text: JSON.stringify(result) }],
+      isError: false
+    };
+  }
+  // ------------------------------------------------------------------
+  // Trace event handlers
+  // ------------------------------------------------------------------
+  handleTraceEvents(args) {
+    const events = this.traceEventStore.query({
+      session_id: args.session_id,
+      operation: args.operation,
+      min_score: args.min_score,
+      has_feedback: args.has_feedback,
+      limit: args.limit ?? 50
+    });
+    return {
+      content: [{ type: "text", text: JSON.stringify(events) }],
+      isError: false
+    };
+  }
+  handleTraceEventStats(args) {
+    const stats = this.traceEventStore.getStats({
+      session_id: args.session_id
+    });
+    return {
+      content: [{ type: "text", text: JSON.stringify(stats) }],
+      isError: false
+    };
+  }
+  handleTraceEventAnnotate(args) {
+    const id = String(args.id ?? "");
+    if (!id) {
+      return {
+        content: [
+          { type: "text", text: JSON.stringify({ error: "id is required" }) }
+        ],
+        isError: true
+      };
+    }
+    const ok = this.traceEventStore.annotate(id, {
+      score: args.score,
+      feedback: args.feedback
+    });
+    return {
+      content: [{ type: "text", text: JSON.stringify({ ok, id }) }],
+      isError: false
+    };
+  }
   findProjectRoot() {
     let dir = process.cwd();
     while (dir !== "/") {
@@ -276,37 +403,6 @@ ${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 {
-      const { ProviderHandlers } = await import("./handlers/provider-handlers.js");
-      this.providerHandlers = new ProviderHandlers();
-      logger.info("Provider handlers initialized (multiProvider enabled)");
-    } catch (error) {
-      logger.warn("Failed to initialize provider handlers", { error });
-    }
-  }
   setupHandlers() {
     this.server.setRequestHandler(
       z.object({
@@ -335,7 +431,6 @@ ${summary}...`, 0.8);
             // 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",
@@ -353,14 +448,12 @@ ${summary}...`, 0.8);
                 }
               },
               {
-                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"
+                      type: "string"
                     },
                     implementer: {
                       type: "string",
@@ -369,6 +462,11 @@ ${summary}...`, 0.8);
                       description: "Which agent implements code"
                     },
                     maxIters: { type: "number", default: 2 },
+                    verificationCommands: {
+                      type: "array",
+                      items: { type: "string" },
+                      description: "Optional repro/test commands that must pass after implementation"
+                    },
                     recordFrame: { type: "boolean", default: true },
                     execute: { type: "boolean", default: true }
                   },
@@ -434,15 +532,13 @@ ${summary}...`, 0.8);
                   type: "object",
                   properties: {
                     approvalId: {
-                      type: "string",
-                      description: "Approval id from plan_gate"
+                      type: "string"
                     }
                   },
                   required: ["approvalId"]
                 }
               },
               {
-                name: "plan_only",
                 description: "Generate an implementation plan (Claude) and return JSON only",
                 inputSchema: {
                   type: "object",
@@ -460,7 +556,6 @@ ${summary}...`, 0.8);
                 }
               },
               {
-                name: "call_codex",
                 description: "Invoke Codex via codex-sm with a prompt and args; dry-run by default",
                 inputSchema: {
                   type: "object",
@@ -484,7 +579,6 @@ ${summary}...`, 0.8);
                 }
               },
               {
-                name: "call_claude",
                 description: "Invoke Claude with a prompt (Anthropic SDK)",
                 inputSchema: {
                   type: "object",
@@ -970,194 +1064,8 @@ ${summary}...`, 0.8);
                 required: ["query"]
               }
             },
-            // 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: "cord_spawn",
-              description: "Create a subtask with clean context (spawn). Child sees only its prompt and completed blocker results.",
-              inputSchema: {
-                type: "object",
-                properties: {
-                  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" },
-                    description: "Task IDs that must complete first"
-                  },
-                  parent_id: { type: "string", description: "Parent task ID" }
-                },
-                required: ["goal"]
-              }
-            },
-            {
-              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: {
-                  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" },
-                    description: "Task IDs that must complete first"
-                  },
-                  parent_id: { type: "string", description: "Parent task ID" }
-                },
-                required: ["goal"]
-              }
-            },
-            {
-              name: "cord_complete",
-              description: "Mark a cord task as completed with a result. Automatically unblocks dependent tasks.",
-              inputSchema: {
-                type: "object",
-                properties: {
-                  task_id: {
-                    type: "string",
-                    description: "Task ID to complete"
-                  },
-                  result: {
-                    type: "string",
-                    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"
-                  },
-                  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: "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: ["content"]
-              }
-            },
-            {
-              name: "team_search",
-              description: "Search across all agents' context in the project. Uses full-text search across all sessions.",
-              inputSchema: {
-                type: "object",
-                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)
-            ...process.env.GREPTILE_API_KEY ? this.greptileHandlers.getToolDefinitions() : [],
             // Provider tools (only active when STACKMEMORY_MULTI_PROVIDER=true)
             ...isFeatureEnabled("multiProvider") ? [
               {
@@ -1274,6 +1182,143 @@ ${summary}...`, 0.8);
                 },
                 required: ["period"]
               }
+            },
+            // Cross-project search tools
+            {
+              name: "sm_cross_search",
+              description: "Search frames across all registered project databases using FTS5/BM25. Returns results ranked by relevance with source project attribution.",
+              inputSchema: {
+                type: "object",
+                properties: {
+                  query: {
+                    type: "string",
+                    description: "Search query (natural language or keywords)"
+                  },
+                  limit: {
+                    type: "number",
+                    default: 20,
+                    description: "Maximum results to return"
+                  },
+                  exclude_current: {
+                    type: "boolean",
+                    default: false,
+                    description: "Exclude the current project from results"
+                  }
+                },
+                required: ["query"]
+              }
+            },
+            {
+              name: "sm_cross_discover",
+              description: "Auto-discover project databases by scanning common directories for .stackmemory/context.db files.",
+              inputSchema: {
+                type: "object",
+                properties: {
+                  paths: {
+                    type: "array",
+                    items: { type: "string" },
+                    description: "Custom directory paths to scan"
+                  }
+                }
+              }
+            },
+            {
+              name: "sm_cross_register",
+              description: "Manually register a project database for cross-project search.",
+              inputSchema: {
+                type: "object",
+                properties: {
+                  name: {
+                    type: "string",
+                    description: "Project display name"
+                  },
+                  path: {
+                    type: "string",
+                    description: "Project root directory path"
+                  },
+                  db_path: {
+                    type: "string",
+                    description: "Path to the SQLite context.db file"
+                  }
+                },
+                required: ["name", "path", "db_path"]
+              }
+            },
+            {
+              name: "sm_cross_list",
+              description: "List all project databases registered for cross-project search.",
+              inputSchema: {
+                type: "object",
+                properties: {}
+              }
+            },
+            // Cache tools
+            {
+              name: "cache_stats",
+              description: "Get content-hash cache statistics: session token savings, hit rate, and lifetime totals. Call this to see how many tokens have been saved by deduplication.",
+              inputSchema: {
+                type: "object",
+                properties: {}
+              }
+            },
+            {
+              name: "cache_lookup",
+              description: "Check if content is already cached. Returns hit/miss and token savings. Use for explicit deduplication before sending large content.",
+              inputSchema: {
+                type: "object",
+                properties: {
+                  content: {
+                    type: "string",
+                    description: "The content to check against the cache."
+                  },
+                  source: {
+                    type: "string",
+                    description: 'Optional source label (e.g., "file:src/index.ts").'
+                  }
+                },
+                required: ["content"]
+              }
+            },
+            // Trace event tools
+            {
+              name: "trace_events",
+              description: "Query ASI-shaped trace events. Filter by session, operation, min score, or feedback presence. Returns events with provenance, cost, and token data.",
+              inputSchema: {
+                type: "object",
+                properties: {
+                  session_id: { type: "string" },
+                  operation: { type: "string" },
+                  min_score: { type: "number" },
+                  has_feedback: { type: "boolean" },
+                  limit: { type: "number" }
+                }
+              }
+            },
+            {
+              name: "trace_event_stats",
+              description: "Get aggregate trace event statistics: total tokens, cost, operation counts, host distribution.",
+              inputSchema: {
+                type: "object",
+                properties: {
+                  session_id: { type: "string" }
+                }
+              }
+            },
+            {
+              name: "trace_event_annotate",
+              description: "Add a numeric score and/or textual feedback to a trace event. Used by GEPA-class optimizers.",
+              inputSchema: {
+                type: "object",
+                properties: {
+                  id: { type: "string", description: "Trace event ID" },
+                  score: { type: "number", description: "Numeric score (0-1)" },
+                  feedback: {
+                    type: "string",
+                    description: "Textual ASI feedback"
+                  }
+                },
+                required: ["id"]
+              }
             }
           ]
         };
@@ -1288,7 +1333,18 @@ ${summary}...`, 0.8);
         })
       }),
       async (request) => {
-        const { name, arguments: args } = request.params;
+        const { name: rawName, arguments: rawArgs } = request.params;
+        const aliasResolution = resolveToolAlias(rawName);
+        const name = aliasResolution.canonicalName;
+        const paramResolution = resolveParamAliases(name, rawArgs);
+        const args = paramResolution.resolvedParams;
+        if (aliasResolution.wasAlias || Object.keys(paramResolution.renames).length > 0) {
+          logger.debug("Tool alias resolved", {
+            originalTool: rawName,
+            canonicalTool: name,
+            paramRenames: paramResolution.renames
+          });
+        }
         const callId = uuidv4();
         const startTime = Date.now();
         const currentFrameId = this.frameManager.getCurrentFrameId();
@@ -1296,7 +1352,8 @@ ${summary}...`, 0.8);
           this.frameManager.addEvent("tool_call", {
             tool_name: name,
             arguments: args,
-            timestamp: startTime
+            timestamp: startTime,
+            ...aliasResolution.wasAlias ? { alias_from: rawName } : {}
           });
         }
         const toolCall = {
@@ -1305,6 +1362,28 @@ ${summary}...`, 0.8);
           arguments: args,
           timestamp: startTime
         };
+        const cacheKey = this.buildCacheKey(name, args);
+        if (cacheKey) {
+          const cached = this.contentCache.lookupByKey(
+            cacheKey,
+            `tool:${name}`
+          );
+          if (cached.hit && cached.entry) {
+            this.sessionCacheHits++;
+            this.sessionTokensSaved += cached.tokensSaved;
+            const total = this.sessionCacheHits + this.sessionCacheMisses;
+            const rate = (this.sessionCacheHits / total * 100).toFixed(0);
+            console.error(
+              `[cache] HIT ${name} \u2014 saved ~${cached.tokensSaved} tokens (session: ${this.sessionTokensSaved.toLocaleString()} total, ${rate}% hit rate)`
+            );
+            const cachedResult = JSON.parse(cached.entry.content);
+            toolCall.result = cachedResult;
+            toolCall.duration = Date.now() - startTime;
+            this.traceDetector.addToolCall(toolCall);
+            return cachedResult;
+          }
+          this.sessionCacheMisses++;
+        }
         let result;
         let error;
         try {
@@ -1372,20 +1451,10 @@ ${summary}...`, 0.8);
             case "compress_old_traces":
               result = await this.handleCompressOldTraces(args);
               break;
-            case "plan_only":
-              result = await this.handlePlanOnly(args);
               break;
-            case "call_codex":
-              result = await this.handleCallCodex(args);
               break;
-            case "call_claude":
-              result = await this.handleCallClaude(args);
               break;
-            case "plan_gate":
-              result = await this.handlePlanGate(args);
               break;
-            case "approve_plan":
-              result = await this.handleApprovePlan(args);
               break;
             case "pending_list":
               result = await this.handlePendingList();
@@ -1415,141 +1484,17 @@ ${summary}...`, 0.8);
             case "sm_search":
               result = await this.handleSmSearch(args);
               break;
-            // DiffMem handlers
-            case "diffmem_get_user_context":
-              result = await this.diffMemHandlers.handleGetUserContext(args);
-              break;
-            case "diffmem_store_learning":
-              result = await this.diffMemHandlers.handleStoreLearning(args);
-              break;
-            case "diffmem_search":
-              result = await this.diffMemHandlers.handleSearch(args);
-              break;
-            case "diffmem_status":
-              result = await this.diffMemHandlers.handleStatus();
-              break;
-            // Greptile handlers
-            case "greptile_pr_comments":
-              result = await this.greptileHandlers.handleListPRComments(args);
-              break;
-            case "greptile_pr_details":
-              result = await this.greptileHandlers.handleGetMergeRequest(args);
-              break;
-            case "greptile_list_prs":
-              result = await this.greptileHandlers.handleListPullRequests(args);
-              break;
-            case "greptile_trigger_review":
-              result = await this.greptileHandlers.handleTriggerCodeReview(args);
-              break;
-            case "greptile_search_patterns":
-              result = await this.greptileHandlers.handleSearchPatterns(args);
-              break;
-            case "greptile_create_pattern":
-              result = await this.greptileHandlers.handleCreatePattern(args);
-              break;
-            case "greptile_status":
-              result = await this.greptileHandlers.handleStatus();
-              break;
-            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);
-              }
+              result = await this.diffMemHandlers.handleGetUserContext(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);
-              }
+              result = await this.diffMemHandlers.handleStoreLearning(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);
-              }
+              result = await this.diffMemHandlers.handleSearch(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);
-              }
+              result = await this.diffMemHandlers.handleStatus();
               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);
-              }
+            // Greptile handlers
+            case "sm_edit":
+              result = await this.handleSmEdit(args);
               break;
             // Provider tools
             case "delegate_to_model":
@@ -1609,6 +1554,44 @@ ${summary}...`, 0.8);
             case "sm_desire_paths":
               result = this.handleDesirePaths(args);
               break;
+            case "sm_cross_search":
+              result = await this.crossSearchHandlers.handleCrossSearch(args);
+              break;
+            case "sm_cross_discover":
+              result = await this.crossSearchHandlers.handleCrossDiscover(args);
+              break;
+            case "sm_cross_register":
+              result = await this.crossSearchHandlers.handleCrossRegister(args);
+              break;
+            case "sm_cross_list":
+              result = await this.crossSearchHandlers.handleCrossList();
+              break;
+            // Cache tools
+            case "cache_stats":
+              result = this.handleCacheStats();
+              break;
+            case "cache_lookup":
+              result = this.handleCacheLookup(args);
+              break;
+            // Trace event tools
+            case "trace_events":
+              result = this.handleTraceEvents(args);
+              break;
+            case "trace_event_stats":
+              result = this.handleTraceEventStats(args);
+              break;
+            case "trace_event_annotate":
+              result = this.handleTraceEventAnnotate(args);
+              break;
+            case "get_next_master_task":
+              result = this.handleGetNextMasterTask(args);
+              break;
+            case "update_master_task":
+              result = this.handleUpdateMasterTask(args);
+              break;
+            case "create_master_task":
+              result = this.handleCreateMasterTask(args);
+              break;
             default:
               throw new Error(`Unknown tool: ${name}`);
           }
@@ -1619,6 +1602,22 @@ ${summary}...`, 0.8);
           throw err;
         } finally {
           const endTime = Date.now();
+          if (!error && result && cacheKey) {
+            try {
+              const serialized = JSON.stringify(result);
+              const entry = this.contentCache.putByKey(
+                cacheKey,
+                serialized,
+                `tool:${name}`
+              );
+              if (entry.hitCount === 0) {
+                console.error(
+                  `[cache] STORE ${name} \u2014 ~${entry.tokenCount} tokens cached for future dedup`
+                );
+              }
+            } catch {
+            }
+          }
           if (currentFrameId && name !== "close_frame") {
             try {
               this.frameManager.addEvent("tool_result", {
@@ -1641,11 +1640,50 @@ ${summary}...`, 0.8);
             toolCall.filesAffected = Array.isArray(files) ? files : [files];
           }
           this.traceDetector.addToolCall(toolCall);
+          try {
+            const traceEvent = {
+              timestamp: new Date(startTime).toISOString(),
+              session_id: this.sessionId,
+              trace_id: callId,
+              tenant_id: "local",
+              actor: {
+                host: process.env["STACKMEMORY_HOST"] || "claude-code",
+                agent: "stackmemory-mcp",
+                user: process.env["USER"] || "anonymous"
+              },
+              operation: name,
+              inputs: args,
+              outputs: error ? { error: error.message } : result ?? {},
+              tokens_in: 0,
+              tokens_out: 0,
+              cost_usd: 0,
+              duration_ms: endTime - startTime,
+              error: error?.message,
+              provenance: {
+                sources: [{ type: "tool", id: name }],
+                derivation: ["mcp-call"],
+                confidence: 1
+              }
+            };
+            this.traceEventStore.record(traceEvent);
+          } catch {
+          }
         }
         return result;
       }
     );
   }
+  getVerificationCommands(args) {
+    const commands = args.verificationCommands ?? args.verifyCommands;
+    if (Array.isArray(commands)) {
+      return commands.map((command) => String(command).trim()).filter(Boolean);
+    }
+    const single = args.verificationCommand ?? args.verifyCommand;
+    if (typeof single === "string" && single.trim()) {
+      return [single.trim()];
+    }
+    return [];
+  }
   // Handle plan_and_code tool by invoking the mm harness
   async handlePlanAndCode(args) {
     const { runSpike } = await import("../../orchestrators/multimodal/harness.js");
@@ -1660,6 +1698,7 @@ ${summary}...`, 0.8);
     const record = Boolean(args.record);
     const recordFrame = Boolean(args.recordFrame);
     const compact = Boolean(args.compact);
+    const verificationCommands = this.getVerificationCommands(args);
     const task = String(args.task || "Plan and implement change");
     const result = await runSpike(
       {
@@ -1673,6 +1712,7 @@ ${summary}...`, 0.8);
         maxIters: isFinite(maxIters) ? Math.max(1, maxIters) : 2,
         dryRun: !execute,
         auditDir: void 0,
+        verificationCommands,
         recordFrame
       }
     );
@@ -1696,60 +1736,6 @@ ${summary}...`, 0.8);
       isError: false
     };
   }
-  async handlePlanOnly(args) {
-    const { runPlanOnly } = await import("../../orchestrators/multimodal/harness.js");
-    const task = String(args.task || "Plan change");
-    const plannerModel = args.plannerModel || process.env["STACKMEMORY_MM_PLANNER_MODEL"] || DEFAULT_PLANNER_MODEL;
-    const plan = await runPlanOnly(
-      { task, repoPath: this.projectRoot },
-      { plannerModel }
-    );
-    return {
-      content: [
-        {
-          type: "text",
-          text: JSON.stringify({ ok: true, plan })
-        }
-      ],
-      isError: false
-    };
-  }
-  async handleCallCodex(args) {
-    const { callCodexCLI } = await import("../../orchestrators/multimodal/providers.js");
-    const prompt = String(args.prompt || "");
-    const extraArgs = Array.isArray(args.args) ? args.args : [];
-    const execute = Boolean(args.execute);
-    const resp = callCodexCLI(prompt, extraArgs, !execute);
-    return {
-      content: [
-        {
-          type: "text",
-          text: JSON.stringify({
-            ok: resp.ok,
-            command: resp.command,
-            output: resp.output
-          })
-        }
-      ],
-      isError: false
-    };
-  }
-  async handleCallClaude(args) {
-    const { callClaude } = await import("../../orchestrators/multimodal/providers.js");
-    const prompt = String(args.prompt || "");
-    const model = args.model || process.env["STACKMEMORY_MM_PLANNER_MODEL"] || DEFAULT_PLANNER_MODEL;
-    const system = args.system || "You are a precise assistant. Return plain text unless asked for JSON.";
-    const text = await callClaude(prompt, { model, system });
-    return {
-      content: [
-        {
-          type: "text",
-          text: JSON.stringify({ ok: true, text })
-        }
-      ],
-      isError: false
-    };
-  }
   // Pending plan persistence (best-effort)
   getPendingStoreDir() {
     return join(this.projectRoot, ".stackmemory", "build");
@@ -1773,7 +1759,6 @@ ${summary}...`, 0.8);
       }
       const data = JSON.parse(readFileSync(sourceFile, "utf-8"));
       if (data && typeof data === "object") {
-        this.pendingPlans = new Map(Object.entries(data));
         if (sourceFile !== file) this.savePendingPlans();
       }
     } catch {
@@ -1784,212 +1769,11 @@ ${summary}...`, 0.8);
       const dir = this.getPendingStoreDir();
       if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
       const file = this.getPendingStorePath();
-      const obj = Object.fromEntries(this.pendingPlans);
       writeFileSync(file, JSON.stringify(obj, null, 2));
     } catch {
     }
   }
-  async handlePlanGate(args) {
-    const { runPlanOnly } = await import("../../orchestrators/multimodal/harness.js");
-    const task = String(args.task || "Plan change");
-    const plannerModel = args.plannerModel || process.env["STACKMEMORY_MM_PLANNER_MODEL"] || DEFAULT_PLANNER_MODEL;
-    const plan = await runPlanOnly(
-      { task, repoPath: this.projectRoot },
-      { plannerModel }
-    );
-    const approvalId = `appr_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
-    this.pendingPlans.set(approvalId, { task, plan, createdAt: Date.now() });
-    this.savePendingPlans();
-    const compact = Boolean(args.compact);
-    const planOut = compact ? compactPlan(plan) : plan;
-    return {
-      content: [
-        {
-          type: "text",
-          text: JSON.stringify({ ok: true, approvalId, plan: planOut })
-        }
-      ],
-      isError: false
-    };
-  }
-  async handleApprovePlan(args) {
-    const { runSpike } = await import("../../orchestrators/multimodal/harness.js");
-    const approvalId = String(args.approvalId || "");
-    const pending = this.pendingPlans.get(approvalId);
-    if (!pending) {
-      return {
-        content: [
-          {
-            type: "text",
-            text: JSON.stringify({ ok: false, error: "Invalid approvalId" })
-          }
-        ],
-        isError: false
-      };
-    }
-    const implementer = args.implementer || process.env["STACKMEMORY_MM_IMPLEMENTER"] || DEFAULT_IMPLEMENTER;
-    const maxIters = Number(
-      args.maxIters ?? process.env["STACKMEMORY_MM_MAX_ITERS"] ?? DEFAULT_MAX_ITERS
-    );
-    const recordFrame = args.recordFrame !== false;
-    const execute = args.execute !== false;
-    const result = await runSpike(
-      { task: pending.task, repoPath: this.projectRoot },
-      {
-        plannerModel: process.env["STACKMEMORY_MM_PLANNER_MODEL"] || DEFAULT_PLANNER_MODEL,
-        reviewerModel: process.env["STACKMEMORY_MM_REVIEWER_MODEL"] || process.env["STACKMEMORY_MM_PLANNER_MODEL"] || DEFAULT_PLANNER_MODEL,
-        implementer: implementer === "claude" ? "claude" : "codex",
-        maxIters: isFinite(maxIters) ? Math.max(1, maxIters) : 2,
-        dryRun: !execute,
-        recordFrame
-      }
-    );
-    this.pendingPlans.delete(approvalId);
-    this.savePendingPlans();
-    const compact = Boolean(args.compact);
-    const payload = compact ? { ...result, plan: compactPlan(result.plan) } : result;
-    return {
-      content: [
-        {
-          type: "text",
-          text: JSON.stringify({ ok: true, approvalId, result: payload })
-        }
-      ],
-      isError: false
-    };
-  }
-  async handlePendingList(args) {
-    const schema = z.object({
-      taskContains: z.string().optional(),
-      olderThanMs: z.number().optional(),
-      newerThanMs: z.number().optional(),
-      sort: z.enum(["asc", "desc"]).optional(),
-      limit: z.number().int().positive().optional()
-    }).optional();
-    const parsed = schema.safeParse(args);
-    if (args && !parsed.success) {
-      return {
-        content: [
-          {
-            type: "text",
-            text: JSON.stringify({
-              ok: false,
-              error: "Invalid arguments",
-              details: parsed.error.issues
-            })
-          }
-        ],
-        isError: false
-      };
-    }
-    const a = parsed.success && parsed.data ? parsed.data : {};
-    const now = Date.now();
-    let items = Array.from(this.pendingPlans.entries()).map(
-      ([approvalId, data]) => ({
-        approvalId,
-        task: data?.task,
-        createdAt: Number(data?.createdAt || 0) || null
-      })
-    );
-    items = filterPending(items, a, now);
-    return {
-      content: [
-        { type: "text", text: JSON.stringify({ ok: true, pending: items }) }
-      ],
-      isError: false
-    };
-  }
-  async handlePendingClear(args) {
-    const removed = [];
-    const now = Date.now();
-    const all = Boolean(args?.all);
-    const approvalId = args?.approvalId ? String(args.approvalId) : void 0;
-    const olderThanMs = Number.isFinite(Number(args?.olderThanMs)) ? Number(args.olderThanMs) : void 0;
-    if (all) {
-      for (const id of this.pendingPlans.keys()) removed.push(id);
-      this.pendingPlans.clear();
-      this.savePendingPlans();
-      return {
-        content: [
-          { type: "text", text: JSON.stringify({ ok: true, removed }) }
-        ],
-        isError: false
-      };
-    }
-    if (approvalId) {
-      if (this.pendingPlans.has(approvalId)) {
-        this.pendingPlans.delete(approvalId);
-        removed.push(approvalId);
-        this.savePendingPlans();
-      }
-      return {
-        content: [
-          { type: "text", text: JSON.stringify({ ok: true, removed }) }
-        ],
-        isError: false
-      };
-    }
-    if (olderThanMs !== void 0 && olderThanMs >= 0) {
-      for (const [id, data] of this.pendingPlans.entries()) {
-        const ts = Number(data?.createdAt || 0);
-        if (ts && now - ts > olderThanMs) {
-          this.pendingPlans.delete(id);
-          removed.push(id);
-        }
-      }
-      this.savePendingPlans();
-      return {
-        content: [
-          { type: "text", text: JSON.stringify({ ok: true, removed }) }
-        ],
-        isError: false
-      };
-    }
-    return {
-      content: [
-        {
-          type: "text",
-          text: JSON.stringify({
-            ok: false,
-            error: "Specify approvalId, all=true, or olderThanMs"
-          })
-        }
-      ],
-      isError: false
-    };
-  }
-  async handlePendingShow(args) {
-    const approvalId = String(args?.approvalId || "");
-    const data = this.pendingPlans.get(approvalId);
-    if (!data) {
-      return {
-        content: [
-          {
-            type: "text",
-            text: JSON.stringify({ ok: false, error: "Invalid approvalId" })
-          }
-        ],
-        isError: false
-      };
-    }
-    const compact = Boolean(args.compact);
-    const planOut = compact ? compactPlan(data.plan) : data.plan;
-    return {
-      content: [
-        {
-          type: "text",
-          text: JSON.stringify({
-            ok: true,
-            approvalId,
-            task: data.task,
-            plan: planOut,
-            createdAt: data.createdAt || null
-          })
-        }
-      ],
-      isError: false
-    };
-  }
+  // [REMOVED in v1.14] Conductor/multimodal handlers + pending plan handlers
   async handleGetContext(args) {
     const { query: query2 = "", limit = 10 } = args;
     const contexts = Array.from(this.contexts.values()).sort((a, b) => b.importance - a.importance).slice(0, limit);
@@ -3341,6 +3125,123 @@ ${catLines.join("\n")}`
     const transport = new StdioServerTransport();
     await this.server.connect(transport);
     console.error("StackMemory MCP Server started");
+    const printCacheSummary = () => {
+      if (this.sessionCacheHits > 0 || this.sessionCacheMisses > 0) {
+        const total = this.sessionCacheHits + this.sessionCacheMisses;
+        const rate = (this.sessionCacheHits / total * 100).toFixed(1);
+        console.error(
+          `
+\u{1F4CA} Cache: ${this.sessionCacheHits}/${total} hits (${rate}%), ~${this.sessionTokensSaved.toLocaleString()} tokens saved`
+        );
+      }
+    };
+    process.on("SIGINT", printCacheSummary);
+    process.on("SIGTERM", printCacheSummary);
+    process.on("exit", printCacheSummary);
+  }
+  // ── Master Task Handlers ───────────────────────────────────
+  resolveMasterTasksPath() {
+    const smPath = join(
+      this.projectRoot,
+      ".stackmemory",
+      "tasks",
+      "master-tasks.md"
+    );
+    if (existsSync(smPath)) return smPath;
+    const rootPath = join(this.projectRoot, "master-tasks.md");
+    if (existsSync(rootPath)) return rootPath;
+    return null;
+  }
+  handleGetNextMasterTask(args) {
+    const mdPath = this.resolveMasterTasksPath();
+    if (!mdPath) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: 'No master-tasks.md found. Run "stackmemory tasks init" to create one.'
+          }
+        ]
+      };
+    }
+    let tasks = parseMasterTasks(readFileSync(mdPath, "utf-8"));
+    if (args.owner) {
+      tasks = tasks.filter((t) => t.owner === String(args.owner));
+    }
+    const next = getNextTask(tasks);
+    if (!next) {
+      return {
+        content: [{ type: "text", text: "No actionable tasks found." }]
+      };
+    }
+    return {
+      content: [{ type: "text", text: JSON.stringify(next, null, 2) }]
+    };
+  }
+  handleUpdateMasterTask(args) {
+    const mdPath = this.resolveMasterTasksPath();
+    if (!mdPath) {
+      return {
+        content: [{ type: "text", text: "No master-tasks.md found." }]
+      };
+    }
+    const taskId = String(args.task_id || "").toUpperCase();
+    if (!taskId) {
+      return {
+        content: [{ type: "text", text: "task_id is required." }],
+        isError: true
+      };
+    }
+    const updates = {};
+    if (args.status) updates.status = String(args.status);
+    if (args.priority) updates.priority = String(args.priority);
+    if (args.owner) updates.owner = String(args.owner);
+    if (args.branch_pr) updates.branchPr = String(args.branch_pr);
+    if (args.notes) updates.notes = String(args.notes);
+    if (args.sync) updates.sync = String(args.sync);
+    try {
+      updateTaskInFile(mdPath, taskId, updates);
+      return {
+        content: [{ type: "text", text: `Updated ${taskId}` }]
+      };
+    } catch (err) {
+      return {
+        content: [{ type: "text", text: err.message }],
+        isError: true
+      };
+    }
+  }
+  handleCreateMasterTask(args) {
+    const mdPath = this.resolveMasterTasksPath();
+    if (!mdPath) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: 'No master-tasks.md found. Run "stackmemory tasks init" to create one.'
+          }
+        ]
+      };
+    }
+    const task = String(args.task || "");
+    if (!task) {
+      return {
+        content: [{ type: "text", text: "task description is required." }],
+        isError: true
+      };
+    }
+    const id = addTaskToFile(mdPath, {
+      priority: String(args.priority || "P1"),
+      status: "todo",
+      owner: String(args.owner || "@me"),
+      sync: String(args.sync || "local"),
+      task,
+      branchPr: "",
+      notes: String(args.notes || "")
+    });
+    return {
+      content: [{ type: "text", text: `Created ${id}: ${task}` }]
+    };
   }
 }
 var server_default = LocalStackMemoryMCP;