mergen-server 1.4.0

package/dist/intelligence/tools-intent.js

@@ -0,0 +1,128 @@
+import { z } from "zod";
+import { commitContextStore } from "../sensor/commit-context-store.js";
+import { trackCall } from "./tools-state.js";
+import { recordExplainWhy } from "./usage.js";
+function registerIntentTools(server) {
+  server.registerTool(
+    "explain_why",
+    {
+      description: `Retrieves the causal intent behind a service's current behavior \u2014 the PR titles, business descriptions, linked tickets, and human approvers responsible for the code that exists today. Answers "Why does service X have a 30s timeout?" or "Who approved the retry logic?" without requiring the original author to be on-call. Data comes from the commit intent archive (GitHub PR webhooks). Returns nothing if no PRs have been captured yet \u2014 connect GitHub webhook to POST /webhooks/github first.`,
+      inputSchema: {
+        service: z.string().describe('Service or repo name to query (e.g. "api", "payments-worker", "org/repo").'),
+        behavior: z.string().optional().describe('Optional: specific behavior to explain (e.g. "30s timeout", "retry 3 times", "rate limit 100rps"). Filters results by relevance.'),
+        limit: z.number().int().min(1).max(20).optional().describe("Max PRs to return (default: 5).")
+      }
+    },
+    ({ service, behavior, limit = 5 }) => {
+      trackCall("explain_why");
+      recordExplainWhy();
+      const contexts = commitContextStore.listByRepo(service, limit * 2);
+      if (contexts.length === 0) {
+        const total = commitContextStore.count();
+        if (total === 0) {
+          return {
+            content: [{
+              type: "text",
+              text: [
+                `## Intent Archive: ${service}`,
+                "",
+                "**No PRs captured yet.** Connect GitHub to start building the intent archive:",
+                "",
+                "```",
+                `mergen-server connect github --repo ${service.includes("/") ? service : `<org>/${service}`}`,
+                "```",
+                "",
+                "_Takes 30 seconds. Every PR merged after this populates the archive automatically._",
+                '_Next incident: ask "explain why this service has a 30s timeout" and get the original PR, author, and approver instantly._'
+              ].join("\n")
+            }]
+          };
+        }
+        return {
+          content: [{
+            type: "text",
+            text: [
+              `## Intent Archive: ${service}`,
+              "",
+              `_${total} total contexts in archive \u2014 none matched "${service}"._`,
+              "",
+              `Try the full repo name (e.g. \`org/${service}\`), or connect this repo:`,
+              "",
+              "```",
+              `mergen-server connect github --repo <org>/${service}`,
+              "```"
+            ].join("\n")
+          }]
+        };
+      }
+      let filtered = contexts;
+      if (behavior) {
+        const kw = behavior.toLowerCase();
+        filtered = contexts.filter((c) => {
+          const searchText = [c.prTitle, c.prBody, ...c.linkedIssues.map((i) => i.ref)].join(" ").toLowerCase();
+          return searchText.includes(kw);
+        });
+        if (filtered.length === 0) {
+          return {
+            content: [{
+              type: "text",
+              text: [
+                `## Intent Archive: ${service}`,
+                "",
+                `_No PRs matched "${behavior}" across ${contexts.length} archived PR${contexts.length !== 1 ? "s" : ""} for ${service}._`,
+                "",
+                "Try a broader keyword, or omit `behavior` to see the most recent PRs."
+              ].join("\n")
+            }]
+          };
+        }
+      }
+      const results = filtered.slice(0, limit);
+      const aiCount = results.filter((c) => c.aiGenerated).length;
+      const approvedCount = results.filter((c) => c.approvers.length > 0).length;
+      const lines = [
+        `## Intent Archive: ${service}`,
+        `_${results.length} PR${results.length !== 1 ? "s" : ""} \xB7 ${aiCount} AI-generated \xB7 ${approvedCount} with recorded approvals_`,
+        behavior ? `_Filtered by: "${behavior}"_` : "",
+        ""
+      ].filter(Boolean);
+      for (const ctx of results) {
+        const prRef = ctx.prNumber ? `PR #${ctx.prNumber}` : ctx.sha.slice(0, 7);
+        const aiTag = ctx.aiGenerated ? ` \u{1F916} ${ctx.aiTool ?? "AI-generated"}` : "";
+        const dateStr = ctx.mergedAt ? new Date(ctx.mergedAt).toISOString().slice(0, 10) : new Date(ctx.capturedAt).toISOString().slice(0, 10);
+        lines.push(`### ${prRef}${aiTag} \u2014 ${dateStr}`);
+        if (ctx.prTitle) lines.push(`**${ctx.prTitle}**`);
+        const meta = [];
+        if (ctx.author) meta.push(`Author: @${ctx.author}`);
+        if (ctx.approvers.length) meta.push(`Approved by: ${ctx.approvers.join(", ")}`);
+        else meta.push("\u26A0\uFE0F No recorded approvers");
+        if (ctx.branch) meta.push(`Branch: ${ctx.branch}`);
+        lines.push(`_${meta.join(" \xB7 ")}_`);
+        if (ctx.linkedIssues.length > 0) {
+          lines.push(`**Linked issues:** ${ctx.linkedIssues.slice(0, 5).map((i) => i.ref).join(", ")}`);
+        }
+        if (ctx.prBody) {
+          const summary = ctx.prBody.split("\n").filter((l) => l.trim() && !l.startsWith("#")).slice(0, 3).join(" ").slice(0, 400);
+          if (summary) lines.push(`> ${summary}`);
+        }
+        if (ctx.filesChanged.length > 0) {
+          const files = ctx.filesChanged.slice(0, 5).join(", ");
+          const more = ctx.filesChanged.length > 5 ? ` +${ctx.filesChanged.length - 5} more` : "";
+          lines.push(`_Files: ${files}${more}_`);
+        }
+        lines.push("");
+      }
+      lines.push("---");
+      lines.push(`_Source: commit intent archive \xB7 ${commitContextStore.count()} total contexts captured_`);
+      const feedbackId = `ew-${Date.now().toString(36)}`;
+      lines.push("");
+      lines.push(`_Was this helpful?  \`mergen-server feedback ${feedbackId} --yes\`  or  \`mergen-server feedback ${feedbackId} --no\`_`);
+      return {
+        content: [{ type: "text", text: lines.join("\n") }]
+      };
+    }
+  );
+}
+export {
+  registerIntentTools
+};

package/dist/intelligence/tools-memory.js

@@ -0,0 +1,514 @@
+import { z } from "zod";
+import { memoryStore, formatMttr } from "../datadog/memory-store.js";
+import { agentContextStore as agentMemoryStore } from "../sensor/agent-context-store.js";
+import { getOverrideSummary, getOverridesForTag } from "./override-corpus.js";
+import { getStats, getStatsForTag, getRecords, isCorpusSeeded } from "./calibration.js";
+import { trackCall } from "./tools-state.js";
+function formatRecord(r, index) {
+  const firedAgo = Math.round((Date.now() - r.firedAt) / 6e4);
+  const mttr = r.mttrMs ? formatMttr(r.mttrMs) : "unresolved";
+  const fix = r.fixPrTitle ? `Fix: [${r.fixPrTitle}](${r.fixPrUrl ?? "#"}) (${r.resolutionType})` : r.fixSummary ? `Fix: ${r.fixSummary}` : `Fix: not captured (${r.resolutionType})`;
+  const location = r.implicatedFile ? `\`${r.implicatedFile}${r.implicatedLine ? ":" + r.implicatedLine : ""}\`` : "unknown";
+  return [
+    `**${index + 1}.** \`${new Date(r.firedAt).toISOString().slice(0, 16)}\` \xB7 ${firedAgo}m ago`,
+    `   Service: \`${r.service}\` \xB7 Endpoint: \`${r.endpoint}\``,
+    `   Error: ${r.errorMessage.slice(0, 120)}`,
+    `   Location: ${location}`,
+    `   MTTR: ${mttr} \xB7 ${fix}`,
+    r.deployedSha ? `   Deploy: \`${r.deployedSha.slice(0, 7)}\`` : ""
+  ].filter(Boolean).join("\n");
+}
+function fmtMs(ms) {
+  if (ms < 6e4) return `${Math.round(ms / 1e3)}s`;
+  const min = Math.floor(ms / 6e4);
+  const sec = Math.round(ms % 6e4 / 1e3);
+  return sec > 0 ? `${min}m ${sec}s` : `${min}m`;
+}
+function registerMemoryTools(server) {
+  server.registerTool(
+    "get_incident_history",
+    {
+      description: 'Returns the historical record of past incidents matching the current error pattern. Use this after get_incident_context to answer: "Have we seen this before? How was it fixed? How long did it take?" The fingerprint is a stable hash of error_type + service + endpoint \u2014 same class of bug, same fingerprint. Also returns benchmark statistics (p50 MTTR, most common fix type).',
+      inputSchema: {
+        fingerprint: z.string().optional().describe("16-char hex fingerprint from a previous incident (shown in get_incident_context output)"),
+        service: z.string().optional().describe('Filter by service name instead of fingerprint (e.g. "api", "auth-service", "payments")'),
+        limit: z.number().int().min(1).max(20).optional().describe("Max past incidents to return (default 5)")
+      }
+    },
+    async ({ fingerprint, service, limit = 5 }) => {
+      trackCall("get_incident_history");
+      if (!memoryStore.isHealthy()) {
+        return {
+          content: [{
+            type: "text",
+            text: "\u26A0\uFE0F **Incident memory store is unavailable** (SQLite init failed \u2014 check logs for WASM or file error). History cannot be queried. New incidents will not be persisted until the store recovers on next restart."
+          }]
+        };
+      }
+      if (!fingerprint && !service) {
+        return {
+          content: [{
+            type: "text",
+            text: [
+              "## Incident History",
+              "",
+              "Provide either `fingerprint` (from a Runtime Fact) or `service` to look up history.",
+              "",
+              "**Open incidents right now:**",
+              ...memoryStore.listOpen().slice(0, 5).map((r, i) => formatRecord(r, i))
+            ].join("\n")
+          }]
+        };
+      }
+      let similar;
+      if (fingerprint) {
+        similar = memoryStore.findSimilar(fingerprint, limit);
+      } else {
+        const byService = memoryStore.listAll(500).filter((r) => r.service === service);
+        similar = byService.slice(0, limit);
+        if (similar.length > 0 && similar.length < limit) {
+          const fp2 = similar[0].fingerprint;
+          const extra = memoryStore.findSimilar(fp2, limit).filter(
+            (r) => !similar.some((s) => s.id === r.id)
+          );
+          similar = [...similar, ...extra].slice(0, limit);
+        }
+      }
+      if (similar.length === 0) {
+        return {
+          content: [{
+            type: "text",
+            text: fingerprint ? `No historical incidents found for fingerprint \`${fingerprint}\`.
+
+This is the first time Mergen has seen this error pattern.` : `No historical incidents found for service \`${service}\`.`
+          }]
+        };
+      }
+      const fp = similar[0].fingerprint;
+      const stats = memoryStore.benchmarkStats(fp);
+      const lines = [
+        `## Incident History \u2014 fingerprint \`${fp}\``,
+        ""
+      ];
+      const mostRecent = similar[0];
+      const timeAgo = Math.round((Date.now() - mostRecent.firedAt) / 864e5);
+      const timeDesc = timeAgo === 0 ? "today" : timeAgo === 1 ? "yesterday" : `${timeAgo} days ago`;
+      const lastFixDesc = mostRecent.fixPrTitle ? `[${mostRecent.fixPrTitle}](${mostRecent.fixPrUrl ?? "#"})` : mostRecent.fixSummary ? mostRecent.fixSummary : `Fix pattern (${mostRecent.resolutionType})`;
+      lines.push(
+        `> \u{1F4A1} **Visible Intelligence: "Why did this break again?"**`,
+        `> `,
+        `> \u{1F449} **This error has happened before (${timeDesc}). Here's what you did last time \u2014 and why it worked:**`,
+        `> - **Last Fix:** ${lastFixDesc}`,
+        `> - **Resolution Type:** \`${mostRecent.resolutionType}\``,
+        `> - **Implicated File:** \`${mostRecent.implicatedFile || "unknown"}${mostRecent.implicatedLine ? ":" + mostRecent.implicatedLine : ""}\``,
+        ""
+      );
+      if (stats && stats.occurrences > 1) {
+        const p50 = stats.p50MttrMs ? formatMttr(stats.p50MttrMs) : "N/A";
+        const p90 = stats.p90MttrMs ? formatMttr(stats.p90MttrMs) : "N/A";
+        const lastSeen = stats.lastSeenAt ? `${Math.round((Date.now() - stats.lastSeenAt) / 864e5)}d ago` : "unknown";
+        lines.push(
+          `**Seen ${stats.occurrences} time${stats.occurrences !== 1 ? "s" : ""} \xB7 p50 MTTR: ${p50} \xB7 p90 MTTR: ${p90}**`,
+          `Most common fix: **${stats.topResolutionType}** (${stats.topResolutionCount}/${stats.occurrences} times) \xB7 Last seen: ${lastSeen}`,
+          ""
+        );
+      }
+      lines.push("**Past incidents (most recent first):**", "");
+      for (const [i, r] of similar.entries()) {
+        lines.push(formatRecord(r, i), "");
+      }
+      return { content: [{ type: "text", text: lines.join("\n") }] };
+    }
+  );
+  server.registerTool(
+    "list_open_incidents",
+    {
+      description: "Lists all currently open incidents tracked by Mergen (fired but not yet resolved). Use this to see what is actively burning and whether any GitHub PRs have been correlated.",
+      inputSchema: {}
+    },
+    async () => {
+      trackCall("list_open_incidents");
+      const open = memoryStore.listOpen();
+      if (open.length === 0) {
+        return { content: [{ type: "text", text: "## Open Incidents\n\nNo open incidents. All quiet." }] };
+      }
+      const lines = [`## Open Incidents (${open.length})`, ""];
+      for (const [i, r] of open.entries()) {
+        lines.push(formatRecord(r, i), "");
+      }
+      return { content: [{ type: "text", text: lines.join("\n") }] };
+    }
+  );
+  server.registerTool(
+    "store_agent_memory",
+    {
+      description: "Persist a key\u2013value memory that survives across sessions. Use this to remember patterns, constraints, or context that you should not have to re-discover the next time you are invoked. Tag memories with `service` and `errorFingerprint` to enable episodic recall \u2014 retrieving past context for the exact (service, error) pair you are working on.",
+      inputSchema: {
+        key: z.string().min(1).max(200).describe("Short, human-readable identifier for the memory"),
+        value: z.string().min(1).max(8e3).describe("The content to remember (plain text or JSON)"),
+        agentId: z.string().optional().describe('Identifier for this agent. Defaults to "default"'),
+        ttlMs: z.number().int().min(0).optional().describe("Time-to-live in milliseconds. 0 = permanent"),
+        service: z.string().optional().describe('Service name for episodic indexing (e.g. "api", "auth-service")'),
+        errorFingerprint: z.string().optional().describe("Error fingerprint hash for episodic indexing")
+      }
+    },
+    async ({ key, value, agentId = "default", ttlMs = 0, service = "", errorFingerprint = "" }) => {
+      trackCall("store_agent_memory");
+      if (!agentMemoryStore.isHealthy()) {
+        return {
+          content: [{
+            type: "text",
+            text: "\u26A0\uFE0F **Agent memory store is unavailable** (SQLite init failed). Memory was NOT persisted. Check server logs for the root cause."
+          }]
+        };
+      }
+      const entry = agentMemoryStore.store(agentId, key, value, ttlMs, service, errorFingerprint);
+      return {
+        content: [{ type: "text", text: `Memory stored: "${key}" [id=${entry.id}${service ? `, service=${service}` : ""}]` }]
+      };
+    }
+  );
+  server.registerTool(
+    "recall_agent_memory",
+    {
+      description: "Retrieve previously stored agent memories. Use this at the start of each session to recover patterns and constraints from prior runs. Filter by `service` + `errorFingerprint` for episodic recall \u2014 retrieving exactly the memories relevant to the current incident context.",
+      inputSchema: {
+        key: z.string().optional().describe("Filter to memories with this exact key"),
+        agentId: z.string().optional().describe('Agent ID to scope the recall. Defaults to "default"'),
+        limit: z.number().int().min(1).max(50).optional().describe("Max entries to return (default 10)"),
+        service: z.string().optional().describe("Filter to memories tagged for this service"),
+        errorFingerprint: z.string().optional().describe("Filter to memories tagged for this error fingerprint")
+      }
+    },
+    async ({ key, agentId = "default", limit = 10, service, errorFingerprint }) => {
+      trackCall("recall_agent_memory");
+      if (!agentMemoryStore.isHealthy()) {
+        return {
+          content: [{
+            type: "text",
+            text: "\u26A0\uFE0F **Agent memory store is unavailable** (SQLite init failed \u2014 check logs for WASM or file error). Memories cannot be retrieved. Call `store_agent_memory` to check if the issue has resolved."
+          }]
+        };
+      }
+      const entries = agentMemoryStore.recall(agentId, key, limit, service, errorFingerprint);
+      if (entries.length === 0) {
+        return { content: [{ type: "text", text: "No memories found." }] };
+      }
+      const lines = [`## Agent Memories (${entries.length})`, ""];
+      for (const e of entries) {
+        const expiry = e.ttlMs > 0 ? `  _(expires ${new Date(e.storedAt + e.ttlMs).toISOString()})_` : "";
+        const ctx = [e.service, e.errorFingerprint].filter(Boolean).join("/");
+        lines.push(`### ${e.key}${ctx ? ` [${ctx}]` : ""}${expiry}`, e.value, "");
+      }
+      return { content: [{ type: "text", text: lines.join("\n") }] };
+    }
+  );
+  server.registerTool(
+    "list_agent_memory_keys",
+    {
+      description: "List all memory keys stored for an agent. Use this at the start of a session to discover what was previously stored before calling recall_agent_memory with a specific key. Without this tool, an agent would need to already know the key names \u2014 defeating the purpose of persistent memory.",
+      inputSchema: {
+        agentId: z.string().optional().describe('Agent ID to scope the listing. Defaults to "default".')
+      }
+    },
+    async ({ agentId = "default" }) => {
+      trackCall("list_agent_memory_keys");
+      if (!agentMemoryStore.isHealthy()) {
+        return {
+          content: [{
+            type: "text",
+            text: "\u26A0\uFE0F **Agent memory store is unavailable** (SQLite init failed). Keys cannot be listed."
+          }]
+        };
+      }
+      const keys = agentMemoryStore.listKeys(agentId);
+      if (keys.length === 0) {
+        return {
+          content: [{
+            type: "text",
+            text: `No memories stored for agent \`${agentId}\`.
+
+Call \`store_agent_memory\` to begin persisting context across sessions.`
+          }]
+        };
+      }
+      const lines = [
+        `## Agent Memory Keys \u2014 \`${agentId}\` (${keys.length} key${keys.length !== 1 ? "s" : ""})`,
+        "",
+        ...keys.map((k) => `- **${k.key}** \u2014 last updated ${new Date(k.lastStoredAt).toISOString().slice(0, 16)} UTC`),
+        "",
+        '_Call `recall_agent_memory(key: "...")` to retrieve the value for a specific key._'
+      ];
+      return { content: [{ type: "text", text: lines.join("\n") }] };
+    }
+  );
+  server.registerTool(
+    "get_override_patterns",
+    {
+      description: `Returns the override corpus \u2014 all the times engineers said NO to Mergen's recommendations, categorised by why and when. Use this BEFORE proposing or executing a fix to understand operational constraints that are not encoded in code: Friday batch windows, compliance holds, cost ceilings, or on-call preferences. If a pattern shows "batch-window" overrides every Friday evening for a service, do not propose restarts on Friday evenings. This is the team's institutional knowledge in structured form.`,
+      inputSchema: {
+        service: z.string().optional().describe("Filter to override patterns for a specific service."),
+        tag: z.string().optional().describe('Filter to a specific failure mode tag (e.g. "connection_pool_exhausted").'),
+        limit: z.number().int().min(1).max(50).optional().describe("Max patterns to return (default 20).")
+      }
+    },
+    async ({ service, tag, limit = 20 }) => {
+      trackCall("get_override_patterns");
+      if (tag) {
+        const normalizedTag = tag.startsWith("infra_") ? tag : tag;
+        const events = getOverridesForTag(normalizedTag).filter((e) => !service || e.service === service).slice(-limit);
+        if (events.length === 0) {
+          return {
+            content: [{
+              type: "text",
+              text: `## Override Patterns \u2014 \`${normalizedTag}\`
+
+No overrides recorded for this failure mode${service ? ` on service \`${service}\`` : ""}.
+
+_If Mergen has never been overridden for this (tag, service) pair, autonomous execution is not blocked by the corpus._`
+            }]
+          };
+        }
+        const DAY_NAMES = ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"];
+        const lines2 = [
+          `## Override Patterns \u2014 \`${normalizedTag}\`${service ? ` \xB7 service: \`${service}\`` : ""}`,
+          "",
+          `**${events.length} override${events.length !== 1 ? "s" : ""} recorded**`,
+          "",
+          "| Date | Service | Reason | Time (UTC) | Outcome |",
+          "|------|---------|--------|------------|---------|",
+          ...events.map((e) => {
+            const date = new Date(e.recordedAt).toISOString().slice(0, 10);
+            const time = `${DAY_NAMES[e.dayOfWeek]} ${e.hourOfDay}:00`;
+            const outcome = e.outcome ?? "unknown";
+            return `| ${date} | ${e.service} | ${e.overrideReason} | ${time} | ${outcome} |`;
+          }),
+          "",
+          (() => {
+            if (events.length === 0) return "";
+            const counts = /* @__PURE__ */ new Map();
+            for (const ev of events) counts.set(ev.overrideReason, (counts.get(ev.overrideReason) ?? 0) + 1);
+            let topReason = events[0].overrideReason;
+            let topCount = 0;
+            for (const [r, c] of counts) if (c > topCount) {
+              topReason = r;
+              topCount = c;
+            }
+            return `_Dominant pattern: \`${topReason}\` \u2014 check time pattern before proposing a fix._`;
+          })()
+        ];
+        return { content: [{ type: "text", text: lines2.filter(Boolean).join("\n") }] };
+      }
+      const summaries = getOverrideSummary().filter((s) => !service || s.services.includes(service)).slice(0, limit);
+      if (summaries.length === 0) {
+        return {
+          content: [{
+            type: "text",
+            text: "## Override Patterns\n\nNo overrides recorded yet.\n\n_The override corpus grows automatically as engineers decline Mergen's recommendations. POST /overrides to record a manual override._"
+          }]
+        };
+      }
+      const totalOverrides = summaries.reduce((s, x) => s + x.total, 0);
+      const lines = [
+        "## Override Patterns \u2014 Corpus Summary",
+        "",
+        `**${totalOverrides} total overrides** across **${summaries.length} failure modes**`,
+        "",
+        "| Failure Mode | Overrides | Dominant Reason | Time Pattern | Services |",
+        "|---|---|---|---|---|",
+        ...summaries.map((s) => {
+          const tp = s.timePattern ?? "\u2014";
+          const sv = s.services.slice(0, 3).join(", ") + (s.services.length > 3 ? "\u2026" : "");
+          return `| \`${s.tag}\` | ${s.total} | ${s.dominantReason ?? "\u2014"} | ${tp} | ${sv} |`;
+        }),
+        "",
+        "---",
+        '_Call `get_override_patterns(tag: "...")` for full history of a specific failure mode._',
+        "_Before proposing a fix, check whether the (tag, service, time) combination has been overridden before._"
+      ];
+      return { content: [{ type: "text", text: lines.join("\n") }] };
+    }
+  );
+  server.registerTool(
+    "get_detector_calibration",
+    {
+      description: "Returns calibration accuracy for Mergen's detectors \u2014 how often each diagnosis type has been correct, wrong, or partial based on production feedback. Use this to understand how reliable a specific hypothesis is before acting on it. A detector with 90% accuracy and 30+ verdicts is highly trusted. One with 50% accuracy or fewer than 5 verdicts is uncertain \u2014 require higher confidence or manual review. Also returns the 7-day accuracy trend to detect detectors that are drifting.",
+      inputSchema: {
+        tag: z.string().optional().describe('Specific failure mode tag to look up (e.g. "connection_pool_exhausted"). Omit to return all detectors.')
+      }
+    },
+    async ({ tag }) => {
+      trackCall("get_detector_calibration");
+      const seededWarning = isCorpusSeeded() ? "\n> \u26A0\uFE0F **SYNTHETIC PRIORS ACTIVE** \u2014 no production verdicts have been recorded yet (or all have expired). The accuracy figures below are developer estimates, not measurements from this system's incident history. Do not use them to gate autonomous execution decisions.\n" : "";
+      if (tag) {
+        const normalizedTag = tag.startsWith("infra_") ? tag : tag;
+        const stats = getStatsForTag(normalizedTag);
+        if (!stats) {
+          return {
+            content: [{
+              type: "text",
+              text: [
+                `## Detector Calibration \u2014 \`${normalizedTag}\``,
+                seededWarning,
+                "_No calibration data yet for this detector._",
+                "",
+                `Calibration builds automatically as incidents of type \`${normalizedTag}\` are diagnosed and verdicts recorded.`,
+                "With fewer than 5 verdicts, execution decisions use the built-in prior (developer estimate)."
+              ].filter(Boolean).join("\n")
+            }]
+          };
+        }
+        const trustLabel = stats.trusted ? `\u2705 TRUSTED (${stats.verdicts} verdicts)` : `\u26A0\uFE0F PRIOR ESTIMATE (${stats.verdicts}/${5} verdicts needed)`;
+        const trendLabel = stats.trendDelta !== null ? stats.trendDelta > 0.05 ? `\u{1F4C8} Improving (+${Math.round(stats.trendDelta * 100)}% vs all-time)` : stats.trendDelta < -0.05 ? `\u{1F4C9} Degrading (${Math.round(stats.trendDelta * 100)}% vs all-time)` : `\u2192 Stable` : "\u2014 insufficient 7-day data";
+        const shouldAct = stats.accuracy >= 0.7 ? "\u2705 Proceed with `execute_fix` if confidence \u2265 threshold" : stats.accuracy >= 0.5 ? "\u26A0\uFE0F Mixed accuracy \u2014 require confidence \u2265 0.90 or manual review" : "\u{1F6AB} Poor accuracy \u2014 do not auto-execute; manual review required";
+        const tagRecs = getRecords().filter((r) => r.tag === normalizedTag);
+        const realVerdicts = tagRecs.filter((r) => !r.isBuiltinSeed && r.verdict !== null).length;
+        const syntheticVerdicts = tagRecs.filter((r) => r.isBuiltinSeed).length;
+        const verdictBreakdown = realVerdicts > 0 ? `${realVerdicts} real \xB7 ${syntheticVerdicts} synthetic priors` : `0 real \xB7 ${syntheticVerdicts} synthetic priors _(accuracy based on estimates only)_`;
+        const lines2 = [
+          `## Detector Calibration \u2014 \`${normalizedTag}\``,
+          seededWarning,
+          `**Status:** ${trustLabel}`,
+          `**All-time accuracy:** ${Math.round(stats.accuracy * 100)}%`,
+          `**7-day accuracy:** ${stats.accuracy7d !== null ? Math.round(stats.accuracy7d * 100) + "%" : "\u2014"}`,
+          `**Trend:** ${trendLabel}`,
+          `**Total predictions:** ${stats.predictions}`,
+          `**Verdicts:** ${stats.verdicts} (correct: ${Math.round(stats.diagnosisAccuracy * 100)}%, remediation: ${stats.remediationAccuracy !== null ? Math.round(stats.remediationAccuracy * 100) + "%" : "\u2014"})`,
+          `**Verdict breakdown:** ${verdictBreakdown}`,
+          "",
+          `**Recommended action:** ${shouldAct}`,
+          "",
+          stats.commonFailureModes.length > 0 ? [
+            "**Common reasons for wrong diagnoses:**",
+            ...stats.commonFailureModes.slice(0, 3).map((m) => `- "${m.note}" (${m.count}\xD7)`)
+          ].join("\n") : ""
+        ].filter(Boolean);
+        const rationaleNotes = tagRecs.filter((r) => !r.isBuiltinSeed && r.note && (r.verdict === "correct" || r.verdict === "partial")).map((r) => r.note).slice(-5);
+        if (rationaleNotes.length > 0) {
+          lines2.push(
+            "",
+            "**Recorded fix rationale (why past fixes worked):**",
+            ...rationaleNotes.map((n) => `- "${n}"`)
+          );
+        }
+        return { content: [{ type: "text", text: lines2.join("\n") }] };
+      }
+      const allStats = getStats().filter((s) => s.predictions > 0);
+      if (allStats.length === 0) {
+        return {
+          content: [{
+            type: "text",
+            text: "## Detector Calibration\n\nNo calibration data yet.\n\nCalibration builds automatically as incidents are diagnosed and resolved. Each correct/wrong verdict updates the accuracy scores shown here."
+          }]
+        };
+      }
+      const trusted = allStats.filter((s) => s.trusted);
+      const untrusted = allStats.filter((s) => !s.trusted);
+      const avgAccuracy = trusted.length > 0 ? trusted.reduce((sum, s) => sum + s.accuracy, 0) / trusted.length : null;
+      const lines = [
+        "## Detector Calibration \u2014 All Detectors",
+        seededWarning,
+        `**${allStats.length} detectors tracked** \xB7 **${trusted.length} trusted** (\u22655 verdicts) \xB7 **${untrusted.length} on prior estimate**`,
+        avgAccuracy !== null ? `**Mean accuracy (trusted):** ${Math.round(avgAccuracy * 100)}%` : "",
+        "",
+        "### Trusted Detectors",
+        "",
+        "| Tag | Accuracy | 7d Trend | Verdicts | Suppress? |",
+        "|-----|----------|----------|----------|-----------|",
+        ...trusted.sort((a, b) => b.accuracy - a.accuracy).map((s) => {
+          const acc7d = s.accuracy7d !== null ? Math.round(s.accuracy7d * 100) + "%" : "\u2014";
+          const trend = s.trendDelta !== null ? s.trendDelta > 0.05 ? "\u{1F4C8}" : s.trendDelta < -0.05 ? "\u{1F4C9}" : "\u2192" : "\u2014";
+          const suppress = s.shouldInterrupt ? "\u{1F6AB} YES" : "\u2014";
+          return `| \`${s.tag}\` | ${Math.round(s.accuracy * 100)}% | ${trend} ${acc7d} | ${s.verdicts} | ${suppress} |`;
+        }),
+        "",
+        untrusted.length > 0 ? [
+          "### On Prior Estimate (< 5 verdicts)",
+          "",
+          untrusted.map((s) => `- \`${s.tag}\`: ${s.predictions} predictions, ${s.verdicts} verdict${s.verdicts !== 1 ? "s" : ""}`).join("\n")
+        ].join("\n") : "",
+        "",
+        "---",
+        "_A detector is suppressed (\u{1F6AB}) when accuracy falls below 20% on trusted data \u2014 Mergen will stop surfacing it until the corpus improves._"
+      ].filter(Boolean);
+      return { content: [{ type: "text", text: lines.join("\n") }] };
+    }
+  );
+  server.registerTool(
+    "check_staged_changes",
+    {
+      description: "Checks a list of files or staged changes against the operational database to see if they have been involved in past outages or conflicts. Always call this BEFORE applying a change or proposing a fix to make sure your AI assistant is not confidently wrong and repeating a previous failure.",
+      inputSchema: {
+        files: z.array(z.string()).describe('List of files changed or intended to change (e.g. ["server/src/auth.ts", "package.json"])'),
+        prTitle: z.string().optional().describe("The proposed changes description or commit message"),
+        service: z.string().optional().describe("Service name if known")
+      }
+    },
+    async ({ files, prTitle = "", service = "" }) => {
+      trackCall("check_staged_changes");
+      const matchedIncidents = [];
+      const matchedOverrides = [];
+      if (memoryStore.isHealthy()) {
+        const allIncidents = memoryStore.listAll(1e3);
+        for (const file of files) {
+          const matching = allIncidents.filter(
+            (r) => r.implicatedFile && r.implicatedFile.toLowerCase().includes(file.toLowerCase())
+          );
+          matchedIncidents.push(...matching);
+        }
+      }
+      const summary = getOverrideSummary();
+      for (const item of summary) {
+        if (service && item.services.includes(service)) {
+          matchedOverrides.push(item);
+        } else {
+          const cleanTag = item.tag.replace(/_/g, " ").toLowerCase();
+          const cleanTitle = prTitle.toLowerCase();
+          if (cleanTitle.includes(cleanTag) || files.some((f) => f.toLowerCase().includes(item.tag.replace(/^infra_/, "").replace(/_/g, "")))) {
+            matchedOverrides.push(item);
+          }
+        }
+      }
+      if (matchedIncidents.length === 0 && matchedOverrides.length === 0) {
+        return {
+          content: [{
+            type: "text",
+            text: "\u2705 **No past failures or override patterns match your proposed changes.** Safe to proceed."
+          }]
+        };
+      }
+      const lines = [
+        `> \u{1F4A1} **Visible Intelligence: "My AI agent is confidently wrong"**`,
+        `> `,
+        `> \u26A0\uFE0F **Warning: Your proposed changes touch files or logic with a history of operational failures:**`
+      ];
+      const uniqueIncidents = Array.from(new Map(matchedIncidents.map((i) => [i.id, i])).values());
+      for (const inc of uniqueIncidents.slice(0, 5)) {
+        const dateDesc = new Date(inc.firedAt).toISOString().slice(0, 10);
+        lines.push(
+          `> - **File:** \`${inc.implicatedFile}\` previously caused **Incident #${inc.id}** (${dateDesc})`,
+          `>   *Error:* ${inc.errorMessage.slice(0, 100)}`,
+          `>   *Last Fix:* ${inc.fixPrTitle || inc.fixSummary || "Not specified"}`
+        );
+      }
+      const uniqueOverrides = Array.from(new Map(matchedOverrides.map((o) => [o.tag, o])).values());
+      if (uniqueOverrides.length > 0) {
+        lines.push(`>`, `> \u{1F6AB} **Active constraints from past overrides:**`);
+        for (const ov of uniqueOverrides.slice(0, 5)) {
+          lines.push(
+            `> - \`${ov.tag}\` has been overridden **${ov.total} times** (Dominant reason: \`${ov.dominantReason || "unknown"}\`)`
+          );
+        }
+      }
+      return {
+        content: [{
+          type: "text",
+          text: lines.join("\n")
+        }]
+      };
+    }
+  );
+}
+export {
+  registerMemoryTools
+};