@stackmemoryai/stackmemory 1.12.0 → 1.14.0

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

@@ -22,6 +22,7 @@ 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)) {
@@ -36,6 +37,8 @@ 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 = [
@@ -350,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}
 
@@ -444,393 +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.`
-            }
-          ]
-        };
+          }
+        ]
+      };
+    }
+    // ── 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");
       }
-      case "cache_stats": {
-        const stats = contentCache.getStats();
-        return {
-          content: [
-            {
-              type: "text",
-              text: `Content Cache Stats:
+      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." }]
         };
       }
-      // ── 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." }]
-          };
-        }
-        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:
+      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}`
-            }
-          ]
+          }
+        ]
+      };
+    }
+    case "pack_search": {
+      const { query } = args;
+      const results = packRegistry.search(query);
+      if (results.length === 0) {
+        return {
+          content: [{ type: "text", text: `No packs matching "${query}".` }]
         };
       }
-      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}":
+      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.` }]
         };
       }
-      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}
+      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 ? `
+      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:
 ${examples}` : "",
-                pack.instructions ? `
+              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) => ({
+            ].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"];
+            })
+          ),
+          derivation: [],
+          confidence: a["confidence"] || 0
         }
-        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})`
-            }
-          ]
-        };
+      };
+      if (a["parentTraceId"]) {
+        event.parentTraceId = a["parentTraceId"];
       }
-      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)}`
-            }
-          ]
-        };
+      if (a["score"] !== void 0) {
+        event.score = a["score"];
       }
-      default:
-        throw new Error(`Unknown tool: ${name}`);
+      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})`
+          }
+        ]
+      };
     }
-  } 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 "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);
@@ -854,6 +878,7 @@ process.on("SIGINT", async () => {
       );
     }
   }
+  raindrop?.forceFlush();
   db.close();
   contentCacheDb.close();
   provenanceDb.close();