@stackmemoryai/stackmemory 1.10.5 → 1.14.0

package/dist/src/mcp/stackmemory-mcp-server.js

@@ -18,6 +18,11 @@ import {
 import { FrameManager } from "../core/context/index.js";
 import { AgentTaskManager } from "../agents/core/agent-task-manager.js";
 import { logger } from "../core/monitoring/logger.js";
+import { ContentCache } from "../core/cache/content-cache.js";
+import { getSkillPackRegistry } from "../core/skill-packs/index.js";
+import { ProvenanceStore } from "../core/provenance/provenance-store.js";
+import { scoreConfidence } from "../core/provenance/confidence-scorer.js";
+import { Raindrop } from "raindrop-ai";
 const PROJECT_ROOT = process.env["STACKMEMORY_PROJECT"] || process.cwd();
 const stackmemoryDir = join(PROJECT_ROOT, ".stackmemory");
 if (!existsSync(stackmemoryDir)) {
@@ -27,6 +32,13 @@ const db = new Database(join(stackmemoryDir, "cache.db"));
 const taskStore = new LinearTaskManager(PROJECT_ROOT, db);
 const frameManager = new FrameManager(db, PROJECT_ROOT, void 0);
 const agentTaskManager = new AgentTaskManager(taskStore, frameManager);
+const contentCacheDb = new Database(join(stackmemoryDir, "content-cache.db"));
+const contentCache = new ContentCache(contentCacheDb);
+const provenanceDb = new Database(join(stackmemoryDir, "provenance.db"));
+const provenanceStore = new ProvenanceStore(provenanceDb);
+const packRegistry = getSkillPackRegistry();
+const raindropEndpoint = process.env["RAINDROP_LOCAL_DEBUGGER"] || process.env["RAINDROP_ENDPOINT"];
+const raindrop = raindropEndpoint ? new Raindrop({ endpoint: raindropEndpoint }) : null;
 let _claudeSessionId = null;
 let claudeFrameId = null;
 const TOOLS = [
@@ -182,6 +194,137 @@ const TOOLS = [
       },
       required: ["sessionId"]
     }
+  },
+  // ── Content Cache ───────────────────────────────────────────────────
+  {
+    name: "cache_lookup",
+    description: "Check if content has been seen before. Returns cache hit/miss and token savings.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        content: { type: "string", description: "Content to check/cache" },
+        source: {
+          type: "string",
+          description: 'Where this content came from (e.g. "file:src/index.ts")'
+        }
+      },
+      required: ["content"]
+    }
+  },
+  {
+    name: "cache_stats",
+    description: "Get content cache statistics: total entries, tokens cached, tokens saved, hit rate.",
+    inputSchema: {
+      type: "object",
+      properties: {}
+    }
+  },
+  // ── Skill Packs ─────────────────────────────────────────────────────
+  {
+    name: "pack_list",
+    description: "List installed skill packs, optionally filtered by namespace.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        namespace: {
+          type: "string",
+          description: 'Filter by namespace (e.g. "coding", "ops")'
+        }
+      }
+    }
+  },
+  {
+    name: "pack_search",
+    description: "Search installed skill packs by keyword.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        query: { type: "string", description: "Search keyword" }
+      },
+      required: ["query"]
+    }
+  },
+  {
+    name: "pack_get",
+    description: "Get full details of a skill pack including instructions and MCP tools.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        name: {
+          type: "string",
+          description: 'Pack name (e.g. "coding/typescript-react")'
+        }
+      },
+      required: ["name"]
+    }
+  },
+  // ── Provenance ──────────────────────────────────────────────────────
+  {
+    name: "record_trace",
+    description: "Record a provenance-tracked trace event with actor, operation, and source lineage.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        traceId: { type: "string", description: "Unique trace ID" },
+        sessionId: { type: "string", description: "Session ID" },
+        tenantId: { type: "string", description: "Tenant ID" },
+        operation: {
+          type: "string",
+          description: 'What happened (e.g. "query", "decision", "edit")'
+        },
+        host: {
+          type: "string",
+          description: 'Agent host (e.g. "claude-code", "cursor")'
+        },
+        inputs: { type: "object", description: "Operation inputs" },
+        outputs: { type: "object", description: "Operation outputs" },
+        tokensIn: { type: "number", description: "Input tokens" },
+        tokensOut: { type: "number", description: "Output tokens" },
+        costUsd: { type: "number", description: "Cost in USD" },
+        parentTraceId: { type: "string", description: "Parent trace ID" },
+        score: { type: "number", description: "Numeric evaluation score" },
+        feedback: {
+          type: "string",
+          description: "Textual feedback for optimization"
+        },
+        confidence: {
+          type: "number",
+          description: "Confidence level (0-1)",
+          minimum: 0,
+          maximum: 1
+        },
+        sources: {
+          type: "array",
+          items: {
+            type: "object",
+            properties: {
+              system: { type: "string" },
+              externalId: { type: "string" },
+              url: { type: "string" }
+            },
+            required: ["system", "externalId"]
+          },
+          description: "Source references for provenance"
+        }
+      },
+      required: ["traceId", "sessionId", "tenantId", "operation"]
+    }
+  },
+  {
+    name: "score_confidence",
+    description: "Score text for decision confidence. Returns confidence (0-1), signals, and classification (accept/review/discard).",
+    inputSchema: {
+      type: "object",
+      properties: {
+        text: { type: "string", description: "Text to score" },
+        actor: { type: "string", description: "Who said it (boosts score)" },
+        replyCount: {
+          type: "number",
+          description: "Thread reply count (boosts if >2)"
+        }
+      },
+      required: ["text"]
+    }
   }
 ];
 const server = new Server(
@@ -210,92 +353,122 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
       ]
     };
   }
+  const interaction = raindrop?.begin({
+    eventId: `mcp-${name}-${Date.now()}`,
+    event: name,
+    userId: "mcp-server",
+    input: JSON.stringify(args).slice(0, 2e3),
+    properties: { tool: name, host: "stackmemory-mcp" }
+  });
   try {
-    switch (name) {
-      case "create_task": {
-        const taskArgs = args;
-        if (!claudeFrameId) {
-          claudeFrameId = frameManager.createFrame({
-            type: "task",
-            name: "Claude AI Session",
-            inputs: { source: "mcp", timestamp: (/* @__PURE__ */ new Date()).toISOString() }
-          });
+    const result = await handleTool(name, args);
+    const outputText = result.content?.[0]?.text;
+    interaction?.finish({ output: outputText?.slice(0, 2e3) });
+    return result;
+  } catch (error) {
+    interaction?.finish({
+      output: `Error: ${error instanceof Error ? error.message : String(error)}`
+    });
+    logger.error(
+      "MCP tool execution failed",
+      error instanceof Error ? error : void 0
+    );
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Error: ${error instanceof Error ? error.message : String(error)}`
         }
-        const taskId = taskStore.createTask({
-          title: taskArgs.title,
-          description: taskArgs.description,
-          priority: taskArgs.priority || "medium",
-          frameId: claudeFrameId,
-          tags: taskArgs.tags || ["claude-generated"]
+      ]
+    };
+  }
+});
+async function handleTool(name, args) {
+  switch (name) {
+    case "create_task": {
+      const taskArgs = args;
+      if (!claudeFrameId) {
+        claudeFrameId = frameManager.createFrame({
+          type: "task",
+          name: "Claude AI Session",
+          inputs: { source: "mcp", timestamp: (/* @__PURE__ */ new Date()).toISOString() }
         });
-        if (taskArgs.autoExecute) {
-          const session = await agentTaskManager.startTaskSession(
-            taskId,
-            claudeFrameId
-          );
-          _claudeSessionId = session.id;
-          return {
-            content: [
-              {
-                type: "text",
-                text: `Task created: ${taskId}
-Agent session started: ${session.id}
-Ready for execution with ${session.maxTurns} turns available.`
-              }
-            ]
-          };
-        }
-        return {
-          content: [
-            {
-              type: "text",
-              text: `Task created successfully: ${taskId}`
-            }
-          ]
-        };
       }
-      case "execute_task": {
-        const execArgs = args;
-        if (!claudeFrameId) {
-          claudeFrameId = frameManager.createFrame({
-            type: "task",
-            name: "Claude Task Execution",
-            inputs: { taskId: execArgs.taskId }
-          });
-        }
+      const taskId = taskStore.createTask({
+        title: taskArgs.title,
+        description: taskArgs.description,
+        priority: taskArgs.priority || "medium",
+        frameId: claudeFrameId,
+        tags: taskArgs.tags || ["claude-generated"]
+      });
+      if (taskArgs.autoExecute) {
         const session = await agentTaskManager.startTaskSession(
-          execArgs.taskId,
+          taskId,
           claudeFrameId
         );
-        if (execArgs.maxTurns) {
-          session.maxTurns = execArgs.maxTurns;
-        }
         _claudeSessionId = session.id;
         return {
           content: [
             {
               type: "text",
-              text: `Started agent session: ${session.id}
-Task: ${execArgs.taskId}
-Max turns: ${session.maxTurns}
-Use 'agent_turn' to execute actions.`
+              text: `Task created: ${taskId}
+Agent session started: ${session.id}
+Ready for execution with ${session.maxTurns} turns available.`
             }
           ]
         };
       }
-      case "agent_turn": {
-        const turnArgs = args;
-        const result = await agentTaskManager.executeTurn(
-          turnArgs.sessionId,
-          turnArgs.action,
-          turnArgs.context || {}
-        );
-        const verificationSummary = result.verificationResults.map((v) => `${v.passed ? "\u2713" : "\u2717"} ${v.verifierId}: ${v.message}`).join("\n");
-        return {
-          content: [
-            {
-              type: "text",
-              text: `Turn executed:
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Task created successfully: ${taskId}`
+          }
+        ]
+      };
+    }
+    case "execute_task": {
+      const execArgs = args;
+      if (!claudeFrameId) {
+        claudeFrameId = frameManager.createFrame({
+          type: "task",
+          name: "Claude Task Execution",
+          inputs: { taskId: execArgs.taskId }
+        });
+      }
+      const session = await agentTaskManager.startTaskSession(
+        execArgs.taskId,
+        claudeFrameId
+      );
+      if (execArgs.maxTurns) {
+        session.maxTurns = execArgs.maxTurns;
+      }
+      _claudeSessionId = session.id;
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Started agent session: ${session.id}
+Task: ${execArgs.taskId}
+Max turns: ${session.maxTurns}
+Use 'agent_turn' to execute actions.`
+          }
+        ]
+      };
+    }
+    case "agent_turn": {
+      const turnArgs = args;
+      const result = await agentTaskManager.executeTurn(
+        turnArgs.sessionId,
+        turnArgs.action,
+        turnArgs.context || {}
+      );
+      const verificationSummary = result.verificationResults.map((v) => `${v.passed ? "\u2713" : "\u2717"} ${v.verifierId}: ${v.message}`).join("\n");
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Turn executed:
 Success: ${result.success}
 Should Continue: ${result.shouldContinue}
 
@@ -304,220 +477,384 @@ ${result.feedback}
 
 Verifications:
 ${verificationSummary}`
-            }
-          ]
-        };
-      }
-      case "task_status": {
-        const statusArgs = args;
-        if (statusArgs.taskId) {
-          const task = taskStore.getTask(statusArgs.taskId);
-          if (!task) {
-            return {
-              content: [
-                { type: "text", text: `Task ${statusArgs.taskId} not found` }
-              ]
-            };
           }
+        ]
+      };
+    }
+    case "task_status": {
+      const statusArgs = args;
+      if (statusArgs.taskId) {
+        const task = taskStore.getTask(statusArgs.taskId);
+        if (!task) {
           return {
             content: [
-              {
-                type: "text",
-                text: `Task: ${task.title}
-Status: ${task.status}
-Priority: ${task.priority}
-Created: ${new Date(task.created_at * 1e3).toLocaleString()}
-Description: ${task.description || "N/A"}`
-              }
+              { type: "text", text: `Task ${statusArgs.taskId} not found` }
             ]
           };
         }
-        const activeTasks = taskStore.getActiveTasks();
-        const taskList = activeTasks.map((t) => `- ${t.id}: ${t.title} (${t.status}, ${t.priority})`).join("\n");
         return {
           content: [
             {
               type: "text",
-              text: `Active tasks (${activeTasks.length}):
-${taskList || "No active tasks"}`
+              text: `Task: ${task.title}
+Status: ${task.status}
+Priority: ${task.priority}
+Created: ${new Date(task.created_at * 1e3).toLocaleString()}
+Description: ${task.description || "N/A"}`
             }
           ]
         };
       }
-      case "save_context": {
-        const saveArgs = args;
-        if (!claudeFrameId) {
-          claudeFrameId = frameManager.createFrame({
-            type: "task",
-            name: "Claude Context",
-            inputs: { source: "mcp" }
-          });
-        }
-        const eventId = frameManager.addEvent(
-          "observation",
+      const activeTasks = taskStore.getActiveTasks();
+      const taskList = activeTasks.map((t) => `- ${t.id}: ${t.title} (${t.status}, ${t.priority})`).join("\n");
+      return {
+        content: [
           {
-            type: saveArgs.type,
-            content: saveArgs.content,
-            importance: saveArgs.importance || 0.5,
-            source: "claude-mcp",
-            timestamp: (/* @__PURE__ */ new Date()).toISOString()
-          },
-          claudeFrameId
-        );
-        return {
-          content: [
-            {
-              type: "text",
-              text: `Context saved to frame ${claudeFrameId} as event ${eventId}`
-            }
-          ]
-        };
+            type: "text",
+            text: `Active tasks (${activeTasks.length}):
+${taskList || "No active tasks"}`
+          }
+        ]
+      };
+    }
+    case "save_context": {
+      const saveArgs = args;
+      if (!claudeFrameId) {
+        claudeFrameId = frameManager.createFrame({
+          type: "task",
+          name: "Claude Context",
+          inputs: { source: "mcp" }
+        });
       }
-      case "load_context": {
-        const loadArgs = args;
-        const frames = frameManager.getActiveFramePath();
-        const limit = loadArgs.limit || 10;
-        const events = loadArgs.frameId ? frameManager.getFrameEvents(loadArgs.frameId, limit) : [];
-        const contextText = frames.map(
-          (frame) => `[Frame ${frame.type}] ${frame.name}: ${frame.digest_text || "No digest"}`
-        ).concat(
-          events.map(
-            (event) => `[Event ${event.event_type}] ${new Date(event.ts).toLocaleString()}: ${JSON.stringify(
-              event.payload
-            ).substring(0, 100)}...`
-          )
-        ).join("\n\n");
+      const eventId = frameManager.addEvent(
+        "observation",
+        {
+          type: saveArgs.type,
+          content: saveArgs.content,
+          importance: saveArgs.importance || 0.5,
+          source: "claude-mcp",
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        },
+        claudeFrameId
+      );
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Context saved to frame ${claudeFrameId} as event ${eventId}`
+          }
+        ]
+      };
+    }
+    case "load_context": {
+      const loadArgs = args;
+      const frames = frameManager.getActiveFramePath();
+      const limit = loadArgs.limit || 10;
+      const events = loadArgs.frameId ? frameManager.getFrameEvents(loadArgs.frameId, limit) : [];
+      const contextText = frames.map(
+        (frame) => `[Frame ${frame.type}] ${frame.name}: ${frame.digest_text || "No digest"}`
+      ).concat(
+        events.map(
+          (event) => `[Event ${event.event_type}] ${new Date(event.ts).toLocaleString()}: ${JSON.stringify(
+            event.payload
+          ).substring(0, 100)}...`
+        )
+      ).join("\n\n");
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Query: ${loadArgs.query}
+Found ${frames.length} frames and ${events.length} events:
+
+${contextText || "No matching context found"}`
+          }
+        ]
+      };
+    }
+    case "breakdown_task": {
+      const breakdownArgs = args;
+      const task = taskStore.getTask(breakdownArgs.taskId);
+      if (!task) {
         return {
           content: [
             {
               type: "text",
-              text: `Query: ${loadArgs.query}
-Found ${frames.length} frames and ${events.length} events:
-
-${contextText || "No matching context found"}`
+              text: `Task ${breakdownArgs.taskId} not found`
             }
           ]
         };
       }
-      case "breakdown_task": {
-        const breakdownArgs = args;
-        const task = taskStore.getTask(breakdownArgs.taskId);
-        if (!task) {
-          return {
-            content: [
-              { type: "text", text: `Task ${breakdownArgs.taskId} not found` }
-            ]
-          };
-        }
-        const subtasks = [
-          `1. Analyze: ${task.title} - Understand requirements (2 turns)`,
-          `2. Design: ${task.title} - Create implementation plan (2 turns)`,
-          `3. Implement: ${task.title} - Build core functionality (5 turns)`,
-          `4. Test: ${task.title} - Validate and verify (3 turns)`,
-          `5. Polish: ${task.title} - Documentation and cleanup (1 turn)`
-        ].join("\n");
-        return {
-          content: [
-            {
-              type: "text",
-              text: `Task breakdown for: ${task.title}
+      const subtasks = [
+        `1. Analyze: ${task.title} - Understand requirements (2 turns)`,
+        `2. Design: ${task.title} - Create implementation plan (2 turns)`,
+        `3. Implement: ${task.title} - Build core functionality (5 turns)`,
+        `4. Test: ${task.title} - Validate and verify (3 turns)`,
+        `5. Polish: ${task.title} - Documentation and cleanup (1 turn)`
+      ].join("\n");
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Task breakdown for: ${task.title}
 
 ${subtasks}
 
 Total estimated turns: 13`
-            }
-          ]
-        };
-      }
-      case "list_active_sessions": {
-        const sessions = agentTaskManager.getActiveSessions();
-        const sessionList = sessions.map(
-          (s) => `- ${s.sessionId}: Task ${s.taskId} (Turn ${s.turnCount}, ${s.status})`
-        ).join("\n");
+          }
+        ]
+      };
+    }
+    case "list_active_sessions": {
+      const sessions = agentTaskManager.getActiveSessions();
+      const sessionList = sessions.map(
+        (s) => `- ${s.sessionId}: Task ${s.taskId} (Turn ${s.turnCount}, ${s.status})`
+      ).join("\n");
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Active sessions (${sessions.length}):
+${sessionList || "No active sessions"}`
+          }
+        ]
+      };
+    }
+    case "retry_session": {
+      const retryArgs = args;
+      const newSession = await agentTaskManager.retrySession(
+        retryArgs.sessionId
+      );
+      if (!newSession) {
         return {
           content: [
             {
               type: "text",
-              text: `Active sessions (${sessions.length}):
-${sessionList || "No active sessions"}`
+              text: "Cannot retry session (max retries reached or session is still active)"
             }
           ]
         };
       }
-      case "retry_session": {
-        const retryArgs = args;
-        const newSession = await agentTaskManager.retrySession(
-          retryArgs.sessionId
-        );
-        if (!newSession) {
-          return {
-            content: [
-              {
-                type: "text",
-                text: "Cannot retry session (max retries reached or session is still active)"
-              }
-            ]
-          };
-        }
-        _claudeSessionId = newSession.id;
+      _claudeSessionId = newSession.id;
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Retry session started: ${newSession.id}
+Task: ${newSession.taskId}
+Incorporating learned context from previous attempts.`
+          }
+        ]
+      };
+    }
+    case "session_feedback": {
+      const feedbackArgs = args;
+      const sessions = agentTaskManager.getActiveSessions();
+      const session = sessions.find(
+        (s) => s.sessionId === feedbackArgs.sessionId
+      );
+      if (!session) {
         return {
           content: [
             {
               type: "text",
-              text: `Retry session started: ${newSession.id}
-Task: ${newSession.taskId}
-Incorporating learned context from previous attempts.`
+              text: `Session ${feedbackArgs.sessionId} not found or not active`
             }
           ]
         };
       }
-      case "session_feedback": {
-        const feedbackArgs = args;
-        const sessions = agentTaskManager.getActiveSessions();
-        const session = sessions.find(
-          (s) => s.sessionId === feedbackArgs.sessionId
-        );
-        if (!session) {
-          return {
-            content: [
-              {
-                type: "text",
-                text: `Session ${feedbackArgs.sessionId} not found or not active`
-              }
-            ]
-          };
-        }
-        return {
-          content: [
-            {
-              type: "text",
-              text: `Session ${feedbackArgs.sessionId}:
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Session ${feedbackArgs.sessionId}:
 Turn: ${session.turnCount}
 Status: ${session.status}
 
 Ready for next action.`
-            }
-          ]
+          }
+        ]
+      };
+    }
+    // ── Content Cache handlers ──────────────────────────────────────
+    case "cache_lookup": {
+      const { content, source } = args;
+      const result = contentCache.lookup(content, source ?? "mcp");
+      if (!result.hit) {
+        contentCache.put(content, source ?? "mcp");
+      }
+      return {
+        content: [
+          {
+            type: "text",
+            text: result.hit ? `Cache HIT (hash: ${result.hash.slice(0, 12)}...). Tokens saved: ${result.tokensSaved}. Total hits: ${result.entry?.hitCount ?? 0}.` : `Cache MISS (hash: ${result.hash.slice(0, 12)}...). Content cached for future dedup.`
+          }
+        ]
+      };
+    }
+    case "cache_stats": {
+      const stats = contentCache.getStats();
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Content Cache Stats:
+  Entries: ${stats.totalEntries}
+  Tokens cached: ${stats.totalTokensCached}
+  Tokens saved: ${stats.totalTokensSaved}
+  Hit rate: ${(stats.hitRate * 100).toFixed(1)}%
+  Top sources: ${stats.topSources.map((s) => `${s.source} (${s.tokensSaved} saved)`).join(", ") || "none"}`
+          }
+        ]
+      };
+    }
+    // ── Skill Pack handlers ─────────────────────────────────────────
+    case "pack_list": {
+      const { namespace } = args;
+      const packs = packRegistry.list(namespace ? { namespace } : void 0);
+      if (packs.length === 0) {
+        return {
+          content: [{ type: "text", text: "No packs installed." }]
         };
       }
-      default:
-        throw new Error(`Unknown tool: ${name}`);
+      const list = packs.map((p) => {
+        const tools = p.manifest.mcp?.tools?.length ?? 0;
+        return `- ${p.manifest.name} v${p.manifest.version} (${tools} tools) \u2014 ${p.manifest.description}`;
+      }).join("\n");
+      return {
+        content: [
+          {
+            type: "text",
+            text: `${packs.length} pack(s) installed:
+${list}`
+          }
+        ]
+      };
     }
-  } catch (error) {
-    logger.error(
-      "MCP tool execution failed",
-      error instanceof Error ? error : void 0
-    );
-    return {
-      content: [
-        {
-          type: "text",
-          text: `Error: ${error instanceof Error ? error.message : String(error)}`
+    case "pack_search": {
+      const { query } = args;
+      const results = packRegistry.search(query);
+      if (results.length === 0) {
+        return {
+          content: [{ type: "text", text: `No packs matching "${query}".` }]
+        };
+      }
+      const list = results.map(
+        (p) => `- ${p.manifest.name} v${p.manifest.version} \u2014 ${p.manifest.description}`
+      ).join("\n");
+      return {
+        content: [
+          {
+            type: "text",
+            text: `${results.length} result(s) for "${query}":
+${list}`
+          }
+        ]
+      };
+    }
+    case "pack_get": {
+      const { name: packName } = args;
+      const pack = packRegistry.get(packName);
+      if (!pack) {
+        return {
+          content: [{ type: "text", text: `Pack "${packName}" not found.` }]
+        };
+      }
+      const m = pack.manifest;
+      const tools = m.mcp?.tools?.map((t) => `  - ${t.name}: ${t.description}`).join("\n");
+      const examples = m.examples?.map((e) => `  Q: ${e.input}
+  A: ${e.output}`).join("\n\n");
+      return {
+        content: [
+          {
+            type: "text",
+            text: [
+              `${m.name} v${m.version}`,
+              m.description,
+              `Author: ${m.author} | License: ${m.license}`,
+              `Runtime: ${m.runtime?.type ?? "local"}`,
+              tools ? `
+MCP Tools:
+${tools}` : "",
+              examples ? `
+Examples:
+${examples}` : "",
+              pack.instructions ? `
+Instructions:
+${pack.instructions}` : ""
+            ].filter(Boolean).join("\n")
+          }
+        ]
+      };
+    }
+    // ── Provenance handlers ─────────────────────────────────────────
+    case "record_trace": {
+      const a = args;
+      const event = {
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        traceId: a["traceId"],
+        sessionId: a["sessionId"],
+        tenantId: a["tenantId"],
+        operation: a["operation"],
+        actor: {
+          host: a["host"] || "unknown",
+          agent: "mcp",
+          user: "unknown"
+        },
+        inputs: a["inputs"] ?? null,
+        outputs: a["outputs"] ?? null,
+        tokensIn: a["tokensIn"] || 0,
+        tokensOut: a["tokensOut"] || 0,
+        costUsd: a["costUsd"] || 0,
+        provenance: {
+          sources: (a["sources"] || []).map(
+            (s) => ({
+              system: s["system"] ?? "",
+              externalId: s["externalId"] ?? "",
+              url: s["url"],
+              fetchedAt: (/* @__PURE__ */ new Date()).toISOString()
+            })
+          ),
+          derivation: [],
+          confidence: a["confidence"] || 0
         }
-      ]
-    };
+      };
+      if (a["parentTraceId"]) {
+        event.parentTraceId = a["parentTraceId"];
+      }
+      if (a["score"] !== void 0) {
+        event.score = a["score"];
+      }
+      if (a["feedback"]) {
+        event.feedback = a["feedback"];
+      }
+      provenanceStore.record(event);
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Trace recorded: ${event.traceId} (${event.operation}, confidence: ${event.provenance.confidence})`
+          }
+        ]
+      };
+    }
+    case "score_confidence": {
+      const { text, actor, replyCount } = args;
+      const result = scoreConfidence(text, { actor, replyCount });
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Confidence: ${result.confidence.toFixed(2)} (${result.classification})
+Signals: ${JSON.stringify(result.signals)}`
+          }
+        ]
+      };
+    }
+    default:
+      throw new Error(`Unknown tool: ${name}`);
   }
-});
+}
 async function main() {
   const transport = new StdioServerTransport();
   await server.connect(transport);
@@ -541,7 +878,10 @@ process.on("SIGINT", async () => {
       );
     }
   }
+  raindrop?.forceFlush();
   db.close();
+  contentCacheDb.close();
+  provenanceDb.close();
   process.exit(0);
 });
 main().catch((error) => {