mergen-server 1.4.0

package/dist/intelligence/tools-blast-radius.js

@@ -0,0 +1,140 @@
+import { z } from "zod";
+import { store } from "../sensor/buffer.js";
+import { memoryStore } from "../datadog/memory-store.js";
+import { trackCall, withTierGate } from "./tools-state.js";
+import { getTierForTool } from "./tool-manifest.js";
+function registerBlastRadiusTools(server) {
+  _registerBlastRadius(server);
+  _registerAttributionAccuracy(server);
+}
+function _registerBlastRadius(server) {
+  server.tool(
+    "get_blast_radius",
+    'Quantify the user impact of current errors: unique sessions affected, user count, browser/OS segments, first-seen time, and the likely causal deploy. Use this to answer "how many users are broken right now?" during an incident.',
+    {
+      since: z.number().optional().describe("Unix ms \u2014 only count errors after this timestamp. Omit to use all buffered events."),
+      error_pattern: z.string().optional().describe("Regex pattern to filter errors by message text (case-insensitive). Omit for all errors.")
+    },
+    withTierGate(getTierForTool("get_blast_radius"), async ({ since, error_pattern }) => {
+      const report = store.getBlastRadius({
+        since,
+        errorPattern: error_pattern
+      });
+      const text = formatBlastRadius(report, { since, errorPattern: error_pattern });
+      return { content: [{ type: "text", text }] };
+    })
+  );
+}
+function formatBlastRadius(r, opts) {
+  if (r.errorCount === 0) {
+    const window = opts.since ? `since ${new Date(opts.since).toISOString()}` : "in the current buffer";
+    const pattern = opts.errorPattern ? ` matching \`${opts.errorPattern}\`` : "";
+    return `## Blast Radius
+
+No errors found${pattern} ${window}.`;
+  }
+  const lines = ["## Blast Radius"];
+  const hasSessionIds = r.affectedSessions > 0;
+  const hasUserIds = r.affectedUsers > 0;
+  if (hasSessionIds) {
+    const dedupNote = r.returningUserSessions > 0 ? ` (~${r.affectedSessions - r.returningUserSessions} deduplicated \u2014 ${r.returningUserSessions} extra session${r.returningUserSessions !== 1 ? "s" : ""} from returning users)` : "";
+    lines.push(`**${r.affectedSessions} session${r.affectedSessions !== 1 ? "s" : ""} affected**` + (hasUserIds ? ` (${r.affectedUsers} authenticated user${r.affectedUsers !== 1 ? "s" : ""})` : "") + dedupNote);
+  } else {
+    lines.push(`**${r.errorCount} error event${r.errorCount !== 1 ? "s" : ""}** (no session IDs \u2014 count is occurrences, not unique users)`);
+  }
+  if (r.firstSeenAt) {
+    const firstStr = new Date(r.firstSeenAt).toISOString().replace("T", " ").slice(0, 19) + " UTC";
+    const duration = r.durationMs !== null ? ` \u2014 active for **${formatDuration(r.durationMs)}**` : "";
+    lines.push(`First seen: **${firstStr}**${duration}`);
+  }
+  const browsers = Object.entries(r.browserSegments).sort((a, b) => b[1] - a[1]);
+  const oses = Object.entries(r.osSegments).sort((a, b) => b[1] - a[1]);
+  if (browsers.length > 0) {
+    const browserStr = browsers.map(([b, n]) => `${b}: ${n}`).join(", ");
+    lines.push(`Browsers: ${browserStr}`);
+  }
+  if (oses.length > 0) {
+    const osStr = oses.map(([o, n]) => `${o}: ${n}`).join(", ");
+    lines.push(`OS: ${osStr}`);
+  }
+  if (browsers.length === 0 && oses.length === 0) {
+    lines.push("_No userAgent data \u2014 update extension or SDK to enable browser segmentation_");
+  }
+  if (r.correlatedDeploy) {
+    lines.push(`Likely causal deploy: **\`${r.correlatedDeploy}\`** _(most recent successful deploy before first error \u2014 hypothesis, not confirmed)_`);
+  } else {
+    lines.push("No deploy event found prior to first error \u2014 check CI integration.");
+  }
+  if (r.topErrors.length > 0) {
+    lines.push("");
+    lines.push("### Top Errors");
+    for (const { message, count } of r.topErrors) {
+      lines.push(`- \`${message}\` \u2014 ${count}\xD7`);
+    }
+  }
+  if (!hasSessionIds) {
+    lines.push("");
+    lines.push("> **Note:** Session IDs not present. Numbers reflect event count, not unique user count.");
+    lines.push("> Ensure the Mergen extension is updated (v1.1+) or the production SDK is injected.");
+  }
+  return lines.join("\n");
+}
+function formatDuration(ms) {
+  if (ms < 6e4) return `${Math.round(ms / 1e3)}s`;
+  if (ms < 36e5) return `${Math.round(ms / 6e4)}m`;
+  return `${(ms / 36e5).toFixed(1)}h`;
+}
+function _registerAttributionAccuracy(server) {
+  server.tool(
+    "get_attribution_accuracy",
+    "Show the historical accuracy of Mergen's causal blame attribution. Displays how often the attributed deploy SHA matched the actual fix PR SHA, broken down by confidence band. Use this to validate whether attribution scores are trustworthy for your codebase.",
+    {},
+    withTierGate(getTierForTool("get_attribution_accuracy"), async () => {
+      trackCall("get_attribution_accuracy");
+      const all = memoryStore.findSimilar("", 200);
+      const resolved = all.filter(
+        (r) => r.attributionConfidence !== null && r.attributionValidated !== null
+      );
+      if (resolved.length === 0) {
+        return {
+          content: [{
+            type: "text",
+            text: "## Attribution Accuracy\n\nNo validated attributions yet. Attribution accuracy is recorded automatically when incidents resolve with a correlated GitHub PR.\n\nAccuracy data accumulates as incidents are resolved."
+          }]
+        };
+      }
+      const bands = [
+        { label: "HIGH (\u22650.80)", min: 0.8, max: 1.01 },
+        { label: "MEDIUM (0.60\u20130.79)", min: 0.6, max: 0.8 },
+        { label: "LOW (<0.60)", min: 0, max: 0.6 }
+      ];
+      const lines = ["## Attribution Accuracy", ""];
+      let totalCorrect = 0;
+      let totalValidated = 0;
+      for (const band of bands) {
+        const inBand = resolved.filter(
+          (r) => r.attributionConfidence >= band.min && r.attributionConfidence < band.max
+        );
+        if (inBand.length === 0) continue;
+        const correct = inBand.filter((r) => r.attributionValidated === 1).length;
+        const pct = Math.round(correct / inBand.length * 100);
+        totalCorrect += correct;
+        totalValidated += inBand.length;
+        lines.push(`**${band.label}:** ${correct}/${inBand.length} correct (${pct}%)`);
+      }
+      const overallPct = Math.round(totalCorrect / totalValidated * 100);
+      lines.push("", `**Overall:** ${totalCorrect}/${totalValidated} (${overallPct}%)`);
+      if (overallPct >= 80) {
+        lines.push("", "\u2705 Attribution accuracy is strong \u2014 HIGH confidence scores are reliable enough for autonomous action.");
+      } else if (overallPct >= 60) {
+        lines.push("", "\u26A0\uFE0F Attribution accuracy is moderate \u2014 use HIGH confidence for suggestions, require human approval for actions.");
+      } else {
+        lines.push("", "\u274C Attribution accuracy is low \u2014 review signal weights. Possible causes: missing buildSha, git not available, or deploys not posted to Mergen.");
+      }
+      return { content: [{ type: "text", text: lines.join("\n") }] };
+    })
+  );
+}
+export {
+  registerBlastRadiusTools
+};

package/dist/intelligence/tools-browser.js

@@ -0,0 +1,431 @@
+import { z } from "zod";
+import { store } from "../sensor/buffer.js";
+import { serviceTopology } from "../sensor/service-topology.js";
+import { truncateToTokenBudget } from "./token-budget.js";
+import { getActivePlanId } from "./license.js";
+import { getPlan } from "./plans.js";
+import { trackCall } from "./tools-state.js";
+import logger from "../sensor/logger.js";
+function registerBrowserTools(server) {
+  server.registerTool(
+    "get_recent_logs",
+    {
+      description: 'Retrieves runtime events from the event buffer \u2014 recent console events captured from the runtime. Default min_severity is WARN \u2014 console.log spam is filtered out automatically. Use exclude_patterns to suppress known noise (e.g. ["HMR", "\\[vite\\]", "\\[Fast Refresh\\]"]). Use this to drill into specific errors after get_unified_timeline has shown the cross-signal picture. Always lead response with: total errors, total warnings, most critical first.',
+      inputSchema: {
+        limit: z.number().int().min(1).max(200).optional().describe("Max events to return (default 50)"),
+        level: z.enum(["error", "warn", "log"]).optional().describe("Filter by log level"),
+        since: z.number().int().optional().describe("Only return events after this Unix timestamp in ms"),
+        min_severity: z.enum(["log", "warn", "error"]).optional().describe("Minimum severity level (default: warn). Filters out low-priority noise like console.log spam."),
+        exclude_patterns: z.array(z.string()).optional().describe('Regex patterns to exclude, e.g. ["HMR", "webpack", "vite", "\\[Fast Refresh\\]"]. Case-insensitive.'),
+        max_tokens: z.number().int().min(100).max(1e4).optional().describe("Soft token limit for response. Will truncate if exceeded.")
+      }
+    },
+    async ({ limit, level, since, min_severity, exclude_patterns, max_tokens }) => {
+      let events = store.getLogs(limit ?? 50, level, since);
+      const severityThreshold = min_severity || "warn";
+      const severityOrder = { log: 0, warn: 1, error: 2 };
+      events = events.filter((e) => severityOrder[e.level] >= severityOrder[severityThreshold]);
+      if (exclude_patterns && exclude_patterns.length > 0) {
+        try {
+          const regexes = exclude_patterns.map((p) => new RegExp(p, "i"));
+          events = events.filter((e) => {
+            const message = e.args.map((a) => typeof a === "string" ? a : JSON.stringify(a)).join(" ");
+            return !regexes.some((re) => re.test(message));
+          });
+        } catch (err) {
+          logger.warn({ err, exclude_patterns }, "invalid regex in exclude_patterns");
+        }
+      }
+      if (events.length === 0) {
+        return { content: [{ type: "text", text: "No console events match filters." }] };
+      }
+      const errors = events.filter((e) => e.level === "error").length;
+      const warns = events.filter((e) => e.level === "warn").length;
+      const header = `Buffer: ${store.size()} total events. Showing ${events.length} \u2014 ${errors} error(s), ${warns} warning(s).
+
+`;
+      const lines = events.map((e) => {
+        const ts = new Date(e.timestamp).toISOString();
+        const args = e.args.map((a) => typeof a === "string" ? a : JSON.stringify(a)).join(" ");
+        const stack = e.stack ? `
+  Stack: ${e.stack}` : "";
+        const blame = e.gitSuspect ? `
+  Git:   ${e.gitSuspect.sha.slice(0, 7)} by ${e.gitSuspect.author} \u2014 "${e.gitSuspect.summary}"` : "";
+        return `[${ts}] [${e.level.toUpperCase()}] ${args}${stack}${blame}`;
+      });
+      const { result, truncated, omitted, estimatedTokens } = truncateToTokenBudget(lines, max_tokens, "\n");
+      if (truncated) logger.info({ tool: "get_recent_logs", omitted, estimatedTokens }, "response truncated");
+      return { content: [{ type: "text", text: header + result }] };
+    }
+  );
+  server.registerTool(
+    "get_network_activity",
+    {
+      description: "Returns intercepted fetch/XHR events. 404 = missing asset or API call; 500 = critical server error. Use max_tokens to control response size.",
+      inputSchema: {
+        limit: z.number().int().min(1).max(200).optional().describe("Max events to return (default 50)"),
+        status_filter: z.number().int().optional().describe("Filter to a specific HTTP status code (e.g. 404, 500)"),
+        since: z.number().int().optional().describe("Only return events after this Unix timestamp in ms"),
+        max_tokens: z.number().int().min(100).max(1e4).optional().describe("Soft token limit for response. Will truncate if exceeded.")
+      }
+    },
+    async ({ limit, status_filter, since, max_tokens }) => {
+      const events = store.getNetwork(limit ?? 50, status_filter, since);
+      if (events.length === 0) {
+        const msg = status_filter ? `No network events with status ${status_filter}.` : "No network events in buffer.";
+        return { content: [{ type: "text", text: msg }] };
+      }
+      const lines = events.map((e) => {
+        const ts = new Date(e.timestamp).toISOString();
+        const flag = e.status >= 500 ? " [CRITICAL]" : e.status >= 400 ? " [ERROR]" : "";
+        const body = e.error ? ` | error: ${e.error}` : e.responseBody ? ` | response: ${JSON.stringify(e.responseBody).slice(0, 200)}` : "";
+        const trace = e.traceId ? ` | trace: ${e.traceId}` : "";
+        const tracestate = e.tracestate ? ` | tracestate: ${e.tracestate}` : "";
+        const baggage = e.baggage ? ` | baggage: ${JSON.stringify(e.baggage)}` : "";
+        const userId = e.userId ? ` | user: ${e.userId}` : "";
+        return `[${ts}] ${e.method} ${e.url} \u2192 ${e.status} ${e.statusText} (${e.duration}ms)${flag}${body}${trace}${tracestate}${baggage}${userId}`;
+      });
+      const { result, truncated, omitted, estimatedTokens } = truncateToTokenBudget(lines, max_tokens, "\n");
+      if (truncated) logger.info({ tool: "get_network_activity", omitted, estimatedTokens }, "response truncated");
+      return { content: [{ type: "text", text: result }] };
+    }
+  );
+  server.registerTool(
+    "get_dom_context",
+    {
+      description: "Returns DOM and storage snapshots captured at the exact millisecond of each console.error. Shows the page URL, title, focused element, React/Vue component, localStorage, and sessionStorage. Use this to understand what the user was doing and what state the app was in when an error fired. Use focused_element_only=true to minimize token usage.",
+      inputSchema: {
+        limit: z.number().int().min(1).max(50).optional().describe("Max snapshots to return (default 10)"),
+        since: z.number().int().optional().describe("Only return snapshots after this Unix timestamp in ms"),
+        focused_element_only: z.boolean().optional().describe("If true, only return focused element and component (skip storage). Reduces token usage by ~80%."),
+        max_tokens: z.number().int().min(100).max(1e4).optional().describe("Soft token limit for response. Will truncate if exceeded.")
+      }
+    },
+    async ({ limit, since, focused_element_only, max_tokens }) => {
+      const snapshots = store.getContext(limit ?? 10, since);
+      if (snapshots.length === 0) {
+        return { content: [{ type: "text", text: "No context snapshots yet. They are captured automatically on every console.error." }] };
+      }
+      const lines = snapshots.map((s) => {
+        const ts = new Date(s.timestamp).toISOString();
+        const parts = [
+          `[${ts}] ${s.url}`,
+          `  Page: ${s.title}`
+        ];
+        if (s.activeElement) parts.push(`  Focused element: ${s.activeElement}`);
+        if (s.component) parts.push(`  Component: ${s.component}`);
+        if (focused_element_only) return parts.join("\n");
+        const { full: ls, changed: lsChanged } = store.getLocalStorageDiff(s.localStorage, s.url);
+        const lsEntries = Object.entries(ls);
+        if (lsEntries.length > 0) {
+          const changedCount = lsChanged.size;
+          const header = changedCount > 0 ? `  localStorage (${lsEntries.length} keys, ${changedCount} changed):` : `  localStorage (${lsEntries.length} keys):`;
+          parts.push(header);
+          for (const [k, v] of lsEntries) {
+            const badge = lsChanged.has(k) ? "\u{1F504} " : "   ";
+            parts.push(`  ${badge}${k} = ${v}`);
+          }
+        }
+        const ssEntries = Object.entries(s.sessionStorage);
+        if (ssEntries.length > 0) {
+          const showing = ssEntries.slice(0, 10);
+          const header = ssEntries.length > 10 ? `  sessionStorage (showing 10 of ${ssEntries.length}):` : `  sessionStorage (${ssEntries.length} keys):`;
+          parts.push(header);
+          for (const [k, v] of showing) {
+            parts.push(`    ${k} = ${v}`);
+          }
+        }
+        return parts.join("\n");
+      });
+      const { result, truncated, omitted, estimatedTokens } = truncateToTokenBudget(lines, max_tokens, "\n\n");
+      if (truncated) logger.info({ tool: "get_dom_context", omitted, estimatedTokens }, "response truncated");
+      return { content: [{ type: "text", text: result }] };
+    }
+  );
+  server.registerTool(
+    "get_websocket_activity",
+    {
+      description: "Returns WebSocket connection events with message frames. Use this to debug real-time features like chat, live dashboards, or multiplayer games. Shows connection status (open/closed/error), last sent/received frames, and connection duration.",
+      inputSchema: {
+        limit: z.number().int().min(1).max(200).optional().describe("Max connections to return (default 50)"),
+        connection_url: z.string().optional().describe('Filter by WebSocket URL (partial match, e.g. "wss://api.example.com")'),
+        since: z.number().int().optional().describe("Only return events after this Unix timestamp in ms"),
+        max_tokens: z.number().int().min(100).max(1e4).optional().describe("Soft token limit for response. Will truncate if exceeded.")
+      }
+    },
+    async ({ limit, connection_url, since, max_tokens }) => {
+      trackCall("get_websocket_activity");
+      if (!getPlan(getActivePlanId()).websocketInspection) {
+        return {
+          content: [{
+            type: "text",
+            text: `\u26D4 **WebSocket Inspection** is a Pro feature.
+
+Upgrade to **Pro ($29/mo)** to inspect WebSocket connections and message frames.
+
+\u2192 https://mergen.app/pricing`
+          }],
+          isError: true
+        };
+      }
+      const events = store.getWebSockets(limit ?? 50, connection_url, since);
+      if (events.length === 0) {
+        const msg = connection_url ? `No WebSocket activity for URL containing "${connection_url}".` : "No WebSocket activity in buffer.";
+        return { content: [{ type: "text", text: msg }] };
+      }
+      const lines = events.map((e) => {
+        const ts = new Date(e.timestamp).toISOString();
+        const parts = [
+          `[${ts}] WebSocket: ${e.url}`,
+          `  Connection ID: ${e.connectionId}`,
+          `  Status: ${e.status.toUpperCase()}`
+        ];
+        if (e.code !== void 0) parts.push(`  Close code: ${e.code}`);
+        if (e.reason) parts.push(`  Close reason: ${e.reason}`);
+        if (e.error) parts.push(`  Error: ${e.error}`);
+        if (e.frames && e.frames.length > 0) {
+          parts.push(`  Frames captured: ${e.frames.length}`);
+          parts.push(`  Recent frames:`);
+          const recentFrames = e.frames.slice(-5);
+          for (const frame of recentFrames) {
+            const direction = frame.direction === "sent" ? "\u2192" : "\u2190";
+            const frameTs = new Date(frame.timestamp).toISOString().split("T")[1].split(".")[0];
+            parts.push(`    ${direction} [${frameTs}] ${frame.data}`);
+          }
+          if (e.frames.length > 5) parts.push(`    ... (${e.frames.length - 5} more frames)`);
+        }
+        return parts.join("\n");
+      });
+      const { result, truncated, omitted, estimatedTokens } = truncateToTokenBudget(lines, max_tokens, "\n\n");
+      if (truncated) logger.info({ tool: "get_websocket_activity", omitted, estimatedTokens }, "response truncated");
+      return { content: [{ type: "text", text: result }] };
+    }
+  );
+  server.registerTool(
+    "get_sse_activity",
+    {
+      description: "Returns Server-Sent Events (EventSource) activity. Use this to debug real-time server push features. Shows connection status and recent messages.",
+      inputSchema: {
+        limit: z.number().int().min(1).max(200).optional().describe("Max connections to return (default 50)"),
+        connection_url: z.string().optional().describe("Filter by SSE URL (partial match)"),
+        since: z.number().int().optional().describe("Only return events after this Unix timestamp in ms"),
+        max_tokens: z.number().int().min(100).max(1e4).optional().describe("Soft token limit for response. Will truncate if exceeded.")
+      }
+    },
+    async ({ limit, connection_url, since, max_tokens }) => {
+      trackCall("get_sse_activity");
+      if (!getPlan(getActivePlanId()).websocketInspection) {
+        return {
+          content: [{
+            type: "text",
+            text: `\u26D4 **SSE / EventSource Inspection** is a Pro feature.
+
+Upgrade to **Pro ($29/mo)** to inspect Server-Sent Events streams.
+
+\u2192 https://mergen.app/pricing`
+          }],
+          isError: true
+        };
+      }
+      const events = store.getSSE(limit ?? 50, connection_url, since);
+      if (events.length === 0) {
+        const msg = connection_url ? `No SSE activity for URL containing "${connection_url}".` : "No SSE activity in buffer.";
+        return { content: [{ type: "text", text: msg }] };
+      }
+      const lines = events.map((e) => {
+        const ts = new Date(e.timestamp).toISOString();
+        const parts = [
+          `[${ts}] SSE: ${e.url}`,
+          `  Connection ID: ${e.connectionId}`,
+          `  Status: ${e.status.toUpperCase()}`
+        ];
+        if (e.messages && e.messages.length > 0) {
+          parts.push(`  Messages received: ${e.messages.length}`);
+          parts.push(`  Recent messages:`);
+          const recentMessages = e.messages.slice(-5);
+          for (const msg of recentMessages) {
+            const msgTs = new Date(msg.timestamp).toISOString().split("T")[1].split(".")[0];
+            parts.push(`    [${msgTs}] ${msg.data}`);
+          }
+          if (e.messages.length > 5) parts.push(`    ... (${e.messages.length - 5} more messages)`);
+        }
+        return parts.join("\n");
+      });
+      const { result, truncated, omitted, estimatedTokens } = truncateToTokenBudget(lines, max_tokens, "\n\n");
+      if (truncated) logger.info({ tool: "get_sse_activity", omitted, estimatedTokens }, "response truncated");
+      return { content: [{ type: "text", text: result }] };
+    }
+  );
+  server.registerTool(
+    "get_component_tree",
+    {
+      description: '\u{1F333} PRO \xB7 Returns React or Vue component tree with props, state, and hooks. Use this to debug "component not re-rendering", "props not updating", or "infinite render loop" issues. Shows component hierarchy, current prop/state values, and hook dependencies.',
+      inputSchema: {
+        component_name: z.string().optional().describe('Optional: filter to a specific component name (e.g., "UserProfile", "LoginForm")'),
+        max_depth: z.number().int().min(1).max(10).optional().describe("Max tree depth to traverse (default: 5)"),
+        since: z.number().int().optional().describe("Only return component snapshots after this Unix timestamp in ms"),
+        max_tokens: z.number().int().min(100).max(1e4).optional().describe("Soft token limit for response. Will truncate if exceeded.")
+      }
+    },
+    async ({ component_name, max_depth, since, max_tokens }) => {
+      trackCall("get_component_tree");
+      if (!getPlan(getActivePlanId()).componentTree) {
+        return {
+          content: [{
+            type: "text",
+            text: `\u26D4 **Component Tree Inspection** is a Pro feature.
+
+Upgrade to **Pro ($29/mo)** to inspect React and Vue component trees, props, state, and hooks.
+
+\u2192 https://mergen.app/pricing`
+          }],
+          isError: true
+        };
+      }
+      void component_name;
+      const contexts = store.getContext(50, since);
+      const withTrees = contexts.filter((c) => c.componentTree);
+      if (withTrees.length === 0) {
+        return {
+          content: [{
+            type: "text",
+            text: "No component trees captured yet. Component trees are automatically captured on console.error events.\n\nTo manually capture, trigger an error in your app or wait for the next error to occur."
+          }]
+        };
+      }
+      const depth = max_depth ?? 5;
+      function formatReactNode(node, d) {
+        if (d > depth) return [];
+        const indent = "  ".repeat(d);
+        const out = [];
+        const renderBadge = node.renderCount && node.renderCount > 0 ? ` (renders: ${node.renderCount}${node.renderCount > 10 ? " \u26A0" : ""})` : "";
+        out.push(`${indent}${node.name}${renderBadge}`);
+        if (node.props && Object.keys(node.props).length > 0) {
+          out.push(`${indent}  props:`);
+          for (const [key, val] of Object.entries(node.props).slice(0, 5))
+            out.push(`${indent}    ${key}: ${String(val).slice(0, 100)}`);
+        }
+        if (node.state && Object.keys(node.state).length > 0) {
+          out.push(`${indent}  state:`);
+          for (const [key, val] of Object.entries(node.state).slice(0, 5))
+            out.push(`${indent}    ${key}: ${String(val).slice(0, 100)}`);
+        }
+        if (node.hooks && node.hooks.length > 0) {
+          out.push(`${indent}  hooks:`);
+          for (const hook of node.hooks.slice(0, 5))
+            out.push(`${indent}    [${hook.index}]: ${hook.value.slice(0, 100)}`);
+        }
+        for (const child of node.children ?? []) out.push(...formatReactNode(child, d + 1));
+        return out;
+      }
+      function formatVueNode(node, d) {
+        if (d > depth) return [];
+        const indent = "  ".repeat(d);
+        const out = [];
+        out.push(`${indent}${node.name}`);
+        if (node.props && Object.keys(node.props).length > 0) {
+          out.push(`${indent}  props:`);
+          for (const [key, val] of Object.entries(node.props).slice(0, 5))
+            out.push(`${indent}    ${key}: ${String(val).slice(0, 100)}`);
+        }
+        const dataSource = node.state ?? node.data;
+        if (dataSource && Object.keys(dataSource).length > 0) {
+          out.push(`${indent}  ${node.state ? "state" : "data"}:`);
+          for (const [key, val] of Object.entries(dataSource).slice(0, 5))
+            out.push(`${indent}    ${key}: ${String(val).slice(0, 100)}`);
+        }
+        for (const child of node.children ?? []) out.push(...formatVueNode(child, d + 1));
+        return out;
+      }
+      const lines = ["## \u{1F332} Component Tree", ""];
+      for (const ctx of withTrees.slice(-3)) {
+        const tree = ctx.componentTree;
+        if (!tree) continue;
+        lines.push(`**Captured at:** ${new Date(ctx.timestamp).toISOString()}`);
+        lines.push(`**Framework:** ${tree.framework}`);
+        lines.push(`**URL:** ${ctx.url}`);
+        lines.push("");
+        if (tree.framework === "React" && tree.tree) {
+          lines.push("```");
+          lines.push(...formatReactNode(tree.tree, 0));
+          lines.push("```");
+        }
+        if ((tree.framework === "Vue" || tree.framework === "Vue3") && tree.tree) {
+          lines.push("```");
+          lines.push(...formatVueNode(tree.tree, 0));
+          lines.push("```");
+        }
+        lines.push("");
+      }
+      lines.push("---");
+      lines.push("**Debug hints:**");
+      lines.push("- `renders: N \u26A0` means this component type committed >10 times \u2014 check for missing deps in useEffect/useMemo");
+      lines.push("- Missing props? Check parent component's render method");
+      lines.push("- State not updating? Verify setState/dispatch calls");
+      const { result, truncated, omitted, estimatedTokens } = truncateToTokenBudget(lines, max_tokens, "\n");
+      if (truncated) logger.info({ tool: "get_component_tree", omitted, estimatedTokens }, "response truncated");
+      return { content: [{ type: "text", text: result }] };
+    }
+  );
+  server.registerTool(
+    "get_service_topology",
+    {
+      description: '\u26A1 FREE \xB7 Returns the persistent service dependency graph as structured JSON \u2014 every service Mergen has observed (browser, API, database, queue, cache, infra), their dependencies, call counts, error rates, and p99 latencies. Built incrementally from backend spans and W3C trace joins. Survives server restarts. Use this to understand system structure before diagnosing an incident: "what services exist?", "what calls what?", "which service has the most errors?". Returns empty graph if no backend spans have been received yet \u2014 install the Node.js or Python SDK to start populating it.'
+    },
+    async () => {
+      trackCall("get_service_topology");
+      const snap = serviceTopology.snapshot();
+      if (snap.nodes.length === 0) {
+        return {
+          content: [{
+            type: "text",
+            text: [
+              "## Service Topology\n",
+              "> No services observed yet. The topology is built from backend spans.",
+              "> Install the Mergen SDK in your backend services to start populating it:",
+              "> - Node.js: `npm install @mergen/node`",
+              "> - Python: `pip install mergen`",
+              "",
+              "Browser-side network events are already captured.",
+              "Service-to-service edges appear once backend spans arrive."
+            ].join("\n")
+          }]
+        };
+      }
+      const lines = ["## Service Topology\n"];
+      lines.push(`**${snap.summary.totalServices} services \xB7 ${snap.summary.totalEdges} edges**
+`);
+      if (snap.summary.criticalPath.length > 0) {
+        lines.push(`**Critical path:** ${snap.summary.criticalPath.join(" \u2192 ")}
+`);
+      }
+      if (snap.summary.errorHotspot) {
+        lines.push(`**Error hotspot:** \`${snap.summary.errorHotspot}\``);
+      }
+      if (snap.summary.slowestEdge) {
+        const e = snap.summary.slowestEdge;
+        lines.push(`**Slowest edge:** \`${e.from} \u2192 ${e.to}\` (${e.avgDurationMs}ms avg)
+`);
+      }
+      lines.push("### Services\n");
+      lines.push("| Service | Type | Calls | Errors | Avg ms | p99 ms |");
+      lines.push("|---------|------|-------|--------|--------|--------|");
+      for (const n of snap.nodes.sort((a, b) => b.spanCount - a.spanCount)) {
+        const errPct = n.spanCount > 0 ? (n.errorCount / n.spanCount * 100).toFixed(1) : "0.0";
+        const errCell = n.errorCount > 0 ? `${n.errorCount} (${errPct}%)` : "0";
+        lines.push(`| \`${n.id}\` | ${n.type} | ${n.spanCount} | ${errCell} | ${n.avgDurationMs} | ${n.p99DurationMs} |`);
+      }
+      lines.push("\n### Dependencies\n");
+      for (const e of snap.edges.sort((a, b) => b.callCount - a.callCount)) {
+        const errInfo = e.errorCount > 0 ? ` \xB7 \u26A0\uFE0F ${e.errorCount} errors` : "";
+        lines.push(`- \`${e.from}\` \u2192 \`${e.to}\` (${e.callCount} calls \xB7 ${e.avgDurationMs}ms avg${errInfo})`);
+      }
+      lines.push("\n---");
+      lines.push(`*Updated: ${snap.capturedAt} \xB7 Raw JSON: GET /topology*`);
+      return { content: [{ type: "text", text: lines.join("\n") }] };
+    }
+  );
+}
+export {
+  registerBrowserTools
+};