mergen-server 1.4.0

package/dist/intelligence/tools-infra.js

@@ -0,0 +1,612 @@
+import { z } from "zod";
+import { store } from "../sensor/buffer.js";
+import { truncateToTokenBudget } from "./token-budget.js";
+import { hypothesisHistory } from "./hypothesis-history.js";
+import { getActivePlanId } from "./license.js";
+import { getPlan } from "./plans.js";
+import { trackCall, withTierGate } from "./tools-state.js";
+import { getTierForTool } from "./tool-manifest.js";
+import { serviceGraph } from "../sensor/service-graph.js";
+import { incidentStore } from "../sensor/incident-store.js";
+import logger from "../sensor/logger.js";
+function registerInfraTools(server) {
+  server.registerTool(
+    "get_unified_timeline",
+    {
+      description: "Returns the complete cross-signal causal timeline with confidence labels on every event. EXACT = deterministic traceId join (browser request \u2194 backend log line, same request). LINKED = structural SHA join (git blame / CI run / deployment matches browser build). ~CORR = timestamp proximity only (within 2s, statistical). OBS = event captured, no cross-signal link found. Start with EXACT rows \u2014 they are the verified causal chain. Use LINKED rows to find the responsible commit. Includes root cause hypothesis at top when confidence \u2265 45%.",
+      inputSchema: {
+        seconds: z.number().int().min(60).max(3600).optional().describe("Time window in seconds (default 300 = 5 minutes, max 3600 = 1 hour)"),
+        limit: z.number().int().min(1).max(200).optional().describe("Max events to return (default 50)")
+      }
+    },
+    withTierGate(getTierForTool("get_unified_timeline"), async ({ seconds = 300, limit = 50 }) => {
+      trackCall("get_unified_timeline");
+      const since = Date.now() - seconds * 1e3;
+      const BACKEND_ERROR_RE = /error|exception|traceback|panic|fatal|killed|oom/i;
+      const backendTraceSet = /* @__PURE__ */ new Set();
+      for (const t of store.getTerminalOutput(200, void 0, since)) {
+        if (t.traceId) backendTraceSet.add(t.traceId);
+      }
+      const browserTraceMap = /* @__PURE__ */ new Map();
+      for (const n of store.getNetwork(limit, void 0, since)) {
+        if (n.traceId) browserTraceMap.set(n.traceId, `${n.method} ${n.url}`);
+      }
+      const browserBuildShas = /* @__PURE__ */ new Set();
+      for (const e of store.getLogs(limit, void 0, since)) {
+        if (e.buildSha) browserBuildShas.add(e.buildSha.toLowerCase());
+      }
+      for (const n of store.getNetwork(limit, void 0, since)) {
+        if (n.buildSha) browserBuildShas.add(n.buildSha.toLowerCase());
+      }
+      const ciAndDeployShas = /* @__PURE__ */ new Set();
+      for (const c of store.getCIEvents(50, void 0, since)) {
+        ciAndDeployShas.add(c.sha.toLowerCase());
+        if (c.shortSha) ciAndDeployShas.add(c.shortSha.toLowerCase());
+      }
+      for (const d of store.getDeployments(20, void 0, since)) {
+        ciAndDeployShas.add(d.sha.toLowerCase());
+        if (d.shortSha) ciAndDeployShas.add(d.shortSha.toLowerCase());
+      }
+      const backendErrTimes = store.getTerminalOutput(100, void 0, since).filter((t) => BACKEND_ERROR_RE.test(t.data)).map((t) => t.timestamp);
+      function nearBackend(ts) {
+        return backendErrTimes.some((t) => Math.abs(t - ts) <= 2e3);
+      }
+      function badge(c) {
+        switch (c) {
+          case "exact":
+            return "`EXACT   `";
+          case "linked":
+            return "`LINKED  `";
+          case "temporal":
+            return "`~CORR   `";
+          case "observed":
+            return "`OBS     `";
+        }
+      }
+      const rows = [];
+      for (const e of store.getLogs(limit, void 0, since)) {
+        if (e.level === "log") continue;
+        const msg = e.args.map((a) => typeof a === "string" ? a : JSON.stringify(a)).join(" ").slice(0, 150);
+        const blame = e.gitSuspect ? `  [${e.gitSuspect.sha.slice(0, 7)} \xB7 ${e.gitSuspect.author}]` : "";
+        const confidence = e.gitSuspect ? "linked" : nearBackend(e.timestamp) ? "temporal" : "observed";
+        rows.push({ ts: e.timestamp, icon: e.level === "error" ? "\u{1F534}" : "\u{1F7E1}", label: msg + blame, source: "browser", confidence });
+      }
+      for (const n of store.getNetwork(limit, void 0, since)) {
+        if (n.status < 400 && n.status !== 0 && !n.error) continue;
+        const traceJoin = n.traceId ? backendTraceSet.has(n.traceId) : false;
+        const shaJoin = n.buildSha ? ciAndDeployShas.has(n.buildSha.toLowerCase()) : false;
+        const confidence = traceJoin ? "exact" : shaJoin ? "linked" : nearBackend(n.timestamp) ? "temporal" : "observed";
+        const traceNote = traceJoin ? "  \u2194 backend" : "";
+        rows.push({ ts: n.timestamp, icon: "\u{1F534}", label: `${n.method} ${n.url} \u2192 ${n.status || "ERR"} (${n.duration}ms)${traceNote}`, source: "browser", confidence });
+      }
+      for (const t of store.getTerminalOutput(100, void 0, since)) {
+        if (!BACKEND_ERROR_RE.test(t.data)) continue;
+        const traceJoin = t.traceId ? browserTraceMap.has(t.traceId) : false;
+        const confidence = traceJoin ? "exact" : "observed";
+        const traceNote = traceJoin ? `  \u2194 ${browserTraceMap.get(t.traceId)}` : "";
+        rows.push({ ts: t.timestamp, icon: "\u{1F4BB}", label: `[${t.terminalName}] ${t.data.slice(0, 150)}${traceNote}`, source: "backend", confidence });
+      }
+      for (const p of store.getProcessExits(20, void 0, since)) {
+        if (p.reason === "normal") continue;
+        rows.push({ ts: p.timestamp, icon: "\u{1F4A5}", label: `[${p.process}] crashed (exit ${p.exitCode})`, source: "backend", confidence: "observed" });
+      }
+      for (const c of store.getCIEvents(50, void 0, since)) {
+        const icon = c.status === "failure" ? "\u274C" : c.status === "success" ? "\u2705" : "\u23ED";
+        const tests = c.failedTests && c.failedTests.length > 0 ? ` \u2014 ${c.failedTests.slice(0, 2).map((t) => t.name).join(", ")}` : "";
+        const sha7 = c.shortSha ?? c.sha.slice(0, 7);
+        const shaJoin = browserBuildShas.has(c.sha.toLowerCase()) || browserBuildShas.has(sha7.toLowerCase());
+        rows.push({ ts: c.timestamp, icon, label: `CI ${c.status}: ${c.job}${tests}`, source: "ci", sha: sha7, confidence: shaJoin ? "linked" : "observed" });
+      }
+      for (const d of store.getDeployments(20, void 0, since)) {
+        const icon = d.status === "success" ? "\u{1F680}" : d.status === "failure" ? "\u{1F4A5}" : d.status === "rollback" ? "\u23EA" : "\u23F3";
+        const sha7 = d.shortSha ?? d.sha.slice(0, 7);
+        const shaJoin = browserBuildShas.has(d.sha.toLowerCase()) || browserBuildShas.has(sha7.toLowerCase());
+        rows.push({ ts: d.timestamp, icon, label: `Deploy to ${d.environment}: ${d.status}${d.actor ? " by " + d.actor : ""}`, source: "deploy", sha: sha7, confidence: shaJoin ? "linked" : "observed" });
+      }
+      rows.sort((a, b) => a.ts - b.ts);
+      const trimmed = rows.slice(-limit);
+      const latest = hypothesisHistory.latest();
+      const top = latest?.topHypothesis ?? null;
+      const lines = [];
+      if (top && top.confidenceScore >= 0.45) {
+        const pct = Math.round(top.confidenceScore * 100);
+        lines.push(`## Root Cause \u2014 ${pct}% confidence`, `**${top.summary}**`);
+        if (top.fixHint) lines.push(`Fix: ${top.fixHint}`);
+        lines.push("", "---", "");
+      }
+      const exactCount = trimmed.filter((r) => r.confidence === "exact").length;
+      const linkedCount = trimmed.filter((r) => r.confidence === "linked").length;
+      const temporalCount = trimmed.filter((r) => r.confidence === "temporal").length;
+      lines.push(`## Unified Timeline (last ${Math.round(seconds / 60)}m \xB7 ${trimmed.length} events)`);
+      if (exactCount > 0 || linkedCount > 0 || temporalCount > 0) {
+        const parts = [];
+        if (exactCount > 0) parts.push(`${exactCount} exact trace join${exactCount > 1 ? "s" : ""}`);
+        if (linkedCount > 0) parts.push(`${linkedCount} SHA-linked`);
+        if (temporalCount > 0) parts.push(`${temporalCount} temporal`);
+        lines.push(`*Causal joins: ${parts.join(" \xB7 ")}*`);
+      }
+      lines.push("");
+      for (const r of trimmed) {
+        const time = new Date(r.ts).toISOString().slice(11, 19);
+        const sha = r.sha ? `  [${r.sha}]` : "";
+        lines.push(`\`${time}\`  ${r.icon}  ${badge(r.confidence)}  **[${r.source.toUpperCase()}]**  ${r.label}${sha}`);
+      }
+      if (trimmed.length === 0) {
+        lines.push("*No significant events in the last " + Math.round(seconds / 60) + " minutes.*", "");
+        lines.push("Connect your CI pipeline: `POST /ci/github` or `POST /ci/generic`");
+        lines.push("Notify Mergen of deploys: `POST /deployments`");
+        lines.push("Stream backend logs: `mergen-server watch npm start`");
+      } else {
+        lines.push("", "> `EXACT` = traceId join  \xB7  `LINKED` = SHA/git join  \xB7  `~CORR` = timestamp proximity  \xB7  `OBS` = no cross-signal link");
+      }
+      return { content: [{ type: "text", text: lines.join("\n") }] };
+    })
+  );
+  server.registerTool(
+    "get_ci_results",
+    {
+      description: 'Returns CI/CD run results (GitHub Actions, GitLab CI, etc.) captured by Mergen. Use this when a browser error appeared after a deploy to ask: "Did the CI run for this commit have failures? Which tests?" The commit SHA links CI failures directly to browser errors.',
+      inputSchema: {
+        limit: z.number().int().min(1).max(100).optional().describe("Max results to return (default 20)"),
+        status: z.enum(["success", "failure", "cancelled", "skipped"]).optional().describe('Filter by status \u2014 use "failure" to see only broken builds'),
+        since: z.number().int().optional().describe("Only return CI runs after this Unix timestamp in ms"),
+        sha: z.string().optional().describe("Filter to a specific commit SHA (full or short)")
+      }
+    },
+    async ({ limit, status, since, sha }) => {
+      trackCall("get_ci_results");
+      let events = store.getCIEvents(limit ?? 20, status, since);
+      if (sha) {
+        const s = sha.toLowerCase();
+        events = events.filter((e) => e.sha.startsWith(s) || s.startsWith(e.sha.slice(0, 7)));
+      }
+      if (events.length === 0) {
+        return {
+          content: [{
+            type: "text",
+            text: 'No CI events in buffer.\n\nTo send CI results to Mergen, add to your GitHub Actions workflow:\n\n  - name: Report to Mergen\n    if: always()\n    run: |\n      curl -s -X POST $MERGEN_URL/ci/generic \\\n        -H "Content-Type: application/json" \\\n        -d \'{"sha":"${{ github.sha }}","branch":"${{ github.ref_name }}",\' \\\n           \'"status":"${{ job.status }}","job":"${{ github.job }}"}\'\n\nOr use: POST /ci/github, /ci/gitlab, /ci/generic, /deployments'
+          }]
+        };
+      }
+      const failures = events.filter((e) => e.status === "failure");
+      const lines = [`## CI Results (${events.length} runs, ${failures.length} failure${failures.length !== 1 ? "s" : ""})`, ""];
+      for (const e of events) {
+        const ts = new Date(e.timestamp).toISOString();
+        const icon = e.status === "success" ? "\u2705" : e.status === "failure" ? "\u274C" : "\u23ED";
+        const dur = e.durationMs ? ` (${Math.round(e.durationMs / 1e3)}s)` : "";
+        lines.push(`${icon} **${e.job}** \xB7 ${e.shortSha ?? e.sha.slice(0, 7)} \xB7 ${e.branch ?? ""} \xB7 ${ts}${dur}`);
+        if (e.workflow) lines.push(`   Workflow: ${e.workflow} (${e.provider})`);
+        if (e.url) lines.push(`   URL: ${e.url}`);
+        if (e.failedTests && e.failedTests.length > 0) {
+          lines.push(`   Failed tests (${e.failedTests.length}):`);
+          for (const t of e.failedTests.slice(0, 10))
+            lines.push(`     \u2022 ${t.name}${t.error ? ` \u2014 ${t.error.slice(0, 100)}` : ""}`);
+        }
+        lines.push("");
+      }
+      return { content: [{ type: "text", text: lines.join("\n") }] };
+    }
+  );
+  server.registerTool(
+    "get_deployments",
+    {
+      description: 'Returns deployment events captured by Mergen. Use this to answer "when was this version deployed and who deployed it?" and to correlate browser errors with the specific deploy that introduced them.',
+      inputSchema: {
+        limit: z.number().int().min(1).max(100).optional().describe("Max results to return (default 10)"),
+        environment: z.string().optional().describe('Filter by environment name (e.g. "staging", "production")'),
+        since: z.number().int().optional().describe("Only return deployments after this Unix timestamp in ms")
+      }
+    },
+    async ({ limit, environment, since }) => {
+      trackCall("get_deployments");
+      const events = store.getDeployments(limit ?? 10, environment, since);
+      if (events.length === 0) {
+        return {
+          content: [{
+            type: "text",
+            text: `No deployment events in buffer.
+
+To notify Mergen of a deploy:
+
+  curl -X POST $MERGEN_URL/deployments \\
+    -H "Content-Type: application/json" \\
+    -d '{"sha":"abc1234","environment":"staging","status":"success"}'
+
+Supported status values: started | success | failure | rollback`
+          }]
+        };
+      }
+      const lines = [`## Deployments (${events.length})`, ""];
+      for (const d of events) {
+        const ts = new Date(d.timestamp).toISOString();
+        const icon = d.status === "success" ? "\u{1F680}" : d.status === "failure" ? "\u{1F4A5}" : d.status === "rollback" ? "\u23EA" : "\u23F3";
+        lines.push(`${icon} **${d.environment}** \xB7 ${d.shortSha ?? d.sha.slice(0, 7)} \xB7 ${d.status} \xB7 ${ts}`);
+        if (d.service) lines.push(`   Service: ${d.service}`);
+        if (d.version) lines.push(`   Version: ${d.version}`);
+        if (d.actor) lines.push(`   Actor: ${d.actor}`);
+        if (d.url) lines.push(`   URL: ${d.url}`);
+        lines.push("");
+      }
+      return { content: [{ type: "text", text: lines.join("\n") }] };
+    }
+  );
+  server.registerTool(
+    "get_process_logs",
+    {
+      description: 'Returns stdout/stderr lines captured from local dev servers and containers. Use this when a browser error (e.g. fetch \u2192 500) needs to be correlated with backend output. Filter by process_name to narrow to a specific service (e.g. "backend", "docker:api").',
+      inputSchema: {
+        limit: z.number().int().min(1).max(500).optional().describe("Max lines to return (default 100)"),
+        process_name: z.string().optional().describe('Filter to a specific process or container name (partial match, e.g. "api", "docker:web")'),
+        since: z.number().int().optional().describe("Only return lines after this Unix timestamp in ms"),
+        errors_only: z.boolean().optional().describe("If true, only return lines matching error/exception/panic/fatal patterns"),
+        max_tokens: z.number().int().min(100).max(1e4).optional().describe("Soft token limit for response")
+      }
+    },
+    async ({ limit, process_name, since, errors_only, max_tokens }) => {
+      trackCall("get_process_logs");
+      let events = store.getTerminalOutput(limit ?? 100, void 0, since);
+      if (process_name) {
+        const pat = process_name.toLowerCase();
+        events = events.filter((e) => e.terminalName.toLowerCase().includes(pat));
+      }
+      if (errors_only) {
+        const ERROR_RE = /error|exception|traceback|panic|fatal|unhandled|crash|killed|oom/i;
+        events = events.filter((e) => ERROR_RE.test(e.data));
+      }
+      const processExits = store.getProcessExits(20, void 0, since);
+      if (events.length === 0 && processExits.length === 0) {
+        return {
+          content: [{
+            type: "text",
+            text: "No process logs in buffer.\n\nTo stream a dev server into Mergen:\n  mergen-server watch npm start\n  mergen-server watch python manage.py runserver\n\nOr enable Docker log streaming: MERGEN_DOCKER_LOGS=true"
+          }]
+        };
+      }
+      const sources = [...new Set(events.map((e) => e.terminalName))];
+      const lines = events.map((e) => `[${new Date(e.timestamp).toISOString()}] [${e.terminalName}] ${e.data}`);
+      for (const p of processExits) {
+        lines.push(`[${new Date(p.timestamp).toISOString()}] [${p.process}] EXIT code=${p.exitCode} reason=${p.reason}${p.signal ? " signal=" + p.signal : ""}`);
+      }
+      const header = `Process logs from: ${sources.join(", ")} (${events.length} lines)
+
+`;
+      const { result, truncated, omitted } = truncateToTokenBudget(lines, max_tokens, "\n");
+      if (truncated) logger.info({ tool: "get_process_logs", omitted }, "response truncated");
+      return { content: [{ type: "text", text: header + result }] };
+    }
+  );
+  server.registerTool(
+    "get_code_owners",
+    {
+      description: "Looks up the CODEOWNERS entry for a given file path. Use this after finding a suspect commit to identify which team owns the file and who to page or assign the bug to. Reads .github/CODEOWNERS, CODEOWNERS, or docs/CODEOWNERS from the working directory.",
+      inputSchema: {
+        file_path: z.string().describe('Relative or absolute file path to look up (e.g. "src/auth/token.ts")'),
+        cwd: z.string().optional().describe("Working directory to search for CODEOWNERS (defaults to process.cwd())")
+      }
+    },
+    withTierGate(getTierForTool("get_code_owners"), async ({ file_path, cwd }) => {
+      trackCall("get_code_owners");
+      const { findCodeOwners } = await import("../sensor/git-suspect.js");
+      const result = findCodeOwners(file_path, cwd ?? process.cwd());
+      if (!result) {
+        return {
+          content: [{
+            type: "text",
+            text: `No CODEOWNERS entry found for \`${file_path}\`.
+
+Either no CODEOWNERS file exists in this repo, or the file doesn't match any pattern.
+CODEOWNERS should be at .github/CODEOWNERS, CODEOWNERS, or docs/CODEOWNERS.`
+          }]
+        };
+      }
+      return {
+        content: [{
+          type: "text",
+          text: [
+            `## Code Owners for \`${file_path}\``,
+            "",
+            `**Owners:** ${result.owners.join(", ")}`,
+            `**Matched pattern:** \`${result.pattern}\``,
+            `**Source:** \`${result.source}\``,
+            "",
+            `These are the teams/individuals responsible for this file.`,
+            `Tag them in the bug report or assign the fix to their queue.`
+          ].join("\n")
+        }]
+      };
+    })
+  );
+  server.registerTool(
+    "get_backend_logs",
+    {
+      description: "Returns structured log events from Node.js or Python backend SDKs. Events come from services instrumented with mergen-node or mergen-python. Use service to filter to a specific backend service by name. Use sdk to filter to node or python events only.",
+      inputSchema: {
+        service: z.string().optional().describe("Filter by service name (MERGEN_NAME env var)"),
+        sdk: z.enum(["node", "python"]).optional().describe("Filter to a specific SDK"),
+        level: z.enum(["log", "warn", "error"]).optional().describe("Filter by log level"),
+        since: z.number().int().optional().describe("Only return events after this Unix ms timestamp"),
+        limit: z.number().int().min(1).max(200).optional().describe("Max events (default 50)")
+      }
+    },
+    withTierGate(getTierForTool("get_backend_logs"), async ({ service, sdk, level, since, limit }) => {
+      trackCall("get_backend_logs");
+      let events = store.getLogs(limit ?? 50, level, since);
+      events = events.filter(
+        (e) => e.url?.startsWith("mergen://node/") || e.url?.startsWith("mergen://python/")
+      );
+      if (service) events = events.filter((e) => e.url?.includes(`/${service}`));
+      if (sdk === "node") events = events.filter((e) => e.url?.startsWith("mergen://node/"));
+      if (sdk === "python") events = events.filter((e) => e.url?.startsWith("mergen://python/"));
+      if (events.length === 0) {
+        return { content: [{ type: "text", text: "No backend log events. Instrument your service with mergen-node or mergen-python." }] };
+      }
+      const lines = events.map((e) => {
+        const ts = new Date(e.timestamp).toISOString();
+        const svcLabel = e.url?.split("/").slice(2).join("/") ?? "backend";
+        const args = e.args.map((a) => typeof a === "string" ? a : JSON.stringify(a)).join(" ");
+        const stack = e.stack ? `
+  Stack: ${e.stack}` : "";
+        return `[${ts}] [${e.level.toUpperCase()}] [${svcLabel}] ${args}${stack}`;
+      });
+      return { content: [{ type: "text", text: `${events.length} backend log event(s):
+
+${lines.join("\n")}` }] };
+    })
+  );
+  server.registerTool(
+    "get_backend_spans",
+    {
+      description: "Returns server-side request spans from Node.js or Python SDK middleware. Each span covers one inbound HTTP request: route, method, status, duration, traceId. The traceId links this span to the matching browser network event for end-to-end tracing. Use get_correlated_trace after finding a traceId to see the full round-trip.",
+      inputSchema: {
+        service: z.string().optional().describe("Filter by service name"),
+        trace_id: z.string().optional().describe("Filter to a specific 32-char hex traceId"),
+        status_filter: z.number().int().optional().describe("Filter to a specific HTTP status code (e.g. 500)"),
+        since: z.number().int().optional().describe("Only return spans after this Unix ms timestamp"),
+        limit: z.number().int().min(1).max(200).optional().describe("Max spans (default 50)")
+      }
+    },
+    async ({ service, trace_id, status_filter, since, limit }) => {
+      trackCall("get_backend_spans");
+      if (!getPlan(getActivePlanId()).backendObservability) {
+        return {
+          content: [{
+            type: "text",
+            text: `\u26D4 **Backend span tracing** is a Pro feature.
+
+Upgrade to **Pro ($29/mo)** for OTLP export, backend spans, and end-to-end trace correlation.
+
+\u2192 https://mergen.app/pricing`
+          }],
+          isError: true
+        };
+      }
+      let spans = store.getBackendSpans(limit ?? 50, service, since);
+      if (trace_id) spans = spans.filter((s) => s.traceId.toLowerCase() === trace_id.toLowerCase());
+      if (status_filter !== void 0) spans = spans.filter((s) => s.statusCode === status_filter);
+      if (spans.length === 0) {
+        return { content: [{ type: "text", text: "No backend spans. Add mergen-node Express middleware or mergen-python Django/FastAPI middleware to capture server spans." }] };
+      }
+      const browserTraceIds = new Set(store.getNetwork(200).filter((n) => n.traceId).map((n) => n.traceId));
+      const lines = spans.map((s) => {
+        const ts = new Date(s.timestamp).toISOString();
+        const flag = s.statusCode >= 500 ? " [CRITICAL]" : s.statusCode >= 400 ? " [ERROR]" : "";
+        const joined = browserTraceIds.has(s.traceId) ? " [JOINED\u2192browser]" : "";
+        const err = s.error ? ` \u2014 ${s.error}` : "";
+        return `[${ts}] [${s.sdk}:${s.service}] ${s.method} ${s.route} \u2192 ${s.statusCode} (${s.durationMs}ms)${flag}${joined}${err}
+  traceId: ${s.traceId}`;
+      });
+      return { content: [{ type: "text", text: `${spans.length} backend span(s):
+
+${lines.join("\n\n")}` }] };
+    }
+  );
+  server.registerTool(
+    "get_correlated_trace",
+    {
+      description: "Given a traceId, returns ALL events that share it: the browser fetch/XHR event, the matching backend span, and any backend log lines that logged the same traceId. This gives a deterministic end-to-end view of one request as it traveled from browser to server. Use after get_backend_spans or get_network_activity shows a traceId of interest.",
+      inputSchema: {
+        trace_id: z.string().describe("32-char hex traceId from a network event or backend span")
+      }
+    },
+    async ({ trace_id }) => {
+      trackCall("get_correlated_trace");
+      if (!getPlan(getActivePlanId()).backendObservability) {
+        return {
+          content: [{
+            type: "text",
+            text: `\u26D4 **End-to-end trace correlation** is a Pro feature.
+
+Upgrade to **Pro ($29/mo)** for backend spans and browser-to-server trace correlation.
+
+\u2192 https://mergen.app/pricing`
+          }],
+          isError: true
+        };
+      }
+      const traceId = trace_id.toLowerCase().replace(/-/g, "");
+      if (!/^[0-9a-f]{32}$/.test(traceId)) {
+        return { content: [{ type: "text", text: "Invalid traceId \u2014 must be a 32-char hex string." }] };
+      }
+      const browserNet = store.getNetwork(200).filter((n) => n.traceId?.toLowerCase() === traceId);
+      const backendSpans = store.getBackendSpans(50).filter((s) => s.traceId.toLowerCase() === traceId);
+      const backendLogs = store.getTerminalOutput(200).filter((t) => t.traceId?.toLowerCase() === traceId);
+      if (browserNet.length === 0 && backendSpans.length === 0 && backendLogs.length === 0) {
+        return { content: [{ type: "text", text: `No events found for traceId ${traceId}. The trace may have expired from the buffer.` }] };
+      }
+      const lines = [`Correlated trace: ${traceId}
+`];
+      if (browserNet.length > 0) {
+        lines.push("\u2500\u2500 Browser (fetch/XHR) \u2500\u2500");
+        for (const n of browserNet) {
+          lines.push(`[${new Date(n.timestamp).toISOString()}] ${n.method} ${n.url} \u2192 ${n.status} ${n.statusText} (${n.duration}ms)`);
+          if (n.error) lines.push(`  Error: ${n.error}`);
+          if (n.responseBody) lines.push(`  Response: ${JSON.stringify(n.responseBody).slice(0, 300)}`);
+        }
+        lines.push("");
+      }
+      if (backendSpans.length > 0) {
+        lines.push("\u2500\u2500 Backend spans \u2500\u2500");
+        for (const s of backendSpans) {
+          lines.push(`[${new Date(s.timestamp).toISOString()}] [${s.sdk}:${s.service}] ${s.method} ${s.route} \u2192 ${s.statusCode} (${s.durationMs}ms)`);
+          if (s.error) lines.push(`  Error: ${s.error}`);
+          if (s.userId) lines.push(`  UserId: ${s.userId}`);
+        }
+        lines.push("");
+      }
+      if (backendLogs.length > 0) {
+        lines.push("\u2500\u2500 Backend log lines (traceId extracted from stdout) \u2500\u2500");
+        for (const t of backendLogs)
+          lines.push(`[${new Date(t.timestamp).toISOString()}] [${t.terminalName}] ${t.data.slice(0, 300)}`);
+      }
+      const joinStatus = browserNet.length > 0 && backendSpans.length > 0 ? "\u2705 EXACT JOIN \u2014 browser request matched to backend span" : browserNet.length > 0 ? "\u26A0\uFE0F  PARTIAL \u2014 browser event found, no backend span (SDK not instrumented?)" : "\u26A0\uFE0F  PARTIAL \u2014 backend span found, no browser event";
+      lines.push("", joinStatus);
+      return { content: [{ type: "text", text: lines.join("\n") }] };
+    }
+  );
+  server.registerTool(
+    "get_service_graph",
+    {
+      description: "Returns the live service dependency graph \u2014 which services call which, blast risk for each service (how many upstream callers would be affected by a fix), and historical co-occurrence edges from incident data (which services tend to fail together). Use this BEFORE proposing a fix to understand blast radius: a service with 6+ upstream callers has HIGH blast risk and requires manual approval for any autonomous fix. Also use this to identify cascading failure patterns: if A \u2192 B \u2192 C all show errors simultaneously, fix B first. The OTLP graph is built from live traces; the incident graph accumulates from past incidents. Both are shown \u2014 they complement each other.",
+      inputSchema: {
+        service: z.string().optional().describe(
+          "Focus on a single service. Returns its direct callers, callees, blast risk tier, transitive upstream impact count, and co-incident service history. Omit to see the full cross-service topology."
+        ),
+        include_incidents: z.boolean().optional().describe("Include incident co-occurrence graph (default: true).")
+      }
+    },
+    async ({ service, include_incidents = true }) => {
+      trackCall("get_service_graph");
+      if (service) {
+        const callers = serviceGraph.getCallers(service);
+        const callees = serviceGraph.getCallees(service);
+        const blastRisk = serviceGraph.getBlastRisk(service);
+        const upstream = serviceGraph.getUpstreamImpact(service);
+        const hasOtlpData2 = serviceGraph.size > 0;
+        const coIncident = include_incidents ? incidentStore.coOccurringServices(service, 10 * 6e4, 8) : [];
+        const riskEmoji = blastRisk === "high" ? "\u{1F534}" : blastRisk === "medium" ? "\u{1F7E1}" : "\u{1F7E2}";
+        const lines2 = [
+          `## Service Graph \u2014 \`${service}\``,
+          "",
+          `**Blast risk:** ${riskEmoji} ${blastRisk.toUpperCase()} \u2014 ${upstream.length} transitive upstream service${upstream.length !== 1 ? "s" : ""} affected by a fix`,
+          ""
+        ];
+        if (!hasOtlpData2) {
+          lines2.push(
+            "_OTLP graph is empty \u2014 no spans received yet. Instrument your services with the OpenTelemetry SDK and point them at `:4318/v1/traces` or `:3000/v1/traces` to populate the live topology._",
+            ""
+          );
+        } else {
+          if (callers.length > 0) {
+            lines2.push(
+              `**Callers** (services that call \`${service}\`):`,
+              ...callers.map((s) => `- \`${s}\``),
+              ""
+            );
+          } else {
+            lines2.push(`**Callers:** none observed in OTLP stream`, "");
+          }
+          if (callees.length > 0) {
+            lines2.push(
+              `**Callees** (services \`${service}\` calls):`,
+              ...callees.map((s) => `- \`${s}\``),
+              ""
+            );
+          } else {
+            lines2.push(`**Callees:** none observed in OTLP stream`, "");
+          }
+          if (upstream.length > 0) {
+            lines2.push(
+              `**Transitive upstream impact** (BFS depth \u2264 3):`,
+              upstream.map((s) => `\`${s}\``).join(", "),
+              ""
+            );
+          }
+        }
+        if (include_incidents) {
+          if (coIncident.length > 0) {
+            lines2.push(
+              `**Co-incident services** (failed together within 10 min in incident history):`,
+              "",
+              "| Service | Co-occurrences |",
+              "|---------|---------------|",
+              ...coIncident.map(({ service: s, count }) => `| \`${s}\` | ${count} |`),
+              "",
+              "_High co-occurrence suggests a shared dependency or cascade pattern._"
+            );
+          } else {
+            lines2.push(`**Co-incident services:** no co-occurrence data yet`);
+          }
+        }
+        lines2.push(
+          "",
+          "---",
+          `_Blast risk: LOW = 0\u20132 upstream, MEDIUM = 3\u20135, HIGH = 6+. HIGH blast risk raises the autonomous execution threshold by 10 percentage points._`
+        );
+        return { content: [{ type: "text", text: lines2.join("\n") }] };
+      }
+      const hasOtlpData = serviceGraph.size > 0;
+      const graphJson = serviceGraph.toJSON();
+      const coEdges = include_incidents ? incidentStore.getInteractionGraph() : [];
+      const lines = ["## Service Graph \u2014 Full Topology", ""];
+      if (!hasOtlpData) {
+        lines.push(
+          `**OTLP graph:** empty`,
+          "",
+          "_No OTLP spans received. To populate the live service graph:_",
+          "```",
+          "# Point your services at Mergen:",
+          "OTEL_EXPORTER_OTLP_ENDPOINT=http://127.0.0.1:3000 node your-app.js",
+          "```",
+          ""
+        );
+      } else {
+        const lastUpdated = graphJson.lastUpdated ? `${Math.round((Date.now() - graphJson.lastUpdated) / 1e3)}s ago` : "unknown";
+        lines.push(
+          `**OTLP graph:** ${graphJson.services.length} service${graphJson.services.length !== 1 ? "s" : ""}, ${graphJson.edges.length} edge${graphJson.edges.length !== 1 ? "s" : ""} \xB7 last updated ${lastUpdated}`,
+          "",
+          "**Services:**",
+          graphJson.services.map((s) => {
+            const risk = serviceGraph.getBlastRisk(s);
+            const emoji = risk === "high" ? "\u{1F534}" : risk === "medium" ? "\u{1F7E1}" : "\u{1F7E2}";
+            return `${emoji} \`${s}\``;
+          }).join("  "),
+          ""
+        );
+        const topEdges = [...graphJson.edges].sort((a, b) => b.callCount - a.callCount).slice(0, 5);
+        if (topEdges.length > 0) {
+          lines.push(
+            "**Top call paths (by volume):**",
+            "",
+            "| From | To | Calls | Errors |",
+            "|------|----|-------|--------|",
+            ...topEdges.map((e) => `| \`${e.source}\` | \`${e.target}\` | ${e.callCount} | ${e.errorCount} |`),
+            ""
+          );
+        }
+      }
+      if (include_incidents && coEdges.length > 0) {
+        const topCoEdges = coEdges.slice(0, 5);
+        lines.push(
+          "**Top co-incident pairs (from incident history):**",
+          "",
+          "| Service A | Service B | Co-occurrences |",
+          "|-----------|-----------|---------------|",
+          ...topCoEdges.map((e) => `| \`${e.source}\` | \`${e.target}\` | ${e.weight} |`),
+          "",
+          "_Co-incident pairs often share a common dependency. When both are paging, fix the shared upstream first._"
+        );
+      } else if (include_incidents) {
+        lines.push("**Co-incident pairs:** no incident history yet");
+      }
+      lines.push(
+        "",
+        "---",
+        `_Call \`get_service_graph(service: "name")\` for per-service blast risk and callers/callees._`
+      );
+      return { content: [{ type: "text", text: lines.join("\n") }] };
+    }
+  );
+}
+export {
+  registerInfraTools
+};