@stackmemoryai/stackmemory 1.10.5 → 1.12.0

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

@@ -29,20 +29,24 @@ 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 { CrossSearchHandlers } from "./handlers/cross-search-handlers.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 +63,35 @@ 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",
+  "diffmem_get_user_context",
+  "diffmem_search",
+  "diffmem_status",
+  "greptile_list_prs",
+  "greptile_pr_details",
+  "greptile_pr_comments",
+  "greptile_status",
+  "linear_get_tasks",
+  "linear_status",
+  "provenant_search",
+  "provenant_status",
+  "provenant_contradictions"
+]);
 class LocalStackMemoryMCP {
   server;
   db;
@@ -76,9 +109,14 @@ class LocalStackMemoryMCP {
   diffMemHandlers;
   greptileHandlers;
   providerHandlers = null;
-  cordHandlers = null;
-  teamHandlers = null;
+  crossSearchHandlers;
   pendingPlans = /* @__PURE__ */ new Map();
+  contentCache;
+  traceEventStore;
+  sessionId;
+  sessionTokensSaved = 0;
+  sessionCacheHits = 0;
+  sessionCacheMisses = 0;
   constructor() {
     this.projectRoot = this.findProjectRoot();
     this.projectId = this.getProjectId();
@@ -120,6 +158,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(
@@ -151,7 +192,7 @@ class LocalStackMemoryMCP {
     });
     this.diffMemHandlers = new DiffMemHandlers();
     this.greptileHandlers = new GreptileHandlers();
-    this.initCordTeamHandlers();
+    this.crossSearchHandlers = new CrossSearchHandlers({});
     this.initProviderHandlers();
     this.setupHandlers();
     this.loadInitialContext();
@@ -166,6 +207,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,27 +416,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 {
@@ -369,6 +488,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 }
                   },
@@ -972,190 +1096,6 @@ ${summary}...`, 0.8);
             },
             // 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)
@@ -1274,6 +1214,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 +1365,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 +1384,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 +1394,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 {
@@ -1453,104 +1564,6 @@ ${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) {
@@ -1609,6 +1622,35 @@ ${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;
             default:
               throw new Error(`Unknown tool: ${name}`);
           }
@@ -1619,6 +1661,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 +1699,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 +1757,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 +1771,7 @@ ${summary}...`, 0.8);
         maxIters: isFinite(maxIters) ? Math.max(1, maxIters) : 2,
         dryRun: !execute,
         auditDir: void 0,
+        verificationCommands,
         recordFrame
       }
     );
@@ -1833,6 +1932,7 @@ ${summary}...`, 0.8);
     );
     const recordFrame = args.recordFrame !== false;
     const execute = args.execute !== false;
+    const verificationCommands = this.getVerificationCommands(args);
     const result = await runSpike(
       { task: pending.task, repoPath: this.projectRoot },
       {
@@ -1841,6 +1941,7 @@ ${summary}...`, 0.8);
         implementer: implementer === "claude" ? "claude" : "codex",
         maxIters: isFinite(maxIters) ? Math.max(1, maxIters) : 2,
         dryRun: !execute,
+        verificationCommands,
         recordFrame
       }
     );
@@ -3341,6 +3442,19 @@ ${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);
   }
 }
 var server_default = LocalStackMemoryMCP;