mergen-server 1.4.0

package/dist/intelligence/tools-runbook.js

@@ -0,0 +1,951 @@
+import { z } from "zod";
+import { postmortemStore } from "./postmortem-store.js";
+import { hybridSearch, tagToQuery } from "./postmortem-retrieval.js";
+import { trackCall, withTierGate } from "./tools-state.js";
+import { getTierForTool } from "./tool-manifest.js";
+import { store } from "../sensor/buffer.js";
+import { incidentStore } from "../sensor/incident-store.js";
+import { detectAiCommit } from "./ai-commit.js";
+import { commitContextStore } from "../sensor/commit-context-store.js";
+import { hypothesisHistory } from "./hypothesis-history.js";
+import { readdir, readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import { existsSync } from "node:fs";
+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 parseRunbookYaml(yaml) {
+  const steps = [];
+  let currentStep = null;
+  let inParams = false;
+  let name = "";
+  let description = "";
+  const lines = yaml.split("\n");
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    if (currentStep === null) {
+      if (line.startsWith("name:")) {
+        name = line.replace("name:", "").trim();
+        if (name.startsWith('"') && name.endsWith('"') || name.startsWith("'") && name.endsWith("'")) {
+          name = name.slice(1, -1);
+        }
+        continue;
+      }
+      if (line.startsWith("description:")) {
+        description = line.replace("description:", "").trim();
+        if (description.startsWith('"') && description.endsWith('"') || description.startsWith("'") && description.endsWith("'")) {
+          description = description.slice(1, -1);
+        }
+        continue;
+      }
+    }
+    if (line.match(/^\s*-\s*name:/)) {
+      let stepName = line.replace(/^\s*-\s*name:/, "").trim();
+      if (stepName.startsWith('"') && stepName.endsWith('"') || stepName.startsWith("'") && stepName.endsWith("'")) {
+        stepName = stepName.slice(1, -1);
+      }
+      currentStep = {
+        step: stepName,
+        tool: "",
+        params: {}
+      };
+      steps.push(currentStep);
+      inParams = false;
+      continue;
+    }
+    if (currentStep) {
+      if (line.match(/^\s*tool:/)) {
+        let toolName = line.replace(/^\s*tool:/, "").trim();
+        if (toolName.startsWith('"') && toolName.endsWith('"') || toolName.startsWith("'") && toolName.endsWith("'")) {
+          toolName = toolName.slice(1, -1);
+        }
+        currentStep.tool = toolName;
+        inParams = false;
+        continue;
+      }
+      if (line.match(/^\s*params:/)) {
+        inParams = true;
+        continue;
+      }
+      if (inParams) {
+        const kvMatch = line.match(/^\s*([a-zA-Z0-9_-]+)\s*:\s*(.+)$/);
+        if (kvMatch) {
+          const [, k, rawVal] = kvMatch;
+          let valStr = rawVal.trim();
+          if (valStr.startsWith('"') && valStr.endsWith('"') || valStr.startsWith("'") && valStr.endsWith("'")) {
+            valStr = valStr.slice(1, -1);
+          }
+          let val = valStr;
+          if (valStr === "true") val = true;
+          else if (valStr === "false") val = false;
+          else if (valStr === "null") val = null;
+          else if (!isNaN(Number(valStr))) val = Number(valStr);
+          currentStep.params[k] = val;
+        } else {
+          const indentMatch = line.match(/^(\s*)/);
+          const indent = indentMatch ? indentMatch[0].length : 0;
+          if (indent < 6) {
+            inParams = false;
+          }
+        }
+      }
+    }
+  }
+  return { name, description, steps };
+}
+function registerRunbookTools(server) {
+  server.registerTool(
+    "check_fix_history",
+    {
+      description: "Before running a fix, check whether Mergen has seen it before and whether it worked. Prevents repeated mistakes: if this command previously caused a REGRESSION or has a low resolution rate, the tool surfaces that before execution. Pass the exact command you are about to run (command) or a free-text description (description). Returns: resolution rate, avg MTTR when successful, per-service breakdown, and nearest corpus alternatives if the command is not found. Always call this before execute_fix or before proposing a fix to the user.",
+      inputSchema: {
+        command: z.string().optional().describe('The shell command you are about to run (e.g. "kubectl rollout restart deployment/api"). Fuzzy-matched against fix history.'),
+        description: z.string().optional().describe('Free-text description of what the fix does (e.g. "restart the api pod"). Used for hybrid search when exact command is unknown.'),
+        service: z.string().optional().describe("Narrow results to a specific service.")
+      }
+    },
+    async ({ command, description, service }) => {
+      trackCall("check_fix_history");
+      if (!command && !description) {
+        return {
+          content: [{
+            type: "text",
+            text: "Provide either `command` (the exact fix to check) or `description` (what the fix does)."
+          }]
+        };
+      }
+      if (command) {
+        const rows = postmortemStore.lookupFixHistory(command, service);
+        if (rows.length > 0) {
+          const totalApplied = rows.reduce((s, r) => s + r.timesApplied, 0);
+          const totalResolved = rows.reduce((s, r) => s + r.timesResolved, 0);
+          const resolutionRate = totalApplied > 0 ? Math.round(totalResolved / totalApplied * 100) : 0;
+          const verdict = resolutionRate >= 80 ? "\u2705 HIGH CONFIDENCE" : resolutionRate >= 50 ? "\u26A0\uFE0F MIXED RESULTS" : "\u274C LOW SUCCESS RATE";
+          const tableRows = rows.map((r) => {
+            const mttr = r.avgMttrMs != null ? fmtMs(r.avgMttrMs) : "\u2014";
+            const rate = r.timesApplied > 0 ? Math.round(r.timesResolved / r.timesApplied * 100) : 0;
+            const last = new Date(r.lastUsedAt).toISOString().slice(0, 10);
+            return `| ${r.service} | ${r.timesApplied} | ${rate}% | ${mttr} | ${last} |`;
+          });
+          const lines2 = [
+            `## Fix History: \`${command.slice(0, 80)}${command.length > 80 ? "\u2026" : ""}\``,
+            "",
+            `**Found in corpus:** ${totalApplied} application${totalApplied !== 1 ? "s" : ""} across ${rows.length} service${rows.length !== 1 ? "s" : ""}`,
+            "",
+            "| Service | Applied | Resolved | Avg MTTR | Last used |",
+            "|---------|---------|----------|----------|-----------|",
+            ...tableRows,
+            "",
+            `${verdict} \u2014 ${resolutionRate}% overall resolution rate`,
+            "",
+            resolutionRate >= 80 ? "_This fix has a strong track record. Proceed with `execute_fix`._" : resolutionRate >= 50 ? "_Mixed results. Review the per-service breakdown before proceeding._" : "_Poor track record. Consider `triage_incident` for an alternative diagnosis._"
+          ];
+          return { content: [{ type: "text", text: lines2.join("\n") }] };
+        }
+      }
+      const searchQuery = command ?? description ?? "";
+      const related = hybridSearch(searchQuery, { service, topK: 5 });
+      if (related.length === 0) {
+        const corpusSize = postmortemStore.count();
+        return {
+          content: [{
+            type: "text",
+            text: [
+              `## Fix History: \`${searchQuery.slice(0, 80)}\``,
+              "",
+              command ? `\u26A0\uFE0F **Not found in corpus.** No previous applications of this command recorded.` : `\u26A0\uFE0F **No matching incidents found** for: "${searchQuery}"`,
+              "",
+              corpusSize === 0 ? "_Corpus is empty \u2014 no incident history yet. Proceed with caution and validate after applying._" : `_Corpus has ${corpusSize} postmortem${corpusSize !== 1 ? "s" : ""} but none matched. Consider \`triage_incident\` for automated root cause analysis first._`
+            ].join("\n")
+          }]
+        };
+      }
+      const altLines = related.slice(0, 3).map((r, i) => {
+        const pm = r.postmortem;
+        const fix = pm.fixCommand ? `\`${pm.fixCommand.slice(0, 70)}${pm.fixCommand.length > 70 ? "\u2026" : ""}\`` : "_no fix recorded_";
+        const mttr = pm.mttrMs != null ? fmtMs(pm.mttrMs) : "\u2014";
+        const date = new Date(pm.generatedAt).toISOString().slice(0, 10);
+        return [
+          `**${i + 1}. ${pm.tag.replace(/^infra_/, "")}** \u2014 ${pm.service} (${date})`,
+          `Fix: ${fix}  |  MTTR: ${mttr}  |  ${pm.resolvedAutonomously ? "\u{1F916} autonomous" : "\u{1F464} manual"}`
+        ].join("\n");
+      });
+      const lines = [
+        `## Fix History: \`${searchQuery.slice(0, 80)}\``,
+        "",
+        command ? `\u26A0\uFE0F **Not found in corpus.** No exact match \u2014 showing nearest related fixes:` : `**Nearest corpus fixes for:** "${searchQuery}"`,
+        "",
+        ...altLines.flatMap((l) => [l, ""]),
+        "---",
+        "_If none of these apply, call `triage_incident` for a fresh causal analysis._"
+      ];
+      return { content: [{ type: "text", text: lines.join("\n") }] };
+    }
+  );
+  server.registerTool(
+    "explain_service",
+    {
+      description: "Returns a deterministic, token-efficient briefing card for a service: top failure modes ranked by frequency, avg MTTR per mode, autonomous resolution rate, verified fix commands ranked by usage, co-occurring services, and current open incident count. Built from the local incident corpus \u2014 no LLM calls, no hallucinated topology. Primary use case: new engineer joins on-call rotation and calls this before their first page. Also used by AI agents to ground themselves before triaging \u2014 prevents fabricated service boundaries.",
+      inputSchema: {
+        service: z.string().describe('Service or component name (e.g. "api", "checkout-api", "payments-worker").'),
+        limit: z.number().int().min(1).max(10).optional().describe("Max failure modes to return (default: 5).")
+      }
+    },
+    async ({ service, limit = 5 }) => {
+      trackCall("explain_service");
+      let profile = postmortemStore.serviceProfile(service);
+      let resolvedName = service;
+      if (profile.totalIncidents === 0) {
+        const fuzzy = postmortemStore.fuzzyService(service);
+        if (fuzzy) {
+          resolvedName = fuzzy;
+          profile = postmortemStore.serviceProfile(fuzzy);
+        }
+      }
+      if (profile.totalIncidents === 0) {
+        const allStats = postmortemStore.tagStats();
+        const knownServices = postmortemStore.knownServices(10);
+        return {
+          content: [{
+            type: "text",
+            text: [
+              `## Service Profile: ${service}`,
+              "",
+              "_No incidents found for this service in the Mergen corpus._",
+              "",
+              knownServices.length > 0 ? `**Known services in corpus:** ${knownServices.join(", ")}` : `**Corpus is empty.** Incidents are recorded automatically as they are triaged.`,
+              "",
+              "Once incidents are resolved, this tool returns:",
+              "- Top failure modes by frequency",
+              "- Average MTTR per failure mode",
+              "- Verified fix commands ranked by usage",
+              "- Co-occurring services",
+              "",
+              allStats.length > 0 ? `_Tip: ${allStats.length} failure mode${allStats.length !== 1 ? "s" : ""} exist across all services \u2014 call \`generate_runbook\` with one of: ${allStats.slice(0, 3).map((s) => `\`${s.tag.replace(/^infra_/, "")}\``).join(", ")}_` : `_Run \`mergen-server demo\` to seed 50 real-world incidents and see this tool in action._`
+            ].join("\n")
+          }]
+        };
+      }
+      const coServices = incidentStore.coOccurringServices(resolvedName);
+      const openCount = incidentStore.list(void 0, 200).filter(
+        (i) => i.service === resolvedName && i.status === "open"
+      ).length;
+      const firstDate = profile.firstSeenAt ? new Date(profile.firstSeenAt).toISOString().slice(0, 10) : "\u2014";
+      const lastDate = profile.lastSeenAt ? new Date(profile.lastSeenAt).toISOString().slice(0, 10) : "\u2014";
+      const fuzzyNote = resolvedName !== service ? `_No exact match for "${service}" \u2014 showing results for "${resolvedName}"_
+` : "";
+      const modes = profile.failureModes.slice(0, limit);
+      const modeRows = modes.map((m) => {
+        const tag = m.tag.replace(/^infra_/, "");
+        const mttr = m.avgMttrMs != null ? fmtMs(m.avgMttrMs) : "\u2014";
+        const fix = m.topFixCommand ? `\`${m.topFixCommand.slice(0, 60)}${m.topFixCommand.length > 60 ? "\u2026" : ""}\`` : "\u2014";
+        return `| ${tag} | ${m.frequency}\xD7 | ${mttr} | ${m.autonomousRate}% | ${fix} |`;
+      });
+      const fixLines = profile.topFixCommands.map(
+        (f, i) => `${i + 1}. \`${f.command}\` \u2014 applied ${f.timesApplied}\xD7`
+      );
+      const coLine = coServices.length > 0 ? coServices.map(({ service: svc, count }) => `${svc} (${count})`).join(" \xB7 ") : "_No co-occurring service data yet_";
+      const openLine = openCount > 0 ? `\u26A0\uFE0F **${openCount} open incident${openCount !== 1 ? "s" : ""}** currently tracked` : "\u2705 No open incidents";
+      const lines = [
+        `## Service Profile: ${resolvedName}`,
+        `_Mergen corpus \xB7 ${profile.totalIncidents} incident${profile.totalIncidents !== 1 ? "s" : ""} \xB7 First: ${firstDate} \xB7 Last: ${lastDate}_`,
+        fuzzyNote,
+        openLine,
+        "",
+        "### Failure Modes",
+        "",
+        "| Mode | Freq | Avg MTTR | Auto-resolved | Most Recent Verified Fix |",
+        "|------|------|----------|---------------|--------------------------|",
+        ...modeRows,
+        ""
+      ];
+      if (fixLines.length > 0) {
+        lines.push("### Verified Fix Commands (ranked by usage)", "", ...fixLines, "");
+      }
+      lines.push(
+        "### Co-occurring Services",
+        "",
+        coLine,
+        "",
+        "---",
+        `_Drill down: \`generate_runbook(service: "${resolvedName}")\` \xB7 \`search_postmortems(query: "...", service: "${resolvedName}")\`_`
+      );
+      return { content: [{ type: "text", text: lines.join("\n") }] };
+    }
+  );
+  server.registerTool(
+    "generate_runbook",
+    {
+      description: 'Generate a self-updating runbook for a failure mode from your incident corpus. Uses hybrid retrieval (FTS5 BM25 keyword search + TF-IDF embedding, fused via RRF) to find the most relevant past incidents. Synthesizes root cause patterns, verified fix commands, MTTR trends, and step-by-step procedure. Replaces static Confluence/Notion runbooks that decay within weeks. Pass a failure tag (e.g. "db_connection_pool_exhausted") or a free-text description. If no tag is provided, lists all failure modes with corpus coverage.',
+      inputSchema: {
+        tag: z.string().optional().describe('Failure mode tag (e.g. "infra_db_connection_pool_exhausted"). If omitted, lists all available.'),
+        query: z.string().optional().describe('Free-text description to search for (e.g. "database connections timing out"). Used for hybrid retrieval if tag is not given.'),
+        service: z.string().optional().describe("Filter to a specific service name."),
+        limit: z.number().int().min(1).max(50).optional().describe("Max postmortems to synthesize from (default: 10).")
+      }
+    },
+    withTierGate(getTierForTool("generate_runbook"), async ({ tag, query, service, limit = 10 }) => {
+      trackCall("generate_runbook");
+      if (!postmortemStore.isHealthy()) {
+        return {
+          content: [{
+            type: "text",
+            text: "\u26A0\uFE0F **Postmortem store is unavailable** (SQLite init failed \u2014 check logs for WASM or file error). Runbooks cannot be generated until the store recovers on next restart."
+          }]
+        };
+      }
+      if (!tag && !query) {
+        const stats = postmortemStore.tagStats();
+        if (stats.length === 0) {
+          return {
+            content: [{
+              type: "text",
+              text: [
+                "## Runbook Corpus \u2014 Empty",
+                "",
+                "No postmortems have been written yet. The corpus grows automatically as incidents are resolved.",
+                "",
+                "To seed with 50 real-world incident postmortems run: `mergen-server demo`",
+                "Or call `triage_incident` to begin building your own corpus."
+              ].join("\n")
+            }]
+          };
+        }
+        const totalPms = stats.reduce((s, t) => s + t.count, 0);
+        const lines2 = [
+          "## Runbook Corpus \u2014 Coverage",
+          "",
+          `**${totalPms} postmortems** across **${stats.length} failure modes**`,
+          "",
+          "| Failure mode | Incidents | Avg MTTR | Last seen |",
+          "|---|---|---|---|"
+        ];
+        for (const s of stats) {
+          const displayTag2 = s.tag.replace(/^infra_/, "");
+          const mttr = s.avgMttrMs != null ? fmtMs(s.avgMttrMs) : "\u2014";
+          const last = new Date(s.lastAt).toISOString().slice(0, 10);
+          lines2.push(`| \`${displayTag2}\` | ${s.count} | ${mttr} | ${last} |`);
+        }
+        lines2.push("", 'Call `generate_runbook(tag: "...")` or `generate_runbook(query: "...")` to synthesize a runbook.');
+        return { content: [{ type: "text", text: lines2.join("\n") }] };
+      }
+      const normalizedTag = tag ? tag.startsWith("infra_") ? tag : `infra_${tag}` : void 0;
+      const searchQuery = query ?? (normalizedTag ? tagToQuery(normalizedTag) : "");
+      const results = hybridSearch(searchQuery, {
+        tag: normalizedTag,
+        service,
+        topK: limit
+      });
+      const postmortems = results.length > 0 ? results.map((r) => r.postmortem) : normalizedTag ? postmortemStore.getByTag(normalizedTag, limit) : [];
+      if (postmortems.length === 0) {
+        return {
+          content: [{
+            type: "text",
+            text: [
+              `## Runbook \u2014 ${(normalizedTag ?? query ?? "").replace(/^infra_/, "")}`,
+              "",
+              "No postmortems found.",
+              service ? `No resolved incidents for service \`${service}\` matching this query.` : "",
+              "",
+              "The runbook auto-generates once the first matching incident is resolved."
+            ].filter(Boolean).join("\n")
+          }]
+        };
+      }
+      const displayTag = (normalizedTag ?? postmortems[0].tag).replace(/^infra_/, "");
+      const totalCount = postmortems.length;
+      const autonomousCount = postmortems.filter((pm) => pm.resolvedAutonomously).length;
+      const mttrSamples = postmortems.filter((pm) => pm.mttrMs != null).map((pm) => pm.mttrMs);
+      const avgMttr = mttrSamples.length > 0 ? mttrSamples.reduce((a, b) => a + b, 0) / mttrSamples.length : null;
+      const minMttr = mttrSamples.length > 0 ? Math.min(...mttrSamples) : null;
+      const commandCounts = /* @__PURE__ */ new Map();
+      for (const pm of postmortems) {
+        if (pm.fixCommand) {
+          commandCounts.set(pm.fixCommand, (commandCounts.get(pm.fixCommand) ?? 0) + 1);
+        }
+      }
+      const topCommands = [...commandCounts.entries()].sort((a, b) => b[1] - a[1]).slice(0, 3);
+      const rootCauses = [...new Set(
+        postmortems.map((pm) => pm.rootCause.split(".")[0].trim()).filter(Boolean)
+      )].slice(0, 3);
+      const signalSummary = results.length > 0 ? `_Retrieved via: ${[...new Set(results.flatMap((r) => r.signals))].join(" + ")} \u2192 RRF fusion_` : "";
+      const recentRows = postmortems.slice(0, 5).map((pm) => {
+        const date = new Date(pm.generatedAt).toISOString().slice(0, 10);
+        const mttr = pm.mttrMs != null ? fmtMs(pm.mttrMs) : "\u2014";
+        const how = pm.resolvedAutonomously ? "\u{1F916} auto" : "\u{1F464} manual";
+        return `| ${date} | ${pm.service} | ${mttr} | ${how} |`;
+      });
+      const lines = [
+        `# Runbook \u2014 ${displayTag}`,
+        `_Auto-generated from ${totalCount} incident${totalCount !== 1 ? "s" : ""} \xB7 ${new Date(postmortems[0].generatedAt).toISOString().slice(0, 10)}_`,
+        signalSummary,
+        "",
+        "## Summary",
+        "",
+        `- **${totalCount}** incidents in corpus`,
+        avgMttr != null ? `- **Avg MTTR:** ${fmtMs(avgMttr)}${minMttr != null ? ` (best: ${fmtMs(minMttr)})` : ""}` : "",
+        `- **Autonomous resolution rate:** ${Math.round(autonomousCount / totalCount * 100)}%`,
+        "",
+        "## Root Causes",
+        "",
+        ...rootCauses.map((rc, i) => `${i + 1}. ${rc}`),
+        ""
+      ];
+      if (topCommands.length > 0) {
+        lines.push("## Verified Fix Commands", "");
+        lines.push("_Ranked by frequency \u2014 these have resolved this failure mode before:_", "");
+        for (const [cmd, cnt] of topCommands) {
+          lines.push(`\`\`\`
+${cmd}
+\`\`\``);
+          lines.push(`_Applied ${cnt} time${cnt !== 1 ? "s" : ""}_`, "");
+        }
+      }
+      lines.push(
+        "## Procedure",
+        "",
+        `1. Confirm failure: check logs for \`${displayTag}\` pattern`,
+        "2. Run `triage_incident` to get current diagnosis",
+        topCommands.length > 0 ? `3. If confidence \u2265 85%: apply \`${topCommands[0][0]}\`` : "3. Apply fix per root cause above",
+        "4. Run `validate_fix` to confirm resolution",
+        "5. Resolution automatically updates this runbook",
+        "",
+        "## Recent Incidents",
+        "",
+        "| Date | Service | MTTR | How |",
+        "|---|---|---|---|",
+        ...recentRows
+      );
+      return { content: [{ type: "text", text: lines.filter((l) => l !== void 0).join("\n") }] };
+    })
+  );
+  server.registerTool(
+    "search_postmortems",
+    {
+      description: 'Semantic search over the postmortem corpus using hybrid retrieval (FTS5 BM25 + TF-IDF cosine similarity fused via Reciprocal Rank Fusion). Use this to find past incidents similar to the current one before triaging. Returns ranked postmortems with retrieval signal metadata. This is the "token tax" solution: instead of dumping raw logs into context, retrieve the 3-5 most relevant past incidents and include only those.',
+      inputSchema: {
+        query: z.string().describe(`Describe what you're looking for (e.g. "memory OOM kill in worker service", "rate limit cascade").`),
+        service: z.string().optional().describe("Restrict to a specific service."),
+        tag: z.string().optional().describe("Restrict to a specific failure mode tag."),
+        limit: z.number().int().min(1).max(20).optional().describe("Number of results to return (default: 5).")
+      }
+    },
+    withTierGate(getTierForTool("search_postmortems"), async ({ query, service, tag, limit = 5 }) => {
+      trackCall("search_postmortems");
+      if (!postmortemStore.isHealthy()) {
+        return {
+          content: [{
+            type: "text",
+            text: "\u26A0\uFE0F **Postmortem store is unavailable** (SQLite init failed). Search cannot run until the store recovers on next restart."
+          }]
+        };
+      }
+      const normalizedTag = tag ? tag.startsWith("infra_") ? tag : `infra_${tag}` : void 0;
+      const results = hybridSearch(query, {
+        tag: normalizedTag,
+        service,
+        topK: limit
+      });
+      if (results.length === 0) {
+        const totalInCorpus = postmortemStore.count();
+        return {
+          content: [{
+            type: "text",
+            text: totalInCorpus === 0 ? "## No results\n\nCorpus is empty. Resolve an incident with `triage_incident` to start building the corpus." : `## No results for "${query}"
+
+Corpus has ${totalInCorpus} postmortem${totalInCorpus !== 1 ? "s" : ""} but none matched. Try a broader query.`
+          }]
+        };
+      }
+      const lines = [
+        `## Postmortem Search \u2014 "${query}"`,
+        "",
+        `_Found ${results.length} result${results.length !== 1 ? "s" : ""} \xB7 hybrid retrieval (FTS5 + TF-IDF \u2192 RRF)_`,
+        ""
+      ];
+      for (const [i, result] of results.entries()) {
+        const { postmortem: pm, score, signals, embeddingSimilarity, keywordRank } = result;
+        const date = new Date(pm.generatedAt).toISOString().slice(0, 10);
+        const mttr = pm.mttrMs != null ? fmtMs(pm.mttrMs) : "\u2014";
+        const signalStr = signals.join("+");
+        const simStr = embeddingSimilarity != null ? `sim=${(embeddingSimilarity * 100).toFixed(0)}%` : "";
+        const rankStr = keywordRank != null ? `kw-rank=${keywordRank + 1}` : "";
+        const meta = [signalStr, simStr, rankStr].filter(Boolean).join(", ");
+        lines.push(
+          `### ${i + 1}. ${pm.tag.replace(/^infra_/, "")} \u2014 ${pm.service} (${date})`,
+          `_RRF score: ${score.toFixed(4)} \xB7 ${meta}_`,
+          "",
+          `**Root cause:** ${pm.rootCause}`,
+          pm.fixCommand ? `**Fix:** \`${pm.fixCommand}\`` : "",
+          `**MTTR:** ${mttr}  |  **Confidence:** ${Math.round(pm.confidence * 100)}%  |  **Resolution:** ${pm.resolvedAutonomously ? "\u{1F916} autonomous" : "\u{1F464} manual"}`,
+          pm.gitBranch ? `**Branch:** ${pm.gitBranch}  |  **SHA:** ${pm.gitSha ?? "unknown"}` : "",
+          ""
+        );
+      }
+      lines.push("---", `_To generate a full runbook: \`generate_runbook(tag: "...")\`_`);
+      return { content: [{ type: "text", text: lines.filter((l) => l !== void 0).join("\n") }] };
+    })
+  );
+  server.registerTool(
+    "draft_postmortem",
+    {
+      description: 'Draft a blameless incident postmortem from live telemetry + corpus context. Reconstructs the incident timeline from buffer events, correlates with past similar incidents via hybrid retrieval, and produces a structured Markdown draft ready for team review. Eliminates the post-incident documentation chore \u2014 from "incident closed" to blameless draft in seconds. Outputs: timeline, contributing factors, impact estimate, action items, and related past incidents. Pass a summary of what happened plus the affected service. The draft auto-links to similar corpus incidents.',
+      inputSchema: {
+        service: z.string().describe('Affected service name (e.g. "api", "payments", "worker").'),
+        summary: z.string().optional().describe('One-sentence description of what happened (e.g. "Database connection pool exhausted during peak traffic"). Used to find similar past incidents.'),
+        duration_minutes: z.number().int().min(1).max(1440).optional().describe("How long the incident lasted in minutes. Used for impact estimate."),
+        severity: z.enum(["sev1", "sev2", "sev3"]).optional().describe("Incident severity (default: sev2)."),
+        affected_users: z.string().optional().describe('Who was affected and how (e.g. "all authenticated users, checkout unavailable").'),
+        slack_thread: z.string().optional().describe("Slack thread URL or text content to incorporate into the timeline (optional).")
+      }
+    },
+    withTierGate(getTierForTool("draft_postmortem"), async ({ service, summary, duration_minutes, severity = "sev2", affected_users, slack_thread }) => {
+      trackCall("draft_postmortem");
+      const markdown = await draftPostmortemDoc({ service, summary, duration_minutes, severity, affected_users, slack_thread });
+      return { content: [{ type: "text", text: markdown }] };
+    })
+  );
+  server.registerTool(
+    "start_runbook",
+    {
+      description: "Run a named runbook from ~/.mergen/runbooks/*.yaml \u2014 step-by-step guided incident response. Each step maps to a Mergen tool call. Call with no name to list available runbooks. Built-in runbooks: api-degradation, db-connection-pool, auth-failures. Custom runbooks: add your own YAML files to ~/.mergen/runbooks/. Returns step-by-step results so the AI can walk through the investigation systematically.",
+      inputSchema: {
+        name: z.string().optional().describe("Runbook name (without .yaml extension). Omit to list all available runbooks."),
+        service: z.string().optional().describe('Target service name to substitute into runbook steps (e.g. "api", "payments").')
+      }
+    },
+    async ({ name, service }) => {
+      trackCall("start_runbook");
+      const RUNBOOKS_DIR = join(homedir(), ".mergen", "runbooks");
+      const BUILTIN_DIR = join(homedir(), ".mergen", "runbooks", "_builtin");
+      if (!name) {
+        const available = [];
+        for (const dir of [BUILTIN_DIR, RUNBOOKS_DIR]) {
+          if (!existsSync(dir)) continue;
+          const files = await readdir(dir).catch(() => []);
+          for (const f of files) {
+            if (f.endsWith(".yaml") || f.endsWith(".yml")) {
+              available.push(f.replace(/\.ya?ml$/, "") + (dir === BUILTIN_DIR ? " (built-in)" : ""));
+            }
+          }
+        }
+        if (available.length === 0) {
+          return { content: [{ type: "text", text: [
+            "## Available Runbooks",
+            "",
+            "No runbooks found. Built-in runbooks are seeded on first `mergen-server setup` run.",
+            "",
+            "To create one, add a YAML file to ~/.mergen/runbooks/:",
+            "",
+            "```yaml",
+            "name: my-runbook",
+            "description: Investigate API latency spikes",
+            "steps:",
+            "  - name: Check recent errors",
+            "    tool: get_recent_logs",
+            "    params: { level: error, limit: 50 }",
+            "  - name: Check network failures",
+            "    tool: get_network_activity",
+            "    params: { limit: 30 }",
+            "  - name: Causal analysis",
+            "    tool: analyze_runtime",
+            "```"
+          ].join("\n") }] };
+        }
+        return { content: [{ type: "text", text: `## Available Runbooks
+
+${available.map((r) => `- \`${r}\``).join("\n")}
+
+Call \`start_runbook(name: "<runbook-name>")\` to execute.` }] };
+      }
+      let yaml = null;
+      for (const dir of [RUNBOOKS_DIR, BUILTIN_DIR]) {
+        for (const ext of [".yaml", ".yml"]) {
+          const p = join(dir, name + ext);
+          if (existsSync(p)) {
+            yaml = await readFile(p, "utf-8");
+            break;
+          }
+        }
+        if (yaml) break;
+      }
+      if (!yaml) {
+        return { content: [{ type: "text", text: `Runbook \`${name}\` not found. Call \`start_runbook()\` with no arguments to list available runbooks.` }] };
+      }
+      const parsed = parseRunbookYaml(yaml);
+      const rbName = parsed.name || name;
+      const rbDesc = parsed.description;
+      const steps = parsed.steps;
+      if (service) {
+        for (const s of steps) {
+          s.params = s.params || {};
+          s.params.service = service;
+        }
+      }
+      const serviceNote = service ? ` for service **${service}**` : "";
+      const output = [
+        `## Runbook: ${rbName}${serviceNote}`,
+        rbDesc ? `_${rbDesc}_` : "",
+        "",
+        `**${steps.length} step${steps.length !== 1 ? "s" : ""}:**`,
+        "",
+        ...steps.map((s, i) => {
+          const paramStr = Object.keys(s.params).length > 0 ? "(" + Object.entries(s.params).map(([k, v]) => `${k}: ${JSON.stringify(v)}`).join(", ") + ")" : "";
+          return `${i + 1}. **${s.step}** \u2192 \`${s.tool}${paramStr}\``;
+        }),
+        "",
+        "---",
+        "_Execute each step in order. Each tool call returns evidence for the next step._",
+        "",
+        "**Start with step 1:** call the tool listed above, then proceed to step 2."
+      ];
+      return { content: [{ type: "text", text: output.filter(Boolean).join("\n") }] };
+    }
+  );
+  server.registerTool(
+    "suggest_followups",
+    {
+      description: "After triage or incident resolution: suggest high-value follow-up actions. Reads the latest hypothesis chain and recent incident state to recommend the next steps \u2014 opening a ticket, scheduling a postmortem, updating runbooks, or adding corpus policy. Returns a prioritized list with the exact tool call or command to execute each action. Call this after `triage_incident` or `validate_fix` to close the incident loop.",
+      inputSchema: {
+        context: z.string().optional().describe("Optional free-text context about what happened (adds to hypothesis history context).")
+      }
+    },
+    async ({ context }) => {
+      trackCall("suggest_followups");
+      const latest = hypothesisHistory.latest();
+      const openIncidents = incidentStore.list(void 0, 5).filter((i) => i.status === "open" || i.status === "acknowledged");
+      const actions = [];
+      const tag = latest?.topHypothesis?.tag ?? null;
+      const svc = latest?.topHypothesis?.service ?? null;
+      const conf = Number(latest?.topHypothesis?.confidence ?? 0);
+      const fix = latest?.topHypothesis?.fix ?? null;
+      const errors = latest?.chain?.errors ?? [];
+      if (fix && conf >= 0.85) {
+        actions.push({
+          priority: 1,
+          emoji: "\u{1F527}",
+          action: "Execute the recommended fix",
+          tool: `execute_fix(command: "${fix}", confirm: true)`,
+          rationale: `Confidence is ${Math.round(conf * 100)}% \u2014 above the 85% autonomous execution threshold.`
+        });
+      }
+      if (fix && conf >= 0.7) {
+        actions.push({
+          priority: 2,
+          emoji: "\u2705",
+          action: "Validate the fix",
+          tool: `validate_fix(command: "${fix}")`,
+          rationale: "Confirms error rate decreased after fix \u2014 required for corpus update."
+        });
+      }
+      if (svc || errors.length > 0) {
+        const title = tag ? `Investigate ${tag} in ${svc ?? "service"}` : `Post-incident follow-up${svc ? ` \u2014 ${svc}` : ""}`;
+        actions.push({
+          priority: 3,
+          emoji: "\u{1F3AB}",
+          action: "Create a tracking ticket",
+          tool: `create_ticket(title: "${title}", description: "See Mergen incident context for details.")`,
+          rationale: "Ensures incident action items are tracked to completion."
+        });
+      }
+      if (svc && errors.length >= 5) {
+        actions.push({
+          priority: 4,
+          emoji: "\u{1F4CB}",
+          action: "Draft a blameless postmortem",
+          tool: `draft_postmortem(service: "${svc}", summary: "${context ?? (tag ? `${tag} failure` : "incident")}")`,
+          rationale: `${errors.length} errors observed \u2014 warrants a formal postmortem document.`
+        });
+      }
+      if (svc) {
+        actions.push({
+          priority: 5,
+          emoji: "\u{1F4D6}",
+          action: "Update runbook for this failure mode",
+          tool: `generate_runbook(service: "${svc}"${tag ? `, failure_mode: "${tag}"` : ""})`,
+          rationale: "Codifies the resolution path so future incidents resolve faster."
+        });
+      }
+      for (const inc of openIncidents.slice(0, 2)) {
+        actions.push({
+          priority: 6,
+          emoji: "\u{1F6A8}",
+          action: `Acknowledge open incident ${inc.pid}`,
+          tool: `triage_incident(pid: "${inc.pid}")`,
+          rationale: `Incident ${inc.pid} is still ${inc.status} \u2014 may be related.`
+        });
+      }
+      if (tag) {
+        actions.push({
+          priority: 7,
+          emoji: "\u{1F50D}",
+          action: "Search for similar past incidents",
+          tool: `find_similar_incidents(query: "${tag}")`,
+          rationale: "Recurring patterns need systemic fixes, not just one-off patches."
+        });
+      }
+      if (actions.length === 0) {
+        return { content: [{ type: "text", text: "## Suggested Follow-ups\n\nNo active incident context found. Run `triage_incident` or `analyze_runtime` first to generate context." }] };
+      }
+      const lines = [
+        "## Suggested Follow-ups",
+        "",
+        "_Prioritized next actions based on current incident state:_",
+        "",
+        ...actions.sort((a, b) => a.priority - b.priority).map((a, i) => [
+          `### ${i + 1}. ${a.emoji} ${a.action}`,
+          "",
+          `**Why:** ${a.rationale}`,
+          "",
+          a.tool ? `**Call:** \`${a.tool}\`` : a.command ? `**Run:** \`${a.command}\`` : "",
+          ""
+        ].filter((l) => l !== void 0).join("\n"))
+      ];
+      return { content: [{ type: "text", text: lines.join("\n") }] };
+    }
+  );
+  server.registerTool(
+    "find_similar_incidents",
+    {
+      description: "Find past incidents similar to the current failure. Uses hybrid retrieval (BM25 + TF-IDF + RRF fusion) over the postmortem corpus to surface the top matches \u2014 each with its root cause, fix command, and MTTR. Call after `analyze_runtime` to see if this is a recurring pattern and what fixed it before. Returns: similarity score, root cause, fix command, MTTR, and whether it resolved autonomously.",
+      inputSchema: {
+        query: z.string().optional().describe("Free-text description of the current failure (default: uses latest hypothesis tag)."),
+        limit: z.number().int().min(1).max(10).optional().describe("Number of similar incidents to return (default: 3).")
+      }
+    },
+    withTierGate(getTierForTool("find_similar_incidents"), async ({ query, limit = 3 }) => {
+      trackCall("find_similar_incidents");
+      const latest = hypothesisHistory.latest();
+      const tag = latest?.topHypothesis?.tag ?? null;
+      const svc = latest?.topHypothesis?.service ?? null;
+      const effectiveQ = query ?? (tag ? tagToQuery(tag) : null);
+      if (!effectiveQ) {
+        return { content: [{ type: "text", text: "No query provided and no active hypothesis found. Run `analyze_runtime` first or pass a query string." }] };
+      }
+      const results = await hybridSearch(effectiveQ, { topK: limit });
+      if (results.length === 0) {
+        return { content: [{ type: "text", text: `## Similar Past Incidents
+
+No matches found for query: \`${effectiveQ}\`
+
+Corpus size: ${postmortemStore.count()} postmortems.` }] };
+      }
+      const lines = [
+        "## Similar Past Incidents",
+        "",
+        `_Query: \`${effectiveQ}\`${svc ? ` \xB7 Service: \`${svc}\`` : ""} \xB7 Corpus: ${postmortemStore.count()} postmortems_`,
+        ""
+      ];
+      for (let i = 0; i < results.length; i++) {
+        const r = results[i];
+        const pm = r.postmortem;
+        const simPct = Math.round((r.score ?? 0) * 100);
+        const mttrLabel = pm.mttrMs ? fmtMs(pm.mttrMs) : "unknown";
+        const autoLabel = pm.resolvedAutonomously ? "\u{1F916} autonomous" : "\u{1F464} manual";
+        lines.push(
+          `### ${i + 1}. ${pm.tag ?? pm.service} \u2014 ${simPct}% match`,
+          "",
+          `| Field | Value |`,
+          `|-------|-------|`,
+          `| **Service** | ${pm.service ?? "unknown"} |`,
+          `| **Root cause** | ${pm.rootCause ?? "_not recorded_"} |`,
+          `| **Fix** | ${pm.fixCommand ? `\`${pm.fixCommand}\`` : "_not recorded_"} |`,
+          `| **MTTR** | ${mttrLabel} |`,
+          `| **Resolution** | ${autoLabel} |`,
+          `| **Date** | ${pm.generatedAt ? new Date(pm.generatedAt).toISOString().slice(0, 10) : "unknown"} |`,
+          "",
+          pm.fixCommand ? `**\u21B3 To apply this fix:** \`execute_fix(command: "${pm.fixCommand}", confirm: true)\`` : "",
+          ""
+        );
+      }
+      lines.push("---");
+      lines.push('_Call `check_fix_history(command: "<fix>")` before executing any of the above fixes._');
+      return { content: [{ type: "text", text: lines.filter((l) => l !== void 0).join("\n") }] };
+    })
+  );
+}
+async function draftPostmortemDoc(params) {
+  const { service, summary, duration_minutes, severity = "sev2", affected_users, slack_thread } = params;
+  const now = Date.now();
+  const windowMs = (duration_minutes ?? 60) * 60 * 1e3;
+  const windowStart = now - windowMs;
+  const errors = store.getLogs(50, "error", windowStart);
+  const warns = store.getLogs(20, "warn", windowStart);
+  const netFails = store.getNetwork(30, void 0, windowStart).filter((n) => n.status >= 400 || !!n.error);
+  const terminal = store.getTerminalOutput(20, void 0, windowStart);
+  const searchQuery = summary ?? `${service} incident failure`;
+  const relatedPms = hybridSearch(searchQuery, { service, topK: 5 });
+  const timelineEvents = [];
+  for (const e of errors.slice(0, 10)) {
+    const msg = e.args.map((a) => typeof a === "string" ? a : JSON.stringify(a)).join(" ").slice(0, 200);
+    timelineEvents.push({ ts: e.timestamp, kind: "ERROR", msg });
+  }
+  for (const n of netFails.slice(0, 10)) {
+    timelineEvents.push({
+      ts: n.timestamp,
+      kind: `HTTP ${n.status || "ERR"}`,
+      msg: `${n.method} ${n.url}${n.error ? ` \u2014 ${n.error.slice(0, 100)}` : ""}`
+    });
+  }
+  for (const t of terminal.slice(0, 5)) {
+    if (/error|fatal|panic|oom|killed/i.test(String(t.data ?? ""))) {
+      timelineEvents.push({ ts: t.timestamp, kind: "PROCESS", msg: String(t.data ?? "").slice(0, 200) });
+    }
+  }
+  timelineEvents.sort((a, b) => a.ts - b.ts);
+  const errorPatterns = [...new Set(
+    errors.map((e) => {
+      const msg = String(e.args?.[0] ?? "").slice(0, 120);
+      return msg.replace(/\d+/g, "N").replace(/[a-f0-9]{8,}/gi, "<id>");
+    })
+  )].slice(0, 5);
+  const netPatterns = [...new Set(
+    netFails.map((n) => {
+      let pathname = n.url;
+      try {
+        pathname = new URL(n.url).pathname;
+      } catch {
+      }
+      return `${n.method} ${pathname} \u2192 ${n.status || "ERR"}`;
+    }).slice(0, 5)
+  )];
+  const userImpact = affected_users ?? "Unknown \u2014 add user impact manually";
+  const durationLabel = duration_minutes ? fmtMs(duration_minutes * 60 * 1e3) : "Unknown \u2014 add duration manually";
+  const relatedSection = relatedPms.length > 0 ? [
+    "## Related Past Incidents",
+    "",
+    "_Retrieved via hybrid search (FTS5 + TF-IDF \u2192 RRF)_",
+    "",
+    ...relatedPms.slice(0, 3).map((r, i) => {
+      const pm = r.postmortem;
+      const date = new Date(pm.generatedAt).toISOString().slice(0, 10);
+      const mttr = pm.mttrMs != null ? fmtMs(pm.mttrMs) : "\u2014";
+      return [
+        `### ${i + 1}. ${pm.tag.replace(/^infra_/, "")} \u2014 ${pm.service} (${date})`,
+        `**Root cause:** ${pm.rootCause}`,
+        pm.fixCommand ? `**Fix that worked:** \`${pm.fixCommand}\`` : "",
+        `**MTTR:** ${mttr}  |  **Resolution:** ${pm.resolvedAutonomously ? "Autonomous" : "Manual"}`,
+        ""
+      ].filter(Boolean).join("\n");
+    })
+  ].join("\n") : "";
+  const slackSection = slack_thread ? [
+    "## Slack Thread Context",
+    "",
+    "```",
+    slack_thread.slice(0, 1e3),
+    "```",
+    ""
+  ].join("\n") : "";
+  const aiCommitsInWindow = [];
+  const seenAiShas = /* @__PURE__ */ new Set();
+  for (const e of errors) {
+    const gs = e.gitSuspect;
+    if (!gs || seenAiShas.has(gs.sha)) continue;
+    const signal = gs.aiGenerated ? { detected: true, tool: null } : detectAiCommit(gs.summary, gs.author);
+    if (signal.detected) {
+      seenAiShas.add(gs.sha);
+      aiCommitsInWindow.push({ sha: gs.sha, author: gs.author, summary: gs.summary, tool: signal.tool });
+    }
+  }
+  const deploys = store.getDeployments(20, void 0, windowStart);
+  for (const d of deploys) {
+    if (!d.actor) continue;
+    const signal = detectAiCommit(d.actor, d.actor);
+    if (signal.detected && !seenAiShas.has(d.sha)) {
+      seenAiShas.add(d.sha);
+      aiCommitsInWindow.push({ sha: d.sha.slice(0, 7), author: d.actor, summary: `deployed to ${d.environment}`, tool: signal.tool });
+    }
+  }
+  const prIntentLines = [];
+  for (const ac of aiCommitsInWindow) {
+    const ctx = commitContextStore.getBySha(ac.sha);
+    if (ctx?.prTitle) {
+      const issueRefs = ctx.linkedIssues.slice(0, 3).map((i) => i.ref).join(", ");
+      const approvers = ctx.approvers.length ? ctx.approvers.join(", ") : "none recorded";
+      prIntentLines.push(
+        `**PR #${ctx.prNumber ?? "?"}: ${ctx.prTitle}**`,
+        `_Author: @${ctx.author ?? ac.author} \xB7 Approved by: ${approvers}${issueRefs ? ` \xB7 Refs: ${issueRefs}` : ""}_`,
+        ctx.prBody ? `> ${ctx.prBody.split("\n").filter((l) => l.trim()).slice(0, 2).join(" ").slice(0, 300)}` : "",
+        ""
+      );
+    }
+  }
+  const aiCommitsSection = aiCommitsInWindow.length > 0 ? [
+    "## AI-Generated Commits in Blast Radius",
+    "",
+    `_${aiCommitsInWindow.length} commit${aiCommitsInWindow.length !== 1 ? "s" : ""} in the incident window were generated by AI coding tools. These have no human author to consult during triage._`,
+    "",
+    ...aiCommitsInWindow.map(
+      (c) => `- \`${c.sha.slice(0, 7)}\` **${c.author}**${c.tool ? ` (${c.tool})` : ""} \u2014 ${c.summary.slice(0, 120)}`
+    ),
+    "",
+    ...prIntentLines.length > 0 ? ["### Captured PR Intent", "", ...prIntentLines] : []
+  ].join("\n") : "";
+  const actionItems = [];
+  if (errors.length > 0) actionItems.push(`[ ] Investigate root cause: ${errorPatterns[0] ?? "see errors above"}`);
+  if (netFails.length > 0) actionItems.push("[ ] Add retry logic / circuit breaker for failing endpoints");
+  if (aiCommitsInWindow.length > 0) actionItems.push(`[ ] Review ${aiCommitsInWindow.length} AI-generated commit${aiCommitsInWindow.length !== 1 ? "s" : ""} in blast radius \u2014 no human author to ask`);
+  if (relatedPms.length > 1) actionItems.push(`[ ] Review ${relatedPms.length} similar past incidents \u2014 recurring pattern may need systemic fix`);
+  actionItems.push('[ ] Update runbook: `generate_runbook(service: "' + service + '")`');
+  actionItems.push("[ ] Schedule blameless retrospective within 5 business days");
+  const severityLabel = severity.toUpperCase();
+  const dateStr = new Date(windowStart).toISOString().slice(0, 10);
+  const lines = [
+    `# [${severityLabel}] Incident Postmortem \u2014 ${service}`,
+    `_Draft generated by Mergen \xB7 ${(/* @__PURE__ */ new Date()).toISOString().slice(0, 16).replace("T", " ")} UTC_`,
+    "",
+    "## Summary",
+    "",
+    summary ?? `${service} incident \u2014 add one-sentence summary here`,
+    "",
+    "## Impact",
+    "",
+    `- **Service:** ${service}`,
+    `- **Severity:** ${severityLabel}`,
+    `- **Date:** ${dateStr}`,
+    `- **Duration:** ${durationLabel}`,
+    `- **Users affected:** ${userImpact}`,
+    "",
+    "## Timeline",
+    "",
+    timelineEvents.length > 0 ? timelineEvents.map((e) => {
+      const ts = new Date(e.ts).toISOString().slice(11, 19);
+      return `- \`${ts}\` **[${e.kind}]** ${e.msg}`;
+    }).join("\n") : "_No telemetry events in window \u2014 add timeline manually or extend the window._",
+    "",
+    slackSection,
+    "## Contributing Factors",
+    "",
+    ...errorPatterns.length > 0 ? errorPatterns.map((p, i) => `${i + 1}. ${p}`) : ["_Add contributing factors here_"],
+    ...netPatterns.length > 0 ? ["", "**Network failures:**", ...netPatterns.map((p) => `- ${p}`)] : [],
+    "",
+    "## Root Cause",
+    "",
+    relatedPms.length > 0 ? `_Likely similar to: ${relatedPms[0].postmortem.rootCause} \u2014 verify against current evidence above_` : "_Add root cause analysis here \u2014 call `triage_incident` for automated root cause identification_",
+    "",
+    "## Resolution",
+    "",
+    relatedPms.length > 0 && relatedPms[0].postmortem.fixCommand ? `Previous resolution: \`${relatedPms[0].postmortem.fixCommand}\` \u2014 verify if applicable here` : "_Describe the fix that resolved the incident_",
+    "",
+    aiCommitsSection,
+    "## Action Items",
+    "",
+    ...actionItems,
+    "",
+    relatedSection,
+    "---",
+    `_Telemetry: ${errors.length} errors, ${warns.length} warnings, ${netFails.length} network failures in window \xB7 Corpus: ${postmortemStore.count()} postmortems_`
+  ].filter((l) => l !== void 0);
+  return lines.join("\n");
+}
+export {
+  draftPostmortemDoc,
+  parseRunbookYaml,
+  registerRunbookTools
+};