mergen-server 1.4.0

package/dist/intelligence/tools-debug-sessions.js

@@ -0,0 +1,209 @@
+import { z } from "zod";
+import { store } from "../sensor/buffer.js";
+import { trackCall } from "./tools-state.js";
+import {
+  startDebugSession,
+  checkpointSession,
+  endDebugSession,
+  getSession,
+  listActiveSessions,
+  captureSnapshot
+} from "./debug-sessions.js";
+function registerDebugSessionTools(server) {
+  server.registerTool(
+    "start_debug_session",
+    {
+      description: "\u26A1 FREE \xB7 Start an iterative debugging session. Fingerprints every current error/warning/network failure as a baseline. After each fix attempt, call checkpoint_debug_session to get a precise 3-way diff: \u2705 resolved | \u274C persisted | \u26A0\uFE0F new regressions. Closes the loop \u2014 no more manually describing what changed between iterations.",
+      inputSchema: {
+        hypothesis: z.string().min(10).max(500).describe('What you think is broken (e.g. "JWT token expires before refresh fires")'),
+        target_component: z.string().optional().describe('Optional component/file to focus on (e.g. "LoginForm", "auth.ts")')
+      }
+    },
+    async ({ hypothesis, target_component }) => {
+      trackCall("start_debug_session");
+      const errors = store.getLogs(200, "error");
+      const warns = store.getLogs(200, "warn");
+      const netFail = store.getNetwork(200).filter((n) => n.status >= 400 || n.status === 0 || n.error);
+      const baseline = captureSnapshot(errors, warns, netFail);
+      const session = startDebugSession(hypothesis, baseline, target_component);
+      const lines = [
+        "## \u{1F52C} Debug Session Started",
+        "",
+        `**Session ID:** \`${session.id}\``,
+        `**Hypothesis:** ${hypothesis}`,
+        ...target_component ? [`**Target:** ${target_component}`] : [],
+        "",
+        "### Baseline Fingerprinted",
+        `| | Count |`,
+        `|---|---|`,
+        `| Errors           | ${baseline.errors.length} |`,
+        `| Warnings         | ${baseline.warnings.length} |`,
+        `| Network failures | ${baseline.networkFailures.length} |`
+      ];
+      if (baseline.errors.length > 0) {
+        lines.push("", "**Errors to resolve:**", "```");
+        for (const e of baseline.errors.slice(0, 5))
+          lines.push(`[${e.level.toUpperCase()}] ${e.message.slice(0, 150)}`);
+        if (baseline.errors.length > 5) lines.push(`... +${baseline.errors.length - 5} more`);
+        lines.push("```");
+      } else {
+        lines.push("", "> \u2705 No errors at baseline \u2014 session will track any NEW errors that appear.");
+      }
+      lines.push(
+        "",
+        "### Workflow",
+        "1. Apply your fix to the code",
+        "2. Reproduce the scenario in the browser",
+        `3. Call \`checkpoint_debug_session\` with \`session_id: "${session.id}"\` + a short note`,
+        "4. See what resolved, what persisted, and any regressions",
+        `5. Repeat until clean, then call \`end_debug_session("${session.id}")\``
+      );
+      return { content: [{ type: "text", text: lines.join("\n") }] };
+    }
+  );
+  server.registerTool(
+    "checkpoint_debug_session",
+    {
+      description: "\u26A1 FREE \xB7 Record a fix attempt and see the exact diff vs baseline. Call this after every code change + browser reproduction \u2014 no credit cost. Returns: \u2705 resolved (gone) | \u274C persisted (still broken) | \u26A0\uFE0F new (regression). Use end_debug_session when satisfied.",
+      inputSchema: {
+        session_id: z.string().describe("Session ID from start_debug_session"),
+        note: z.string().max(300).optional().describe('What you just changed (e.g. "added null check before token read")')
+      }
+    },
+    async ({ session_id, note }) => {
+      trackCall("checkpoint_debug_session");
+      const session = getSession(session_id);
+      if (!session) {
+        const active = listActiveSessions().map((s2) => `"${s2.id.slice(0, 8)}\u2026" (${s2.description.slice(0, 40)})`).join(", ");
+        return {
+          content: [{ type: "text", text: `\u274C Session \`${session_id}\` not found.
+Active: ${active || "none"}` }],
+          isError: true
+        };
+      }
+      const errors = store.getLogs(200, "error", session.baseline.capturedAt);
+      const warns = store.getLogs(200, "warn", session.baseline.capturedAt);
+      const netFail = store.getNetwork(200, void 0, session.baseline.capturedAt).filter((n) => n.status >= 400 || n.status === 0 || n.error);
+      const current = captureSnapshot(errors, warns, netFail);
+      const iterNote = note ?? `Fix attempt ${session.iterations.length + 1}`;
+      const result = checkpointSession(session_id, current, iterNote);
+      if (!result) return { content: [{ type: "text", text: "\u274C Session expired." }], isError: true };
+      const { diff, session: s } = result;
+      const lines = [
+        `## \u{1F52C} Checkpoint \u2014 Iteration ${s.iterations.length}`,
+        `**Fix applied:** ${iterNote}`,
+        "",
+        "### Diff vs Baseline",
+        ""
+      ];
+      if (diff.resolved.length > 0) {
+        lines.push(`\u2705 **Resolved (${diff.resolved.length}) \u2014 gone:**`);
+        diff.resolved.forEach((e) => lines.push(`  - \`${e.message.slice(0, 120)}\``));
+        lines.push("");
+      }
+      if (diff.persisted.length > 0) {
+        lines.push(`\u274C **Persisted (${diff.persisted.length}) \u2014 fix didn't work:**`);
+        diff.persisted.forEach((e) => lines.push(`  - \`${e.message.slice(0, 120)}\``));
+        lines.push("");
+      }
+      if (diff.newErrors.length > 0) {
+        lines.push(`\u26A0\uFE0F **New regressions (${diff.newErrors.length}):**`);
+        diff.newErrors.forEach((e) => lines.push(`  - \`${e.message.slice(0, 120)}\``));
+        lines.push("");
+      }
+      if (diff.resolvedNetworkFailures.length > 0) {
+        lines.push(`\u2705 **Network failures fixed (${diff.resolvedNetworkFailures.length}):**`);
+        diff.resolvedNetworkFailures.forEach((n) => lines.push(`  - \`${n.summary}\``));
+        lines.push("");
+      }
+      if (diff.newNetworkFailures.length > 0) {
+        lines.push(`\u26A0\uFE0F **New network failures (${diff.newNetworkFailures.length}):**`);
+        diff.newNetworkFailures.forEach((n) => lines.push(`  - \`${n.summary}\``));
+        lines.push("");
+      }
+      if (!diff.resolved.length && !diff.persisted.length && !diff.newErrors.length && !diff.resolvedNetworkFailures.length && !diff.newNetworkFailures.length) {
+        lines.push("> \u26A0\uFE0F No events since session start. Reproduce the scenario in the browser first.");
+      }
+      lines.push("---");
+      if (diff.isFixed) {
+        lines.push(`\u2705 **All baseline errors resolved!** Call \`end_debug_session("${session_id}")\`.`);
+      } else {
+        const rem = diff.persisted.length + diff.newErrors.length;
+        lines.push(`\u274C **${rem} error(s) remain.** Apply another fix, reproduce, then checkpoint again.`);
+        lines.push(`> \u{1F4A1} \`reconstruct_context(since: ${session.baseline.capturedAt})\` for root-cause + fix.`);
+      }
+      return { content: [{ type: "text", text: lines.join("\n") }] };
+    }
+  );
+  server.registerTool(
+    "end_debug_session",
+    {
+      description: "\u26A1 FREE \xB7 Close a debugging session with a final resolved/persisted/new diff. Use when the bug is fixed or you are done. For mid-session progress checks without closing, use checkpoint_debug_session.",
+      inputSchema: {
+        session_id: z.string().describe("Session ID from start_debug_session")
+      }
+    },
+    async ({ session_id }) => {
+      trackCall("end_debug_session");
+      const session = getSession(session_id);
+      if (!session) {
+        const active = listActiveSessions().map((s2) => `"${s2.id.slice(0, 8)}\u2026"`).join(", ");
+        return {
+          content: [{ type: "text", text: `\u274C Session \`${session_id}\` not found. Active: ${active || "none"}` }],
+          isError: true
+        };
+      }
+      const errors = store.getLogs(200, "error", session.baseline.capturedAt);
+      const warns = store.getLogs(200, "warn", session.baseline.capturedAt);
+      const netFail = store.getNetwork(200, void 0, session.baseline.capturedAt).filter((n) => n.status >= 400 || n.status === 0 || n.error);
+      const current = captureSnapshot(errors, warns, netFail);
+      const result = endDebugSession(session_id, current);
+      if (!result) return { content: [{ type: "text", text: "\u274C Session already closed." }], isError: true };
+      const { session: s, diff } = result;
+      const duration = Math.round(((s.endedAt ?? Date.now()) - s.startedAt) / 1e3);
+      const lines = [
+        "## \u{1F52C} Debug Session Closed",
+        "",
+        `**Hypothesis:** ${s.description}`,
+        ...s.targetComponent ? [`**Target:** ${s.targetComponent}`] : [],
+        `**Duration:** ${duration}s  |  **Iterations:** ${s.iterations.length}`,
+        "",
+        "### Final Diff vs Baseline",
+        ""
+      ];
+      if (diff.resolved.length > 0) {
+        lines.push(`\u2705 **Resolved (${diff.resolved.length}):**`);
+        diff.resolved.forEach((e) => lines.push(`  - \`${e.message.slice(0, 120)}\``));
+        lines.push("");
+      }
+      if (diff.persisted.length > 0) {
+        lines.push(`\u274C **Still broken (${diff.persisted.length}):**`);
+        diff.persisted.forEach((e) => lines.push(`  - \`${e.message.slice(0, 120)}\``));
+        lines.push("");
+      }
+      if (diff.newErrors.length > 0) {
+        lines.push(`\u26A0\uFE0F **New regressions (${diff.newErrors.length}):**`);
+        diff.newErrors.forEach((e) => lines.push(`  - \`${e.message.slice(0, 120)}\``));
+        lines.push("");
+      }
+      if (diff.resolvedNetworkFailures.length > 0) {
+        lines.push(`\u2705 **Network failures fixed (${diff.resolvedNetworkFailures.length}):**`);
+        diff.resolvedNetworkFailures.forEach((n) => lines.push(`  - \`${n.summary}\``));
+        lines.push("");
+      }
+      lines.push("---");
+      if (diff.isFixed) {
+        lines.push("\u2705 **Bug resolved.** All baseline errors gone, no regressions.");
+      } else if (diff.persisted.length > 0 || diff.newErrors.length > 0) {
+        const rem = diff.persisted.length + diff.newErrors.length;
+        lines.push(`\u26A0\uFE0F Closed with **${rem} unresolved error(s)**. Start a new session to continue.`);
+      } else {
+        lines.push("\u2139\uFE0F No events since session start \u2014 scenario may not have been reproduced.");
+      }
+      return { content: [{ type: "text", text: lines.join("\n") }] };
+    }
+  );
+}
+export {
+  registerDebugSessionTools
+};

package/dist/intelligence/tools-discovery.js

@@ -0,0 +1,284 @@
+import { z } from "zod";
+import { ALL_TOOLS } from "./tool-manifest.js";
+import { trackCall } from "./tools-state.js";
+import { store } from "../sensor/buffer.js";
+import { serviceTopology } from "../sensor/service-topology.js";
+function registerDiscoveryTools(server) {
+  server.registerTool(
+    "discover_repo_context",
+    {
+      description: "Phase 0 repository exploration \u2014 call this BEFORE writing any code. Returns: domain vocabulary, existing patterns, reusable utilities, testing conventions, and all registered MCP tools and REST routes. Read-only; makes no changes. Use the returned context to avoid duplicating logic that already exists.",
+      inputSchema: {
+        focus: z.enum(["all", "tools", "routes", "types", "testing", "utilities"]).optional().describe("Narrow the report to a specific area (default: all)")
+      }
+    },
+    async ({ focus = "all" }) => {
+      trackCall("discover_repo_context");
+      const sections = ["## Repository Discovery Report (Phase 0)", ""];
+      if (focus === "all" || focus === "tools") {
+        const byModule = /* @__PURE__ */ new Map();
+        for (const t of ALL_TOOLS) {
+          const group = byModule.get(t.module) ?? [];
+          group.push(t);
+          byModule.set(t.module, group);
+        }
+        sections.push("### Registered MCP Tools", "");
+        sections.push("Before adding a new tool, verify no existing tool already covers your need.", "");
+        for (const [mod, tools] of byModule) {
+          sections.push(`**${mod}**`);
+          for (const t of tools) {
+            sections.push(`  - \`${t.name}\` (tier: ${t.tier})`);
+          }
+        }
+        sections.push("");
+        sections.push(
+          `**Pattern:** Register in \`intelligence/tool-manifest.ts\` + \`intelligence/tools-state.ts\` (KNOWN_TOOLS). Implement in \`intelligence/tools-<module>.ts\`. Export a \`registerXxxTools(server)\` function.`,
+          ""
+        );
+      }
+      if (focus === "all" || focus === "routes") {
+        sections.push("### REST Route Conventions", "");
+        sections.push(
+          "Each route module exports a **factory function** (e.g. `createIncidentsRouter(): Router`).",
+          "The factory is imported in `app.ts` and mounted with `app.use(createXxxRouter())`.",
+          "Zod validates all request bodies. Return `{ ok: true, ... }` on success, `{ error: string }` on failure.",
+          "",
+          "**Existing route modules** (check before adding a new one):",
+          "`sensor`, `incidents`, `pagerduty`, `github-webhook`, `ci`, `sessions`, `postmortem`,",
+          "`calibration`, `dashboard`, `impact-report`, `shadow-report`, `rbac`, `overrides`,",
+          "`validate`, `license`, `api-keys`, `setup-ui`, `explain-why`, `war-room`,",
+          "`slack-routing`, `heartbeats`, `habituation`, `active-authors`, `agent-blunders`,",
+          "`telemetry`, `demo`, `sentry`, `otel`, `otlp-receiver`, `layers`, `billing-outcome`,",
+          "`tickets`, `incident-webhook`, `sdk`, `adr`, `confidence`",
+          ""
+        );
+      }
+      if (focus === "all" || focus === "types") {
+        sections.push("### Domain Vocabulary (canonical type names)", "");
+        sections.push(
+          "Use these names exactly. Never use generic alternatives like `data`, `item`, `payload`.",
+          "",
+          "**Event types** (from `sensor/buffer-schemas.ts`):",
+          "`ConsoleEvent`, `NetworkEvent`, `ContextSnapshot`, `WebSocketEvent`, `SSEEvent`,",
+          "`DiagnosticEvent`, `TerminalOutputEvent`, `TestResultEvent`, `ProcessExitEvent`,",
+          "`CIEvent`, `DeploymentEvent`, `BackendSpanEvent`, `BrowserEvent`",
+          "",
+          "**Core concepts**:",
+          "`ToolEntry`, `ToolTier` (free|pro|all), `AdrRecord`, `ConfidenceReport`,",
+          "`RollbackStrategy`, `RollbackPlan`, `BlastRadiusReport`, `SessionSignal`",
+          "",
+          "**Key identifiers**: `pid` (hypothesis ID), `sessionId`, `traceId`, `spanId`, `buildSha`",
+          ""
+        );
+      }
+      if (focus === "all" || focus === "testing") {
+        sections.push("### Testing Conventions", "");
+        sections.push(
+          "**Framework:** Vitest (`vitest run`)",
+          "**Test location:** Colocate `.test.ts` next to the implementation file, OR place in `src/__tests__/`.",
+          "**Coverage floors:** lines 80%, functions 80%, branches 75%.",
+          "**Import style:** use `.js` extension even for `.ts` source files (Node16 module resolution).",
+          "",
+          "**Required:** After adding an MCP tool, run `tool-manifest.test.ts` to verify consistency.",
+          "",
+          "**Mocking pattern:**",
+          "```typescript",
+          "vi.mock('../intelligence/license.js', async (importOriginal) => {",
+          "  const actual = await importOriginal() as Record<string, unknown>;",
+          "  return { ...actual, getActivePlanId: vi.fn(() => 'free') };",
+          "});",
+          "```",
+          "",
+          "**Arrange-Act-Assert structure** is expected in all test cases.",
+          ""
+        );
+      }
+      if (focus === "all" || focus === "utilities") {
+        sections.push("### Reusable Utilities (check before writing a duplicate)", "");
+        sections.push(
+          "| Utility | Path | Purpose |",
+          "|---------|------|---------|",
+          "| `store` | `sensor/buffer.ts` | Ring buffer: getLogs, getNetwork, getContext, getSignals, push, clear |",
+          "| `trackCall(tool)` | `intelligence/tools-state.ts` | Increment MCP tool call counter |",
+          "| `withTierGate(tier, handler)` | `intelligence/tools-state.ts` | Enforce plan-tier access on a tool handler |",
+          "| `getTierForTool(name)` | `intelligence/tool-manifest.ts` | Lookup a tool's tier from the manifest |",
+          "| `adrStore` | `sensor/adr-store.ts` | List/get/add Architectural Decision Records |",
+          "| `incidentStore` | `sensor/incident-store.ts` | CRUD for open/acknowledged/resolved incidents |",
+          "| `logger` | `sensor/logger.ts` | Pino logger \u2014 use instead of console.log |",
+          "| `DATA_DIR`, `zeroRetentionMode()` | `sensor/paths.ts` | File paths and zero-retention guard |",
+          "| `executeRemediation(cmd)` | `intelligence/autonomy.ts` | Safe command execution (blocklist, audit, RBAC) |",
+          "| `deriveRollback(cmd)` | `intelligence/rollback.ts` | Derive inverse command for rollback |",
+          "| `generateRollbackPlan(intent)` | `intelligence/rollback.ts` | Pre-implementation rollback plan |",
+          ""
+        );
+      }
+      sections.push("---");
+      sections.push("*This report is generated from live server state. Re-run after adding tools or routes.*");
+      return { content: [{ type: "text", text: sections.join("\n") }] };
+    }
+  );
+  server.registerTool(
+    "get_buffer_schema",
+    {
+      description: "Inspect the live event buffer without reading raw events \u2014 returns a structural summary: event types present, log levels, URL patterns, detected services, error patterns, and time range. Free to call; no credits consumed. Use this before `analyze_runtime` to understand what telemetry is available and calibrate how much context to request.",
+      inputSchema: {
+        include_samples: z.boolean().optional().describe("Include one sample message per error pattern (default: false).")
+      }
+    },
+    async ({ include_samples = false }) => {
+      trackCall("get_buffer_schema");
+      const logs = store.getLogs(500);
+      const network = store.getNetwork(500);
+      const ctx = store.getContext(20);
+      const terminal = store.getTerminalOutput(100);
+      const ci = store.getCIEvents(20);
+      const deploys = store.getDeployments(20);
+      const eventTypes = {};
+      if (logs.length) eventTypes["console"] = logs.length;
+      if (network.length) eventTypes["network"] = network.length;
+      if (ctx.length) eventTypes["context"] = ctx.length;
+      if (terminal.length) eventTypes["terminal"] = terminal.length;
+      if (ci.length) eventTypes["ci"] = ci.length;
+      if (deploys.length) eventTypes["deploy"] = deploys.length;
+      const totalEvents = Object.values(eventTypes).reduce((a, b) => a + b, 0);
+      const levelCounts = {};
+      for (const l of logs) {
+        const lv = l.level ?? "log";
+        levelCounts[lv] = (levelCounts[lv] ?? 0) + 1;
+      }
+      const urlPatterns = /* @__PURE__ */ new Set();
+      for (const n of network) {
+        try {
+          const u = new URL(n.url ?? "");
+          const parts = u.pathname.split("/").filter(Boolean);
+          urlPatterns.add("/" + (parts.slice(0, 2).join("/") || ""));
+        } catch {
+        }
+      }
+      const services = /* @__PURE__ */ new Set();
+      for (const c of ctx) {
+        if (c.service) services.add(c.service);
+      }
+      for (const l of logs) {
+        const m = String(l.args?.[0] ?? "").match(/^\[([a-z0-9_-]{2,24})\]/i);
+        if (m) services.add(m[1].toLowerCase());
+      }
+      const errorMsgs = logs.filter((l) => l.level === "error").map((l) => String(l.args?.[0] ?? ""));
+      const errorPatternMap = /* @__PURE__ */ new Map();
+      for (const msg of errorMsgs) {
+        const pat = msg.replace(/\d{3,}/g, "N").replace(/"[^"]{0,40}"/g, '"\u2026"').slice(0, 80);
+        if (!errorPatternMap.has(pat)) errorPatternMap.set(pat, msg);
+      }
+      const errorPatterns = [...errorPatternMap.keys()].slice(0, 10);
+      const allTs = [
+        ...logs.map((l) => l.timestamp),
+        ...network.map((n) => n.timestamp)
+      ].filter(Boolean);
+      const minTs = allTs.length ? Math.min(...allTs) : null;
+      const maxTs = allTs.length ? Math.max(...allTs) : null;
+      const statusBuckets = {};
+      for (const n of network) {
+        const s = n.status ?? 0;
+        const bucket = s >= 500 ? "5xx" : s >= 400 ? "4xx" : s >= 300 ? "3xx" : s >= 200 ? "2xx" : "other";
+        statusBuckets[bucket] = (statusBuckets[bucket] ?? 0) + 1;
+      }
+      const lines = [
+        "## Buffer Schema",
+        "",
+        `**Total events:** ${totalEvents}`,
+        "",
+        "### Event Types",
+        ...Object.entries(eventTypes).map(([k, v]) => `- \`${k}\`: ${v} events`),
+        "",
+        "### Log Levels",
+        Object.keys(levelCounts).length > 0 ? Object.entries(levelCounts).map(([k, v]) => `- \`${k}\`: ${v}`).join("\n") : "_No console events_",
+        "",
+        "### Network Status Distribution",
+        Object.keys(statusBuckets).length > 0 ? Object.entries(statusBuckets).map(([k, v]) => `- \`${k}\`: ${v}`).join("\n") : "_No network events_",
+        "",
+        "### URL Patterns (top path prefixes)",
+        [...urlPatterns].length > 0 ? [...urlPatterns].slice(0, 15).map((u) => `- \`${u}\``).join("\n") : "_No network events_",
+        "",
+        "### Detected Services",
+        [...services].length > 0 ? [...services].slice(0, 10).map((s) => `- \`${s}\``).join("\n") : "_No service identifiers detected_",
+        "",
+        "### Error Patterns",
+        errorPatterns.length > 0 ? errorPatterns.map((p, i) => {
+          const sample = include_samples ? `
+  _Sample: ${errorPatternMap.get(p)?.slice(0, 100)}_` : "";
+          return `${i + 1}. \`${p}\`${sample}`;
+        }).join("\n") : "_No errors in buffer_",
+        "",
+        "### Time Range",
+        minTs && maxTs ? `- Oldest: ${new Date(minTs).toISOString()}
+- Newest: ${new Date(maxTs).toISOString()}
+- Span: ${Math.round((maxTs - minTs) / 1e3)}s` : "_No timestamped events_",
+        "",
+        "---",
+        "_Call `analyze_runtime` to run full causal analysis, or `get_recent_logs` to read raw events._"
+      ];
+      return { content: [{ type: "text", text: lines.join("\n") }] };
+    }
+  );
+  server.registerTool(
+    "get_behavior_map",
+    {
+      description: "Returns the living runtime behavior map of the system based on actual call traces. Shows service nodes, communication edges, latency stats, error rates, and critical paths. Use this to understand service connections and trace dependencies.",
+      inputSchema: {}
+    },
+    async () => {
+      trackCall("get_behavior_map");
+      const snap = serviceTopology.snapshot();
+      if (snap.nodes.length === 0) {
+        return {
+          content: [{
+            type: "text",
+            text: "## Living Behavior Map\n\nNo telemetry data available yet to build the map. Run your application and trigger network calls to build the topology."
+          }]
+        };
+      }
+      const lines = [
+        "## \u{1F310} Living Behavior Map (Behavior Memory)",
+        "",
+        `*Auto-generated topology based on live traces as of ${snap.capturedAt}*`,
+        "",
+        "### \u{1F5A5}\uFE0F Services / Nodes",
+        "| Service Name | Type | Average Latency | p99 Latency | Call Count | Error Count |",
+        "|---|---|---|---|---|---|",
+        ...snap.nodes.map(
+          (n) => `| \`${n.name}\` | \`${n.type}\` | ${n.avgDurationMs}ms | ${n.p99DurationMs}ms | ${n.spanCount} | ${n.errorCount} |`
+        ),
+        "",
+        "### \u{1F50C} Connections / Edges",
+        "| Caller | Receiver | Call Count | Error Count | Average Latency |",
+        "|---|---|---|---|---|",
+        ...snap.edges.map(
+          (e) => `| \`${e.from}\` | \`${e.to}\` | ${e.callCount} | ${e.errorCount} | ${e.avgDurationMs}ms |`
+        ),
+        "",
+        "### \u{1F4CA} Summary",
+        `- **Total Services**: ${snap.summary.totalServices}`,
+        `- **Total Edges**: ${snap.summary.totalEdges}`
+      ];
+      if (snap.summary.errorHotspot) {
+        lines.push(`- \u26A0\uFE0F **Error Hotspot**: \`${snap.summary.errorHotspot}\` has the highest error rate.`);
+      }
+      if (snap.summary.slowestEdge) {
+        const { from, to, avgDurationMs } = snap.summary.slowestEdge;
+        lines.push(`- \u{1F422} **Slowest Connection**: \`${from}\` \u2192 \`${to}\` (Average: ${avgDurationMs}ms)`);
+      }
+      if (snap.summary.criticalPath && snap.summary.criticalPath.length > 0) {
+        lines.push(`- \u26D3\uFE0F **Critical Execution Path**: ${snap.summary.criticalPath.map((s) => `\`${s}\``).join(" \u2192 ")}`);
+      }
+      return {
+        content: [{
+          type: "text",
+          text: lines.join("\n")
+        }]
+      };
+    }
+  );
+}
+export {
+  registerDiscoveryTools
+};