@runtimescope/mcp-server 0.6.0

package/dist/index.js

@@ -0,0 +1,4690 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { execSync as execSync2 } from "child_process";
+import { existsSync as existsSync2 } from "fs";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import {
+  CollectorServer,
+  ProjectManager,
+  ApiDiscoveryEngine,
+  ProcessMonitor,
+  InfraConnector,
+  ConnectionManager,
+  SchemaIntrospector,
+  DataBrowser,
+  SessionManager,
+  HttpServer,
+  SqliteStore,
+  AuthManager,
+  Redactor,
+  resolveTlsConfig
+} from "@runtimescope/collector";
+
+// src/tools/network.ts
+import { z } from "zod";
+function registerNetworkTools(server, store) {
+  server.tool(
+    "get_network_requests",
+    "Get captured network (fetch) requests from the running web app. Returns URL, method, status, timing, and optional GraphQL operation info.",
+    {
+      since_seconds: z.number().optional().describe("Only return requests from the last N seconds"),
+      url_pattern: z.string().optional().describe("Filter by URL substring match"),
+      status: z.number().optional().describe("Filter by HTTP status code"),
+      method: z.string().optional().describe("Filter by HTTP method (GET, POST, etc.)")
+    },
+    async ({ since_seconds, url_pattern, status, method }) => {
+      const events = store.getNetworkRequests({
+        sinceSeconds: since_seconds,
+        urlPattern: url_pattern,
+        status,
+        method
+      });
+      const timeRange = events.length > 0 ? { from: events[events.length - 1].timestamp, to: events[0].timestamp } : { from: 0, to: 0 };
+      const sessions = store.getSessionInfo();
+      const sessionId = sessions[0]?.sessionId ?? null;
+      const failedCount = events.filter((e) => e.status >= 400).length;
+      const avgDuration = events.length > 0 ? (events.reduce((s, e) => s + e.duration, 0) / events.length).toFixed(0) : "0";
+      const issues = [];
+      if (failedCount > 0) issues.push(`${failedCount} failed request(s) (4xx/5xx)`);
+      const slowRequests = events.filter((e) => e.duration > 3e3);
+      if (slowRequests.length > 0) issues.push(`${slowRequests.length} slow request(s) (>3s)`);
+      const urlCounts = /* @__PURE__ */ new Map();
+      for (const e of events) {
+        const key = `${e.method} ${e.url}`;
+        const existing = urlCounts.get(key);
+        if (existing) {
+          existing.count++;
+          existing.last = Math.max(existing.last, e.timestamp);
+          existing.first = Math.min(existing.first, e.timestamp);
+        } else {
+          urlCounts.set(key, { count: 1, first: e.timestamp, last: e.timestamp });
+        }
+      }
+      for (const [key, info] of urlCounts) {
+        if (info.count > 5 && info.last - info.first < 2e3) {
+          issues.push(`Possible N+1: ${key} called ${info.count} times in ${((info.last - info.first) / 1e3).toFixed(1)}s`);
+        }
+      }
+      const response = {
+        summary: `Found ${events.length} network request(s)${since_seconds ? ` in the last ${since_seconds}s` : ""}. Average duration: ${avgDuration}ms.`,
+        data: events.map((e) => ({
+          url: e.url,
+          method: e.method,
+          status: e.status,
+          duration: `${e.duration.toFixed(0)}ms`,
+          ttfb: `${e.ttfb.toFixed(0)}ms`,
+          requestBodySize: e.requestBodySize,
+          responseBodySize: e.responseBodySize,
+          graphqlOperation: e.graphqlOperation ?? null,
+          timestamp: new Date(e.timestamp).toISOString()
+        })),
+        issues,
+        metadata: { timeRange, eventCount: events.length, sessionId }
+      };
+      return {
+        content: [{ type: "text", text: JSON.stringify(response, null, 2) }]
+      };
+    }
+  );
+}
+
+// src/tools/console.ts
+import { z as z2 } from "zod";
+function registerConsoleTools(server, store) {
+  server.tool(
+    "get_console_messages",
+    "Get captured console messages (log, warn, error, info, debug, trace) from the running web app. Includes message text, args, and stack traces for errors.",
+    {
+      level: z2.enum(["log", "warn", "error", "info", "debug", "trace"]).optional().describe("Filter by console level"),
+      since_seconds: z2.number().optional().describe("Only return messages from the last N seconds"),
+      search: z2.string().optional().describe("Search message text (case-insensitive substring match)")
+    },
+    async ({ level, since_seconds, search }) => {
+      const events = store.getConsoleMessages({
+        level,
+        sinceSeconds: since_seconds,
+        search
+      });
+      const timeRange = events.length > 0 ? { from: events[events.length - 1].timestamp, to: events[0].timestamp } : { from: 0, to: 0 };
+      const sessions = store.getSessionInfo();
+      const sessionId = sessions[0]?.sessionId ?? null;
+      const levelCounts = {};
+      for (const e of events) {
+        levelCounts[e.level] = (levelCounts[e.level] || 0) + 1;
+      }
+      const levelSummary = Object.entries(levelCounts).map(([l, c]) => `${c} ${l}`).join(", ");
+      const issues = [];
+      const errorMessages = /* @__PURE__ */ new Map();
+      for (const e of events) {
+        if (e.level === "error") {
+          const existing = errorMessages.get(e.message);
+          if (existing) {
+            existing.count++;
+            existing.last = Math.max(existing.last, e.timestamp);
+            existing.first = Math.min(existing.first, e.timestamp);
+          } else {
+            errorMessages.set(e.message, { count: 1, first: e.timestamp, last: e.timestamp });
+          }
+        }
+      }
+      for (const [msg, info] of errorMessages) {
+        if (info.count > 5 && info.last - info.first < 1e4) {
+          const truncated = msg.length > 80 ? msg.slice(0, 80) + "..." : msg;
+          issues.push(`Error spam: "${truncated}" repeated ${info.count} times in ${((info.last - info.first) / 1e3).toFixed(1)}s`);
+        }
+      }
+      const response = {
+        summary: `Found ${events.length} console message(s)${since_seconds ? ` in the last ${since_seconds}s` : ""}${levelSummary ? `. Breakdown: ${levelSummary}` : ""}.`,
+        data: events.map((e) => ({
+          level: e.level,
+          message: e.message,
+          args: e.args,
+          stackTrace: e.stackTrace ?? null,
+          sourceFile: e.sourceFile ?? null,
+          timestamp: new Date(e.timestamp).toISOString()
+        })),
+        issues,
+        metadata: { timeRange, eventCount: events.length, sessionId }
+      };
+      return {
+        content: [{ type: "text", text: JSON.stringify(response, null, 2) }]
+      };
+    }
+  );
+}
+
+// src/tools/session.ts
+function registerSessionTools(server, store) {
+  server.tool(
+    "get_session_info",
+    "Get information about connected browser sessions and overall event statistics. Use this to check if the SDK is connected.",
+    {},
+    async () => {
+      const sessions = store.getSessionInfo();
+      const response = {
+        summary: sessions.length > 0 ? `${sessions.length} session(s) connected. Total events captured: ${store.eventCount}.` : "No active sessions. Make sure the RuntimeScope SDK is injected in your app and connected to ws://localhost:9090.",
+        data: sessions.map((s) => ({
+          sessionId: s.sessionId,
+          appName: s.appName,
+          sdkVersion: s.sdkVersion,
+          connectedAt: new Date(s.connectedAt).toISOString(),
+          eventCount: s.eventCount,
+          isConnected: s.isConnected
+        })),
+        issues: sessions.length === 0 ? ["No SDK connections detected"] : [],
+        metadata: {
+          timeRange: { from: 0, to: Date.now() },
+          eventCount: store.eventCount,
+          sessionId: sessions[0]?.sessionId ?? null
+        }
+      };
+      return {
+        content: [{ type: "text", text: JSON.stringify(response, null, 2) }]
+      };
+    }
+  );
+  server.tool(
+    "clear_events",
+    "Clear all captured events from the buffer. Use this to start a fresh capture session.",
+    {},
+    async () => {
+      const { clearedCount } = store.clear();
+      const response = {
+        summary: `Cleared ${clearedCount} events. Buffer is now empty.`,
+        data: null,
+        issues: [],
+        metadata: {
+          timeRange: { from: 0, to: 0 },
+          eventCount: 0,
+          sessionId: null
+        }
+      };
+      return {
+        content: [{ type: "text", text: JSON.stringify(response, null, 2) }]
+      };
+    }
+  );
+}
+
+// src/tools/issues.ts
+import { z as z3 } from "zod";
+import { detectIssues } from "@runtimescope/collector";
+function registerIssueTools(server, store, apiDiscovery, processMonitor) {
+  server.tool(
+    "detect_issues",
+    "Run all pattern detectors against captured runtime data and return prioritized issues. Detects: failed requests, slow requests (>3s), N+1 request patterns, console error spam, high error rates, slow DB queries (>500ms), N+1 DB queries, API degradation, high latency endpoints, orphaned processes, and more. Use this as the first tool when investigating performance problems.",
+    {
+      since_seconds: z3.number().optional().describe("Analyze events from the last N seconds (default: all events)"),
+      severity_filter: z3.enum(["high", "medium", "low"]).optional().describe("Only return issues at this severity or above")
+    },
+    async ({ since_seconds, severity_filter }) => {
+      const events = store.getAllEvents(since_seconds);
+      const allIssues = [...detectIssues(events)];
+      if (apiDiscovery) {
+        try {
+          allIssues.push(...apiDiscovery.detectIssues(events));
+        } catch {
+        }
+      }
+      if (processMonitor) {
+        try {
+          allIssues.push(...processMonitor.detectIssues());
+        } catch {
+        }
+      }
+      const severityOrder = { high: 0, medium: 1, low: 2 };
+      allIssues.sort((a, b) => severityOrder[a.severity] - severityOrder[b.severity]);
+      const filterThreshold = severity_filter ? severityOrder[severity_filter] : 2;
+      const issues = allIssues.filter(
+        (i) => severityOrder[i.severity] <= filterThreshold
+      );
+      const sessions = store.getSessionInfo();
+      const sessionId = sessions[0]?.sessionId ?? null;
+      const highCount = issues.filter((i) => i.severity === "high").length;
+      const mediumCount = issues.filter((i) => i.severity === "medium").length;
+      const lowCount = issues.filter((i) => i.severity === "low").length;
+      const summaryParts = [];
+      if (issues.length === 0) {
+        summaryParts.push("No issues detected.");
+      } else {
+        summaryParts.push(`Found ${issues.length} issue(s):`);
+        if (highCount > 0) summaryParts.push(`${highCount} HIGH`);
+        if (mediumCount > 0) summaryParts.push(`${mediumCount} MEDIUM`);
+        if (lowCount > 0) summaryParts.push(`${lowCount} LOW`);
+      }
+      summaryParts.push(`Analyzed ${events.length} events${since_seconds ? ` from last ${since_seconds}s` : ""}.`);
+      const response = {
+        summary: summaryParts.join(" "),
+        data: issues.map((i) => ({
+          severity: i.severity.toUpperCase(),
+          pattern: i.pattern,
+          title: i.title,
+          description: i.description,
+          evidence: i.evidence,
+          suggestion: i.suggestion ?? null
+        })),
+        issues: issues.map((i) => `[${i.severity.toUpperCase()}] ${i.title}`),
+        metadata: {
+          timeRange: {
+            from: events.length > 0 ? events[0].timestamp : 0,
+            to: events.length > 0 ? events[events.length - 1].timestamp : 0
+          },
+          eventCount: events.length,
+          sessionId
+        }
+      };
+      return {
+        content: [{ type: "text", text: JSON.stringify(response, null, 2) }]
+      };
+    }
+  );
+}
+
+// src/tools/timeline.ts
+import { z as z4 } from "zod";
+function registerTimelineTools(server, store) {
+  server.tool(
+    "get_event_timeline",
+    "Get a chronological view of ALL events (network requests, console messages) interleaved by timestamp. Essential for understanding causal chains \u2014 e.g. seeing that an API call failed, then an error was logged, then another retry fired. Events are in chronological order (oldest first).",
+    {
+      since_seconds: z4.number().optional().describe("Only return events from the last N seconds (default: 60)"),
+      event_types: z4.array(z4.enum(["network", "console", "session", "state", "render", "performance", "dom_snapshot", "database"])).optional().describe("Filter by event types (default: all)"),
+      limit: z4.number().optional().describe("Max events to return (default: 200, max: 1000)")
+    },
+    async ({ since_seconds, event_types, limit }) => {
+      const sinceSeconds = since_seconds ?? 60;
+      const maxEvents = Math.min(limit ?? 200, 1e3);
+      const events = store.getEventTimeline({
+        sinceSeconds,
+        eventTypes: event_types
+      });
+      const trimmed = events.length > maxEvents ? events.slice(events.length - maxEvents) : events;
+      const sessions = store.getSessionInfo();
+      const sessionId = sessions[0]?.sessionId ?? null;
+      const typeCounts = {};
+      for (const e of trimmed) {
+        typeCounts[e.eventType] = (typeCounts[e.eventType] || 0) + 1;
+      }
+      const typeBreakdown = Object.entries(typeCounts).map(([t, c]) => `${c} ${t}`).join(", ");
+      const response = {
+        summary: `Timeline: ${trimmed.length} event(s) in the last ${sinceSeconds}s${events.length > maxEvents ? ` (showing last ${maxEvents} of ${events.length})` : ""}. Breakdown: ${typeBreakdown || "none"}.`,
+        data: trimmed.map((e) => formatTimelineEvent(e)),
+        issues: [],
+        metadata: {
+          timeRange: {
+            from: trimmed.length > 0 ? trimmed[0].timestamp : 0,
+            to: trimmed.length > 0 ? trimmed[trimmed.length - 1].timestamp : 0
+          },
+          eventCount: trimmed.length,
+          totalInWindow: events.length,
+          sessionId
+        }
+      };
+      return {
+        content: [{ type: "text", text: JSON.stringify(response, null, 2) }]
+      };
+    }
+  );
+}
+function formatTimelineEvent(event) {
+  const base = {
+    type: event.eventType,
+    timestamp: new Date(event.timestamp).toISOString(),
+    relativeMs: 0
+    // will be set by caller if needed
+  };
+  switch (event.eventType) {
+    case "network": {
+      const ne = event;
+      return {
+        ...base,
+        method: ne.method,
+        url: ne.url,
+        status: ne.status,
+        duration: `${ne.duration.toFixed(0)}ms`,
+        graphql: ne.graphqlOperation ? `${ne.graphqlOperation.type} ${ne.graphqlOperation.name}` : null
+      };
+    }
+    case "console": {
+      const ce = event;
+      return {
+        ...base,
+        level: ce.level,
+        message: ce.message.length > 200 ? ce.message.slice(0, 200) + "..." : ce.message,
+        hasStack: !!ce.stackTrace
+      };
+    }
+    case "session":
+      return {
+        ...base,
+        note: "SDK session connected"
+      };
+    case "state": {
+      const se = event;
+      return {
+        ...base,
+        storeId: se.storeId,
+        library: se.library,
+        phase: se.phase,
+        action: se.action?.type ?? null,
+        changedKeys: se.diff ? Object.keys(se.diff).join(", ") : null
+      };
+    }
+    case "render": {
+      const re = event;
+      return {
+        ...base,
+        totalRenders: re.totalRenders,
+        componentCount: re.profiles.length,
+        suspicious: re.suspiciousComponents.length > 0 ? re.suspiciousComponents.join(", ") : null
+      };
+    }
+    case "performance": {
+      const pe = event;
+      return {
+        ...base,
+        metric: pe.metricName,
+        value: pe.value,
+        rating: pe.rating,
+        element: pe.element ?? null
+      };
+    }
+    case "dom_snapshot": {
+      const ds = event;
+      return {
+        ...base,
+        url: ds.url,
+        elementCount: ds.elementCount,
+        htmlSize: `${Math.round(ds.html.length / 1024)}KB`,
+        truncated: ds.truncated
+      };
+    }
+    case "database": {
+      const de = event;
+      return {
+        ...base,
+        operation: de.operation,
+        query: de.query.length > 150 ? de.query.slice(0, 150) + "..." : de.query,
+        duration: `${de.duration.toFixed(0)}ms`,
+        tables: de.tablesAccessed,
+        source: de.source,
+        error: de.error ?? null
+      };
+    }
+    default:
+      return base;
+  }
+}
+
+// src/tools/state.ts
+import { z as z5 } from "zod";
+function registerStateTools(server, store) {
+  server.tool(
+    "get_state_snapshots",
+    "Get state store snapshots and diffs from Zustand or Redux stores. Shows state changes over time with action history, mutation frequency, and shallow diffs showing which keys changed.",
+    {
+      store_name: z5.string().optional().describe("Filter by store name/ID"),
+      since_seconds: z5.number().optional().describe("Only return events from the last N seconds")
+    },
+    async ({ store_name, since_seconds }) => {
+      const events = store.getStateEvents({
+        storeId: store_name,
+        sinceSeconds: since_seconds
+      });
+      const sessions = store.getSessionInfo();
+      const sessionId = sessions[0]?.sessionId ?? null;
+      const issues = [];
+      const storeUpdates = /* @__PURE__ */ new Map();
+      for (const e of events) {
+        if (e.phase !== "update") continue;
+        const timestamps = storeUpdates.get(e.storeId) ?? [];
+        timestamps.push(e.timestamp);
+        storeUpdates.set(e.storeId, timestamps);
+      }
+      for (const [storeId, timestamps] of storeUpdates) {
+        if (timestamps.length < 10) continue;
+        for (let i = 0; i <= timestamps.length - 10; i++) {
+          if (timestamps[i + 9] - timestamps[i] < 1e3) {
+            issues.push(`Store thrashing: "${storeId}" had ${timestamps.length} updates, 10+ in a 1-second window`);
+            break;
+          }
+        }
+      }
+      const response = {
+        summary: `Found ${events.length} state event(s)${since_seconds ? ` in the last ${since_seconds}s` : ""}${store_name ? ` for store "${store_name}"` : ""}.`,
+        data: events.map((e) => ({
+          storeId: e.storeId,
+          library: e.library,
+          phase: e.phase,
+          state: e.state,
+          previousState: e.previousState ?? null,
+          diff: e.diff ?? null,
+          action: e.action ?? null,
+          timestamp: new Date(e.timestamp).toISOString()
+        })),
+        issues,
+        metadata: {
+          timeRange: {
+            from: events.length > 0 ? events[0].timestamp : 0,
+            to: events.length > 0 ? events[events.length - 1].timestamp : 0
+          },
+          eventCount: events.length,
+          sessionId
+        }
+      };
+      return {
+        content: [{ type: "text", text: JSON.stringify(response, null, 2) }]
+      };
+    }
+  );
+}
+
+// src/tools/renders.ts
+import { z as z6 } from "zod";
+function registerRenderTools(server, store) {
+  server.tool(
+    "get_render_profile",
+    "Get React component render profiles showing render counts, velocity, average duration, and render causes. Flags suspicious components that are re-rendering excessively. Requires captureRenders: true in the SDK config and React dev mode for accurate timing data.",
+    {
+      component_name: z6.string().optional().describe("Filter by component name (substring match)"),
+      since_seconds: z6.number().optional().describe("Only return events from the last N seconds")
+    },
+    async ({ component_name, since_seconds }) => {
+      const events = store.getRenderEvents({
+        componentName: component_name,
+        sinceSeconds: since_seconds
+      });
+      const sessions = store.getSessionInfo();
+      const sessionId = sessions[0]?.sessionId ?? null;
+      const issues = [];
+      const merged = /* @__PURE__ */ new Map();
+      const allSuspicious = /* @__PURE__ */ new Set();
+      for (const event of events) {
+        for (const profile of event.profiles) {
+          const existing = merged.get(profile.componentName);
+          if (existing) {
+            existing.renderCount += profile.renderCount;
+            existing.totalDuration += profile.totalDuration;
+            existing.avgDuration = existing.renderCount > 0 ? existing.totalDuration / existing.renderCount : 0;
+            existing.renderVelocity = Math.max(existing.renderVelocity, profile.renderVelocity);
+            existing.lastRenderPhase = profile.lastRenderPhase;
+            existing.lastRenderCause = profile.lastRenderCause;
+            if (profile.suspicious) existing.suspicious = true;
+          } else {
+            merged.set(profile.componentName, { ...profile });
+          }
+          if (profile.suspicious) {
+            allSuspicious.add(profile.componentName);
+          }
+        }
+      }
+      if (allSuspicious.size > 0) {
+        issues.push(`${allSuspicious.size} suspicious component(s): ${Array.from(allSuspicious).join(", ")}`);
+      }
+      const profiles = Array.from(merged.values()).sort(
+        (a, b) => b.renderCount - a.renderCount
+      );
+      const totalRenders = profiles.reduce((s, p) => s + p.renderCount, 0);
+      const response = {
+        summary: `${profiles.length} component(s) tracked, ${totalRenders} total renders${since_seconds ? ` in the last ${since_seconds}s` : ""}. ${allSuspicious.size} suspicious.`,
+        data: profiles.map((p) => ({
+          componentName: p.componentName,
+          renderCount: p.renderCount,
+          totalDuration: `${p.totalDuration.toFixed(1)}ms`,
+          avgDuration: `${p.avgDuration.toFixed(1)}ms`,
+          renderVelocity: `${p.renderVelocity.toFixed(1)}/sec`,
+          lastRenderPhase: p.lastRenderPhase,
+          lastRenderCause: p.lastRenderCause,
+          suspicious: p.suspicious
+        })),
+        issues,
+        metadata: {
+          timeRange: {
+            from: events.length > 0 ? events[0].timestamp : 0,
+            to: events.length > 0 ? events[events.length - 1].timestamp : 0
+          },
+          eventCount: events.length,
+          sessionId
+        }
+      };
+      return {
+        content: [{ type: "text", text: JSON.stringify(response, null, 2) }]
+      };
+    }
+  );
+}
+
+// src/tools/performance.ts
+import { z as z7 } from "zod";
+var WEB_VITAL_METRICS = ["LCP", "FCP", "CLS", "TTFB", "FID", "INP"];
+var SERVER_METRICS = [
+  "memory.rss",
+  "memory.heapUsed",
+  "memory.heapTotal",
+  "memory.external",
+  "eventloop.lag.mean",
+  "eventloop.lag.p99",
+  "eventloop.lag.max",
+  "gc.pause.major",
+  "gc.pause.minor",
+  "cpu.user",
+  "cpu.system",
+  "handles.active",
+  "requests.active"
+];
+var ALL_METRICS = [...WEB_VITAL_METRICS, ...SERVER_METRICS];
+function isWebVital(name) {
+  return WEB_VITAL_METRICS.includes(name);
+}
+function registerPerformanceTools(server, store) {
+  server.tool(
+    "get_performance_metrics",
+    "Get performance metrics from browser (Web Vitals: LCP, FCP, CLS, TTFB, FID, INP) and/or server (memory, event loop lag, GC pauses, CPU usage). Browser metrics include quality ratings. Server metrics require capturePerformance: true in the server-SDK config.",
+    {
+      metric_name: z7.enum(ALL_METRICS).optional().describe("Filter by specific metric name"),
+      source: z7.enum(["browser", "server", "all"]).optional().default("all").describe("Filter by metric source: browser (Web Vitals), server (Node.js runtime), or all"),
+      since_seconds: z7.number().optional().describe("Only return metrics from the last N seconds")
+    },
+    async ({ metric_name, source, since_seconds }) => {
+      let events = store.getPerformanceMetrics({
+        metricName: metric_name,
+        sinceSeconds: since_seconds
+      });
+      if (source === "browser") {
+        events = events.filter((e) => isWebVital(e.metricName));
+      } else if (source === "server") {
+        events = events.filter((e) => !isWebVital(e.metricName));
+      }
+      const sessions = store.getSessionInfo();
+      const sessionId = sessions[0]?.sessionId ?? null;
+      const issues = [];
+      const poor = events.filter((e) => e.rating === "poor");
+      const needsImprovement = events.filter((e) => e.rating === "needs-improvement");
+      if (poor.length > 0) {
+        issues.push(`${poor.length} metric(s) rated "poor": ${poor.map((e) => e.metricName).join(", ")}`);
+      }
+      if (needsImprovement.length > 0) {
+        issues.push(`${needsImprovement.length} metric(s) need improvement: ${needsImprovement.map((e) => e.metricName).join(", ")}`);
+      }
+      const highMemory = events.filter((e) => e.metricName === "memory.heapUsed" && e.value > 500 * 1024 * 1024);
+      if (highMemory.length > 0) {
+        issues.push(`Heap usage exceeded 500MB in ${highMemory.length} sample(s)`);
+      }
+      const highEventLoop = events.filter((e) => e.metricName === "eventloop.lag.p99" && e.value > 100);
+      if (highEventLoop.length > 0) {
+        issues.push(`Event loop p99 lag exceeded 100ms in ${highEventLoop.length} sample(s)`);
+      }
+      const latest = /* @__PURE__ */ new Map();
+      for (const e of events) {
+        latest.set(e.metricName, e);
+      }
+      const browserMetrics = Array.from(latest.values()).filter((e) => isWebVital(e.metricName));
+      const serverMetrics = Array.from(latest.values()).filter((e) => !isWebVital(e.metricName));
+      const formatMetric = (e) => ({
+        metricName: e.metricName,
+        value: e.value,
+        unit: e.unit ?? (e.metricName === "CLS" ? "score" : "ms"),
+        rating: e.rating ?? null,
+        element: e.element ?? null,
+        timestamp: new Date(e.timestamp).toISOString()
+      });
+      const response = {
+        summary: `${latest.size} unique metric(s) captured (${browserMetrics.length} browser, ${serverMetrics.length} server). ${poor.length} poor, ${needsImprovement.length} needs improvement.`,
+        data: {
+          browser: browserMetrics.map(formatMetric),
+          server: serverMetrics.map(formatMetric)
+        },
+        allEvents: events.map((e) => ({
+          metricName: e.metricName,
+          value: e.value,
+          unit: e.unit ?? (e.metricName === "CLS" ? "score" : "ms"),
+          rating: e.rating ?? null,
+          timestamp: new Date(e.timestamp).toISOString()
+        })),
+        issues,
+        metadata: {
+          timeRange: {
+            from: events.length > 0 ? events[0].timestamp : 0,
+            to: events.length > 0 ? events[events.length - 1].timestamp : 0
+          },
+          eventCount: events.length,
+          sessionId
+        }
+      };
+      return {
+        content: [{ type: "text", text: JSON.stringify(response, null, 2) }]
+      };
+    }
+  );
+}
+
+// src/tools/dom-snapshot.ts
+import { z as z8 } from "zod";
+function generateRequestId() {
+  return Math.random().toString(36).slice(2, 10) + Date.now().toString(36);
+}
+function registerDomSnapshotTools(server, store, collector) {
+  server.tool(
+    "get_dom_snapshot",
+    "Capture a live DOM snapshot from the running web app. Sends a command to the SDK which serializes document.documentElement.outerHTML and returns it along with the current URL, viewport dimensions, scroll position, and element count. Useful for understanding what the user sees.",
+    {
+      max_size: z8.number().optional().describe("Maximum HTML size in bytes (default: 500000). Larger pages will be truncated.")
+    },
+    async ({ max_size }) => {
+      const sessions = store.getSessionInfo();
+      const sessionId = collector.getFirstSessionId();
+      const activeSession = sessions[0] ?? null;
+      if (!sessionId || !activeSession?.isConnected) {
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({
+              summary: "No active SDK session connected. Ensure the SDK is running in the browser.",
+              data: null,
+              issues: ["No active session"],
+              metadata: { timeRange: { from: 0, to: 0 }, eventCount: 0, sessionId: null }
+            }, null, 2)
+          }]
+        };
+      }
+      try {
+        const requestId = generateRequestId();
+        const result = await collector.sendCommand(sessionId, {
+          command: "capture_dom_snapshot",
+          requestId,
+          params: { maxSize: max_size ?? 5e5 }
+        }, 1e4);
+        const response = {
+          summary: `DOM snapshot captured from ${result.url}. ${result.elementCount} elements, ${Math.round(result.html.length / 1024)}KB HTML${result.truncated ? " (truncated)" : ""}.`,
+          data: {
+            html: result.html,
+            url: result.url,
+            viewport: result.viewport,
+            scrollPosition: result.scrollPosition,
+            elementCount: result.elementCount,
+            truncated: result.truncated
+          },
+          issues: result.truncated ? ["HTML was truncated due to size limit"] : [],
+          metadata: {
+            timeRange: { from: Date.now(), to: Date.now() },
+            eventCount: 1,
+            sessionId
+          }
+        };
+        return {
+          content: [{ type: "text", text: JSON.stringify(response, null, 2) }]
+        };
+      } catch (err) {
+        const errorMsg = err instanceof Error ? err.message : String(err);
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({
+              summary: `Failed to capture DOM snapshot: ${errorMsg}`,
+              data: null,
+              issues: [errorMsg],
+              metadata: { timeRange: { from: 0, to: 0 }, eventCount: 0, sessionId }
+            }, null, 2)
+          }]
+        };
+      }
+    }
+  );
+}
+
+// src/tools/har.ts
+import { z as z9 } from "zod";
+function registerHarTools(server, store) {
+  server.tool(
+    "capture_har",
+    "Export captured network requests as a HAR (HTTP Archive) 1.2 JSON file. This is the standard format used by browser DevTools, Charles Proxy, and other tools. Includes request/response headers, body content (if captureBody was enabled in the SDK), and timing data.",
+    {
+      since_seconds: z9.number().optional().describe("Only include requests from the last N seconds")
+    },
+    async ({ since_seconds }) => {
+      const events = store.getNetworkRequests({
+        sinceSeconds: since_seconds
+      });
+      const sessions = store.getSessionInfo();
+      const sessionId = sessions[0]?.sessionId ?? null;
+      const har = buildHar(events);
+      const response = {
+        summary: `HAR export: ${events.length} request(s)${since_seconds ? ` from the last ${since_seconds}s` : ""}. Import into Chrome DevTools or any HAR viewer.`,
+        data: har,
+        issues: [],
+        metadata: {
+          timeRange: {
+            from: events.length > 0 ? events[0].timestamp : 0,
+            to: events.length > 0 ? events[events.length - 1].timestamp : 0
+          },
+          eventCount: events.length,
+          sessionId
+        }
+      };
+      return {
+        content: [{ type: "text", text: JSON.stringify(response, null, 2) }]
+      };
+    }
+  );
+}
+function buildHar(events) {
+  const entries = events.map((e) => {
+    const queryString = parseQueryString(e.url);
+    const requestHeaders = Object.entries(e.requestHeaders).map(([name, value]) => ({
+      name,
+      value
+    }));
+    const responseHeaders = Object.entries(e.responseHeaders).map(([name, value]) => ({
+      name,
+      value
+    }));
+    const contentType = e.responseHeaders["content-type"] ?? "application/octet-stream";
+    const entry = {
+      startedDateTime: new Date(e.timestamp).toISOString(),
+      time: Math.round(e.duration),
+      request: {
+        method: e.method,
+        url: e.url,
+        httpVersion: "HTTP/1.1",
+        headers: requestHeaders,
+        queryString,
+        headersSize: -1,
+        bodySize: e.requestBodySize
+      },
+      response: {
+        status: e.status,
+        statusText: statusText(e.status),
+        httpVersion: "HTTP/1.1",
+        headers: responseHeaders,
+        content: {
+          size: e.responseBodySize,
+          mimeType: contentType,
+          ...e.responseBody ? { text: e.responseBody } : {}
+        },
+        headersSize: -1,
+        bodySize: e.responseBodySize
+      },
+      timings: {
+        send: 0,
+        wait: Math.round(e.ttfb),
+        receive: Math.max(0, Math.round(e.duration - e.ttfb))
+      }
+    };
+    if (e.requestBody) {
+      const reqContentType = e.requestHeaders["content-type"] ?? "application/octet-stream";
+      entry.request.postData = {
+        mimeType: reqContentType,
+        text: e.requestBody
+      };
+    }
+    return entry;
+  });
+  return {
+    log: {
+      version: "1.2",
+      creator: {
+        name: "RuntimeScope",
+        version: "0.2.0"
+      },
+      entries
+    }
+  };
+}
+function parseQueryString(url) {
+  try {
+    const parsed = new URL(url);
+    return Array.from(parsed.searchParams.entries()).map(([name, value]) => ({
+      name,
+      value
+    }));
+  } catch {
+    return [];
+  }
+}
+function statusText(status) {
+  const texts = {
+    200: "OK",
+    201: "Created",
+    204: "No Content",
+    301: "Moved Permanently",
+    302: "Found",
+    304: "Not Modified",
+    400: "Bad Request",
+    401: "Unauthorized",
+    403: "Forbidden",
+    404: "Not Found",
+    405: "Method Not Allowed",
+    409: "Conflict",
+    422: "Unprocessable Entity",
+    429: "Too Many Requests",
+    500: "Internal Server Error",
+    502: "Bad Gateway",
+    503: "Service Unavailable",
+    504: "Gateway Timeout"
+  };
+  return texts[status] ?? "";
+}
+
+// src/tools/errors.ts
+import { z as z10 } from "zod";
+function registerErrorTools(server, store) {
+  server.tool(
+    "get_errors_with_source_context",
+    "Get console errors with parsed stack traces and surrounding source code lines. Fetches the actual source files from the dev server (e.g. http://localhost:3000/src/...) and shows the lines around the error. This gives you the same context as clicking a stack frame in DevTools.",
+    {
+      since_seconds: z10.number().optional().describe("Only return errors from the last N seconds"),
+      fetch_source: z10.boolean().optional().describe("Whether to fetch source files for context (default: true). Set false for faster results."),
+      context_lines: z10.number().optional().describe("Number of source lines to show above and below the error line (default: 5)")
+    },
+    async ({ since_seconds, fetch_source, context_lines }) => {
+      const shouldFetch = fetch_source !== false;
+      const contextSize = context_lines ?? 5;
+      const events = store.getConsoleMessages({
+        level: "error",
+        sinceSeconds: since_seconds
+      });
+      const sessions = store.getSessionInfo();
+      const sessionId = sessions[0]?.sessionId ?? null;
+      const limited = events.slice(0, 50);
+      const sourceCache = /* @__PURE__ */ new Map();
+      const errors = [];
+      for (const event of limited) {
+        const frames = event.stackTrace ? parseStackTrace(event.stackTrace) : [];
+        if (shouldFetch) {
+          for (const frame of frames) {
+            if (frame.file.includes("node_modules")) continue;
+            if (!frame.file.startsWith("http")) continue;
+            if (!sourceCache.has(frame.file)) {
+              sourceCache.set(frame.file, await fetchSource(frame.file));
+            }
+            const source = sourceCache.get(frame.file);
+            if (source) {
+              frame.sourceContext = extractContext(source, frame.line, contextSize);
+            }
+          }
+        }
+        errors.push({
+          message: event.message,
+          timestamp: new Date(event.timestamp).toISOString(),
+          frames
+        });
+      }
+      const issues = [];
+      if (events.length > 50) {
+        issues.push(`Showing 50 of ${events.length} errors`);
+      }
+      const uniqueMessages = new Set(limited.map((e) => e.message.slice(0, 100)));
+      const response = {
+        summary: `${limited.length} error(s)${since_seconds ? ` in the last ${since_seconds}s` : ""}, ${uniqueMessages.size} unique. ${shouldFetch ? "Source context included." : "Source context disabled."}`,
+        data: errors,
+        issues,
+        metadata: {
+          timeRange: {
+            from: limited.length > 0 ? limited[0].timestamp : 0,
+            to: limited.length > 0 ? limited[limited.length - 1].timestamp : 0
+          },
+          eventCount: limited.length,
+          sessionId
+        }
+      };
+      return {
+        content: [{ type: "text", text: JSON.stringify(response, null, 2) }]
+      };
+    }
+  );
+}
+function parseStackTrace(stack) {
+  const frames = [];
+  for (const line of stack.split("\n")) {
+    const trimmed = line.trim();
+    const chromeMatch = trimmed.match(
+      /^at\s+(?:(.+?)\s+\()?(https?:\/\/[^)]+):(\d+):(\d+)\)?$/
+    );
+    if (chromeMatch) {
+      frames.push({
+        functionName: chromeMatch[1] ?? "<anonymous>",
+        file: chromeMatch[2],
+        line: parseInt(chromeMatch[3], 10),
+        column: parseInt(chromeMatch[4], 10)
+      });
+      continue;
+    }
+    const firefoxMatch = trimmed.match(
+      /^(.+?)@(https?:\/\/.+):(\d+):(\d+)$/
+    );
+    if (firefoxMatch) {
+      frames.push({
+        functionName: firefoxMatch[1] ?? "<anonymous>",
+        file: firefoxMatch[2],
+        line: parseInt(firefoxMatch[3], 10),
+        column: parseInt(firefoxMatch[4], 10)
+      });
+    }
+  }
+  return frames;
+}
+async function fetchSource(url) {
+  try {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 2e3);
+    const response = await fetch(url, { signal: controller.signal });
+    clearTimeout(timeout);
+    if (!response.ok) return null;
+    return await response.text();
+  } catch {
+    return null;
+  }
+}
+function extractContext(source, targetLine, contextSize) {
+  const lines = source.split("\n");
+  const start = Math.max(0, targetLine - contextSize - 1);
+  const end = Math.min(lines.length, targetLine + contextSize);
+  return lines.slice(start, end).map((line, i) => {
+    const lineNum = start + i + 1;
+    const marker = lineNum === targetLine ? ">>>" : "   ";
+    return `${marker} ${lineNum.toString().padStart(4)} | ${line}`;
+  });
+}
+
+// src/tools/api-discovery.ts
+import { z as z11 } from "zod";
+function registerApiDiscoveryTools(server, store, engine) {
+  server.tool(
+    "get_api_catalog",
+    "Discover all API endpoints the app is communicating with, auto-grouped by service. Shows normalized paths, call counts, auth patterns, and inferred response shapes.",
+    {
+      service: z11.string().optional().describe('Filter by service name (e.g. "Supabase", "Your API")'),
+      min_calls: z11.number().optional().describe("Only show endpoints with at least N calls")
+    },
+    async ({ service, min_calls }) => {
+      const catalog = engine.getCatalog({ service, minCalls: min_calls });
+      const services = engine.getServiceMap();
+      const sessions = store.getSessionInfo();
+      const sessionId = sessions[0]?.sessionId ?? null;
+      const response = {
+        summary: `Discovered ${catalog.length} API endpoint(s) across ${services.length} service(s).`,
+        data: {
+          services: services.map((s) => ({
+            name: s.name,
+            baseUrl: s.baseUrl,
+            endpointCount: s.endpointCount,
+            totalCalls: s.totalCalls,
+            avgLatency: `${s.avgLatency.toFixed(0)}ms`,
+            errorRate: `${(s.errorRate * 100).toFixed(1)}%`,
+            auth: s.auth.type,
+            platform: s.detectedPlatform ?? null
+          })),
+          endpoints: catalog.map((ep) => ({
+            method: ep.method,
+            path: ep.normalizedPath,
+            service: ep.service,
+            callCount: ep.callCount,
+            auth: ep.auth.type,
+            firstSeen: new Date(ep.firstSeen).toISOString(),
+            lastSeen: new Date(ep.lastSeen).toISOString(),
+            graphql: ep.graphqlOperation ?? null,
+            responseFields: ep.contract?.responseFields.length ?? 0
+          }))
+        },
+        issues: [],
+        metadata: {
+          timeRange: catalog.length > 0 ? { from: Math.min(...catalog.map((e) => e.firstSeen)), to: Math.max(...catalog.map((e) => e.lastSeen)) } : { from: 0, to: 0 },
+          eventCount: catalog.reduce((s, e) => s + e.callCount, 0),
+          sessionId
+        }
+      };
+      return {
+        content: [{ type: "text", text: JSON.stringify(response, null, 2) }]
+      };
+    }
+  );
+  server.tool(
+    "get_api_health",
+    "Get health metrics for discovered API endpoints: success rate, latency percentiles (p50/p95), error rates and error codes.",
+    {
+      endpoint: z11.string().optional().describe("Filter by endpoint path substring"),
+      since_seconds: z11.number().optional().describe("Only consider requests from the last N seconds")
+    },
+    async ({ endpoint, since_seconds }) => {
+      const health = engine.getHealth({ endpoint, sinceSeconds: since_seconds });
+      const sessions = store.getSessionInfo();
+      const sessionId = sessions[0]?.sessionId ?? null;
+      const issues = [];
+      for (const ep of health) {
+        if (ep.errorRate > 0.5) issues.push(`${ep.method} ${ep.normalizedPath}: ${(ep.errorRate * 100).toFixed(0)}% error rate`);
+        if (ep.p95Latency > 5e3) issues.push(`${ep.method} ${ep.normalizedPath}: p95 latency ${(ep.p95Latency / 1e3).toFixed(1)}s`);
+      }
+      const response = {
+        summary: `Health report for ${health.length} endpoint(s).${issues.length > 0 ? ` ${issues.length} issue(s) found.` : ""}`,
+        data: health.map((ep) => ({
+          method: ep.method,
+          path: ep.normalizedPath,
+          service: ep.service,
+          callCount: ep.callCount,
+          successRate: `${(ep.successRate * 100).toFixed(1)}%`,
+          avgLatency: `${ep.avgLatency.toFixed(0)}ms`,
+          p50Latency: `${ep.p50Latency.toFixed(0)}ms`,
+          p95Latency: `${ep.p95Latency.toFixed(0)}ms`,
+          errorRate: `${(ep.errorRate * 100).toFixed(1)}%`,
+          errorCodes: ep.errorCodes
+        })),
+        issues,
+        metadata: {
+          timeRange: { from: 0, to: Date.now() },
+          eventCount: health.reduce((s, e) => s + e.callCount, 0),
+          sessionId
+        }
+      };
+      return {
+        content: [{ type: "text", text: JSON.stringify(response, null, 2) }]
+      };
+    }
+  );
+  server.tool(
+    "get_api_documentation",
+    "Generate API documentation from observed network traffic. Shows endpoints, auth, latency, and inferred response shapes in markdown format.",
+    {
+      service: z11.string().optional().describe("Generate docs for a specific service only")
+    },
+    async ({ service }) => {
+      const docs = engine.getDocumentation({ service });
+      return {
+        content: [{ type: "text", text: docs }]
+      };
+    }
+  );
+  server.tool(
+    "get_service_map",
+    "Get a topology map of all external services the app communicates with, including detected platforms (Supabase, Vercel, Stripe, etc.), call counts, and latency.",
+    {},
+    async () => {
+      const services = engine.getServiceMap();
+      const sessions = store.getSessionInfo();
+      const sessionId = sessions[0]?.sessionId ?? null;
+      const response = {
+        summary: `${services.length} service(s) detected from network traffic.`,
+        data: services.map((s) => ({
+          name: s.name,
+          baseUrl: s.baseUrl,
+          endpointCount: s.endpointCount,
+          totalCalls: s.totalCalls,
+          avgLatency: `${s.avgLatency.toFixed(0)}ms`,
+          errorRate: `${(s.errorRate * 100).toFixed(1)}%`,
+          auth: s.auth,
+          detectedPlatform: s.detectedPlatform ?? null
+        })),
+        issues: [],
+        metadata: {
+          timeRange: { from: 0, to: Date.now() },
+          eventCount: services.reduce((s, e) => s + e.totalCalls, 0),
+          sessionId
+        }
+      };
+      return {
+        content: [{ type: "text", text: JSON.stringify(response, null, 2) }]
+      };
+    }
+  );
+  server.tool(
+    "get_api_changes",
+    "Compare API endpoints between two sessions. Detects added/removed endpoints and response shape changes.",
+    {
+      session_a: z11.string().describe("First session ID"),
+      session_b: z11.string().describe("Second session ID")
+    },
+    async ({ session_a, session_b }) => {
+      const changes = engine.getApiChanges(session_a, session_b);
+      const sessions = store.getSessionInfo();
+      const sessionId = sessions[0]?.sessionId ?? null;
+      const added = changes.filter((c) => c.changeType === "added").length;
+      const removed = changes.filter((c) => c.changeType === "removed").length;
+      const modified = changes.filter((c) => c.changeType === "modified").length;
+      const response = {
+        summary: `${changes.length} API change(s) between sessions: ${added} added, ${removed} removed, ${modified} modified.`,
+        data: changes,
+        issues: removed > 0 ? [`${removed} endpoint(s) no longer called \u2014 may indicate removed features or routing changes`] : [],
+        metadata: {
+          timeRange: { from: 0, to: Date.now() },
+          eventCount: changes.length,
+          sessionId
+        }
+      };
+      return {
+        content: [{ type: "text", text: JSON.stringify(response, null, 2) }]
+      };
+    }
+  );
+}
+
+// src/tools/database.ts
+import { z as z12 } from "zod";
+import {
+  aggregateQueryStats,
+  detectN1Queries,
+  detectSlowQueries,
+  suggestIndexes
+} from "@runtimescope/collector";
+function registerDatabaseTools(server, store, connectionManager, schemaIntrospector, dataBrowser) {
+  server.tool(
+    "get_query_log",
+    "Get captured database queries with SQL, timing, rows returned, and source ORM. Requires server-side SDK instrumentation.",
+    {
+      since_seconds: z12.number().optional().describe("Only return queries from the last N seconds"),
+      table: z12.string().optional().describe("Filter by table name"),
+      min_duration_ms: z12.number().optional().describe("Only return queries slower than N ms"),
+      search: z12.string().optional().describe("Search query text")
+    },
+    async ({ since_seconds, table, min_duration_ms, search }) => {
+      const events = store.getDatabaseEvents({
+        sinceSeconds: since_seconds,
+        table,
+        minDurationMs: min_duration_ms,
+        search
+      });
+      const sessions = store.getSessionInfo();
+      const sessionId = sessions[0]?.sessionId ?? null;
+      const totalDuration = events.reduce((s, e) => s + e.duration, 0);
+      const avgDuration = events.length > 0 ? totalDuration / events.length : 0;
+      const errorCount = events.filter((e) => e.error).length;
+      const issues = [];
+      if (errorCount > 0) issues.push(`${errorCount} query error(s)`);
+      const slowCount = events.filter((e) => e.duration > 500).length;
+      if (slowCount > 0) issues.push(`${slowCount} slow query/queries (>500ms)`);
+      const response = {
+        summary: `Found ${events.length} database query/queries${since_seconds ? ` in the last ${since_seconds}s` : ""}. Avg duration: ${avgDuration.toFixed(0)}ms.`,
+        data: events.map((e) => ({
+          query: e.query.slice(0, 200),
+          normalizedQuery: e.normalizedQuery.slice(0, 150),
+          duration: `${e.duration.toFixed(0)}ms`,
+          operation: e.operation,
+          tables: e.tablesAccessed,
+          source: e.source,
+          rowsReturned: e.rowsReturned ?? null,
+          rowsAffected: e.rowsAffected ?? null,
+          error: e.error ?? null,
+          label: e.label ?? null,
+          timestamp: new Date(e.timestamp).toISOString()
+        })),
+        issues,
+        metadata: {
+          timeRange: events.length > 0 ? { from: events[0].timestamp, to: events[events.length - 1].timestamp } : { from: 0, to: 0 },
+          eventCount: events.length,
+          sessionId
+        }
+      };
+      return {
+        content: [{ type: "text", text: JSON.stringify(response, null, 2) }]
+      };
+    }
+  );
+  server.tool(
+    "get_query_performance",
+    "Get aggregated database query performance stats: avg/max/p95 duration, call counts, N+1 detection, and slow query analysis.",
+    {
+      since_seconds: z12.number().optional().describe("Analyze queries from the last N seconds")
+    },
+    async ({ since_seconds }) => {
+      const events = store.getDatabaseEvents({ sinceSeconds: since_seconds });
+      const stats = aggregateQueryStats(events);
+      const n1Issues = detectN1Queries(events);
+      const slowIssues = detectSlowQueries(events);
+      const sessions = store.getSessionInfo();
+      const sessionId = sessions[0]?.sessionId ?? null;
+      const issues = [
+        ...n1Issues.map((i) => i.title),
+        ...slowIssues.map((i) => i.title)
+      ];
+      const response = {
+        summary: `Analyzed ${events.length} queries across ${stats.length} unique patterns. ${issues.length} issue(s) found.`,
+        data: {
+          queryStats: stats.slice(0, 20).map((s) => ({
+            pattern: s.normalizedQuery.slice(0, 150),
+            tables: s.tables,
+            operation: s.operation,
+            callCount: s.callCount,
+            avgDuration: `${s.avgDuration.toFixed(0)}ms`,
+            maxDuration: `${s.maxDuration.toFixed(0)}ms`,
+            p95Duration: `${s.p95Duration.toFixed(0)}ms`,
+            totalDuration: `${s.totalDuration.toFixed(0)}ms`,
+            avgRows: s.avgRowsReturned.toFixed(0)
+          })),
+          detectedIssues: [...n1Issues, ...slowIssues]
+        },
+        issues,
+        metadata: {
+          timeRange: { from: 0, to: Date.now() },
+          eventCount: events.length,
+          sessionId
+        }
+      };
+      return {
+        content: [{ type: "text", text: JSON.stringify(response, null, 2) }]
+      };
+    }
+  );
+  server.tool(
+    "get_schema_map",
+    "Get the full database schema: tables, columns, types, foreign keys, and indexes. Requires a configured database connection.",
+    {
+      connection_id: z12.string().optional().describe("Connection ID (defaults to first available)"),
+      table: z12.string().optional().describe("Introspect a specific table only")
+    },
+    async ({ connection_id, table }) => {
+      const connections = connectionManager.listConnections();
+      if (connections.length === 0) {
+        return {
+          content: [{ type: "text", text: JSON.stringify({
+            summary: "No database connections configured.",
+            data: null,
+            issues: ["Configure a database connection in your project's infrastructure config."],
+            metadata: { timeRange: { from: 0, to: 0 }, eventCount: 0, sessionId: null }
+          }, null, 2) }]
+        };
+      }
+      const connId = connection_id ?? connections[0].id;
+      const conn = connectionManager.getConnection(connId);
+      if (!conn) {
+        return {
+          content: [{ type: "text", text: JSON.stringify({
+            summary: `Connection "${connId}" not found.`,
+            data: null,
+            issues: [`Available connections: ${connections.map((c) => c.id).join(", ")}`],
+            metadata: { timeRange: { from: 0, to: 0 }, eventCount: 0, sessionId: null }
+          }, null, 2) }]
+        };
+      }
+      let schema;
+      try {
+        schema = await schemaIntrospector.introspect(conn, table);
+      } catch (err) {
+        return {
+          content: [{ type: "text", text: JSON.stringify({
+            summary: `Schema introspection failed: ${err.message}`,
+            data: null,
+            issues: [err.message],
+            metadata: { timeRange: { from: 0, to: 0 }, eventCount: 0, sessionId: null }
+          }, null, 2) }]
+        };
+      }
+      const response = {
+        summary: `Schema for ${schema.connectionId}: ${schema.tables.length} table(s).`,
+        data: schema.tables.map((t) => ({
+          name: t.name,
+          rowCount: t.rowCount ?? null,
+          columns: t.columns.map((c) => ({
+            name: c.name,
+            type: c.type,
+            nullable: c.nullable,
+            isPrimaryKey: c.isPrimaryKey,
+            default: c.defaultValue ?? null
+          })),
+          foreignKeys: t.foreignKeys,
+          indexes: t.indexes
+        })),
+        issues: [],
+        metadata: {
+          timeRange: { from: schema.fetchedAt, to: schema.fetchedAt },
+          eventCount: schema.tables.length,
+          sessionId: null
+        }
+      };
+      return {
+        content: [{ type: "text", text: JSON.stringify(response, null, 2) }]
+      };
+    }
+  );
+  server.tool(
+    "get_table_data",
+    "Read rows from a database table with pagination. Requires a configured database connection.",
+    {
+      table: z12.string().describe("Table name to read"),
+      connection_id: z12.string().optional().describe("Connection ID"),
+      limit: z12.number().optional().describe("Max rows (default 50, max 1000)"),
+      offset: z12.number().optional().describe("Pagination offset"),
+      where: z12.string().optional().describe("SQL WHERE clause (without WHERE keyword)"),
+      order_by: z12.string().optional().describe("SQL ORDER BY clause (without ORDER BY keyword)")
+    },
+    async ({ table, connection_id, limit, offset, where, order_by }) => {
+      const connections = connectionManager.listConnections();
+      const connId = connection_id ?? connections[0]?.id;
+      if (!connId) {
+        return {
+          content: [{ type: "text", text: JSON.stringify({
+            summary: "No database connections configured.",
+            data: null,
+            issues: ["Configure a database connection."],
+            metadata: { timeRange: { from: 0, to: 0 }, eventCount: 0, sessionId: null }
+          }, null, 2) }]
+        };
+      }
+      const conn = connectionManager.getConnection(connId);
+      if (!conn) {
+        return {
+          content: [{ type: "text", text: `Connection "${connId}" not found.` }]
+        };
+      }
+      let result;
+      try {
+        result = await dataBrowser.read(conn, { table, limit, offset, where, orderBy: order_by });
+      } catch (err) {
+        return {
+          content: [{ type: "text", text: JSON.stringify({
+            summary: `Read failed: ${err.message}`,
+            data: null,
+            issues: [err.message],
+            metadata: { timeRange: { from: 0, to: 0 }, eventCount: 0, sessionId: null }
+          }, null, 2) }]
+        };
+      }
+      const response = {
+        summary: `${result.rows.length} row(s) from "${table}" (${result.total} total).`,
+        data: { rows: result.rows, total: result.total, limit: result.limit, offset: result.offset },
+        issues: [],
+        metadata: {
+          timeRange: { from: 0, to: Date.now() },
+          eventCount: result.rows.length,
+          sessionId: null
+        }
+      };
+      return {
+        content: [{ type: "text", text: JSON.stringify(response, null, 2) }]
+      };
+    }
+  );
+  server.tool(
+    "modify_table_data",
+    "Insert, update, or delete rows in a LOCAL DEV database. Safety guarded: localhost only, WHERE required for update/delete, max 100 affected rows, wrapped in transaction.",
+    {
+      table: z12.string().describe("Table name"),
+      operation: z12.enum(["insert", "update", "delete"]).describe("Operation type"),
+      connection_id: z12.string().optional().describe("Connection ID"),
+      data: z12.record(z12.unknown()).optional().describe("Row data (for insert/update)"),
+      where: z12.string().optional().describe("WHERE clause (required for update/delete)")
+    },
+    async ({ table, operation, connection_id, data, where }) => {
+      const connections = connectionManager.listConnections();
+      const connId = connection_id ?? connections[0]?.id;
+      if (!connId) {
+        return {
+          content: [{ type: "text", text: "No database connections configured." }]
+        };
+      }
+      const conn = connectionManager.getConnection(connId);
+      if (!conn) {
+        return {
+          content: [{ type: "text", text: `Connection "${connId}" not found.` }]
+        };
+      }
+      if ((operation === "update" || operation === "delete") && !where) {
+        return {
+          content: [{ type: "text", text: JSON.stringify({
+            summary: `WHERE clause required for ${operation} operations.`,
+            data: null,
+            issues: [`${operation} without WHERE clause is not allowed`],
+            metadata: { timeRange: { from: 0, to: 0 }, eventCount: 0, sessionId: null }
+          }, null, 2) }]
+        };
+      }
+      let result;
+      try {
+        result = await dataBrowser.write(conn, { table, operation, data, where });
+      } catch (err) {
+        return {
+          content: [{ type: "text", text: JSON.stringify({
+            summary: `Write failed: ${err.message}`,
+            data: null,
+            issues: [err.message],
+            metadata: { timeRange: { from: 0, to: 0 }, eventCount: 0, sessionId: null }
+          }, null, 2) }]
+        };
+      }
+      const response = {
+        summary: result.success ? `${operation} on "${table}": ${result.affectedRows} row(s) affected.` : `${operation} on "${table}" failed: ${result.error}`,
+        data: result,
+        issues: result.error ? [result.error] : [],
+        metadata: {
+          timeRange: { from: Date.now(), to: Date.now() },
+          eventCount: result.affectedRows,
+          sessionId: null
+        }
+      };
+      return {
+        content: [{ type: "text", text: JSON.stringify(response, null, 2) }]
+      };
+    }
+  );
+  server.tool(
+    "get_database_connections",
+    "List all configured database connections with their health status.",
+    {},
+    async () => {
+      const connections = connectionManager.listConnections();
+      const response = {
+        summary: `${connections.length} database connection(s) configured.`,
+        data: connections,
+        issues: connections.filter((c) => !c.isHealthy).map((c) => `Connection "${c.id}" is unhealthy`),
+        metadata: {
+          timeRange: { from: 0, to: Date.now() },
+          eventCount: connections.length,
+          sessionId: null
+        }
+      };
+      return {
+        content: [{ type: "text", text: JSON.stringify(response, null, 2) }]
+      };
+    }
+  );
+  server.tool(
+    "suggest_indexes",
+    "Analyze captured database queries and suggest missing indexes based on WHERE/ORDER BY columns and query performance.",
+    {
+      since_seconds: z12.number().optional().describe("Analyze queries from the last N seconds")
+    },
+    async ({ since_seconds }) => {
+      const events = store.getDatabaseEvents({ sinceSeconds: since_seconds });
+      const suggestions = suggestIndexes(events);
+      const sessions = store.getSessionInfo();
+      const sessionId = sessions[0]?.sessionId ?? null;
+      const response = {
+        summary: `${suggestions.length} index suggestion(s) based on ${events.length} captured queries.`,
+        data: suggestions.map((s) => ({
+          table: s.table,
+          columns: s.columns,
+          reason: s.reason,
+          estimatedImpact: s.estimatedImpact,
+          queryPattern: s.queryPattern,
+          suggestedSQL: `CREATE INDEX idx_${s.table}_${s.columns.join("_")} ON ${s.table}(${s.columns.join(", ")});`
+        })),
+        issues: suggestions.filter((s) => s.estimatedImpact === "high").map((s) => `High-impact index missing on ${s.table}(${s.columns.join(", ")})`),
+        metadata: {
+          timeRange: { from: 0, to: Date.now() },
+          eventCount: events.length,
+          sessionId
+        }
+      };
+      return {
+        content: [{ type: "text", text: JSON.stringify(response, null, 2) }]
+      };
+    }
+  );
+}
+
+// src/tools/process-monitor.ts
+import { z as z13 } from "zod";
+import { execSync, spawn } from "child_process";
+import { existsSync, statSync, rmSync } from "fs";
+import { join } from "path";
+function registerProcessMonitorTools(server, processMonitor) {
+  server.tool(
+    "get_dev_processes",
+    "List all running dev processes (Next.js, Vite, Prisma, Docker, databases, etc.) with PID, port, memory, and CPU usage.",
+    {
+      type: z13.string().optional().describe("Filter by process type (next, vite, docker, postgres, etc.)"),
+      project: z13.string().optional().describe("Filter by project name")
+    },
+    async ({ type, project }) => {
+      processMonitor.scan();
+      const processes = processMonitor.getProcesses({
+        type,
+        project
+      });
+      const issues = processMonitor.detectIssues();
+      const response = {
+        summary: `${processes.length} dev process(es) running.${issues.length > 0 ? ` ${issues.length} issue(s) detected.` : ""}`,
+        data: processes.map((p) => ({
+          pid: p.pid,
+          type: p.type,
+          command: p.command,
+          cpuPercent: `${p.cpuPercent}%`,
+          memoryMB: `${p.memoryMB.toFixed(0)}MB`,
+          ports: p.ports,
+          cwd: p.cwd ?? null,
+          project: p.project ?? null,
+          isOrphaned: p.isOrphaned
+        })),
+        issues: issues.map((i) => i.title),
+        metadata: {
+          timeRange: { from: Date.now(), to: Date.now() },
+          eventCount: processes.length,
+          sessionId: null
+        }
+      };
+      return {
+        content: [{ type: "text", text: JSON.stringify(response, null, 2) }]
+      };
+    }
+  );
+  server.tool(
+    "kill_process",
+    "Terminate a dev process by PID. Default signal is SIGTERM; use SIGKILL for force kill.",
+    {
+      pid: z13.number().describe("Process ID to kill"),
+      signal: z13.enum(["SIGTERM", "SIGKILL"]).optional().describe("Signal to send (default: SIGTERM)")
+    },
+    async ({ pid, signal }) => {
+      if (pid < 2 || pid === process.pid) {
+        return {
+          content: [{ type: "text", text: JSON.stringify({
+            summary: `Refusing to kill PID ${pid}: ${pid < 2 ? "system process" : "current process"}.`,
+            data: { success: false, pid },
+            issues: [`Cannot kill PID ${pid}`],
+            metadata: { timeRange: { from: Date.now(), to: Date.now() }, eventCount: 0, sessionId: null }
+          }, null, 2) }]
+        };
+      }
+      const result = processMonitor.killProcess(pid, signal ?? "SIGTERM");
+      const response = {
+        summary: result.success ? `Process ${pid} terminated with ${signal ?? "SIGTERM"}.` : `Failed to kill process ${pid}: ${result.error}`,
+        data: result,
+        issues: result.error ? [result.error] : [],
+        metadata: {
+          timeRange: { from: Date.now(), to: Date.now() },
+          eventCount: 1,
+          sessionId: null
+        }
+      };
+      return {
+        content: [{ type: "text", text: JSON.stringify(response, null, 2) }]
+      };
+    }
+  );
+  server.tool(
+    "get_port_usage",
+    "Show which dev processes are bound to which ports. Useful for debugging port conflicts.",
+    {
+      port: z13.number().optional().describe("Filter by specific port number")
+    },
+    async ({ port }) => {
+      processMonitor.scan();
+      const ports = processMonitor.getPortUsage(port);
+      const response = {
+        summary: `${ports.length} port binding(s) found.`,
+        data: ports.map((p) => ({
+          port: p.port,
+          pid: p.pid,
+          process: p.process,
+          type: p.type,
+          project: p.project ?? null
+        })),
+        issues: [],
+        metadata: {
+          timeRange: { from: Date.now(), to: Date.now() },
+          eventCount: ports.length,
+          sessionId: null
+        }
+      };
+      return {
+        content: [{ type: "text", text: JSON.stringify(response, null, 2) }]
+      };
+    }
+  );
+  server.tool(
+    "purge_caches",
+    "Delete common build/dev cache directories (.next/cache, node_modules/.cache, .vite, .turbo, .swc, .parcel-cache, etc.) for a project directory. Reports size freed per cache.",
+    {
+      directory: z13.string().describe("Absolute path to the project directory"),
+      dryRun: z13.boolean().optional().describe("If true, report what would be deleted without actually deleting (default: false)")
+    },
+    async ({ directory, dryRun }) => {
+      const CACHE_TARGETS = [
+        ".next/cache",
+        "node_modules/.cache",
+        "node_modules/.vite",
+        ".turbo",
+        ".cache",
+        ".swc",
+        ".parcel-cache",
+        ".nuxt",
+        "tsconfig.tsbuildinfo"
+      ];
+      const purged = [];
+      let totalFreed = 0;
+      for (const target of CACHE_TARGETS) {
+        const fullPath = join(directory, target);
+        if (!existsSync(fullPath)) continue;
+        const sizeMB = getDirSizeMB(fullPath);
+        const deleted = !dryRun;
+        if (!dryRun) {
+          try {
+            rmSync(fullPath, { recursive: true, force: true });
+          } catch {
+            purged.push({ path: target, sizeMB, deleted: false });
+            continue;
+          }
+        }
+        totalFreed += sizeMB;
+        purged.push({ path: target, sizeMB, deleted });
+      }
+      const mode = dryRun ? "Dry run" : "Purged";
+      const response = {
+        summary: purged.length > 0 ? `${mode}: ${purged.length} cache(s), ${totalFreed.toFixed(1)}MB ${dryRun ? "would be freed" : "freed"}.` : "No caches found to purge.",
+        data: {
+          directory,
+          dryRun: dryRun ?? false,
+          totalFreedMB: parseFloat(totalFreed.toFixed(1)),
+          caches: purged
+        },
+        issues: purged.filter((p) => !p.deleted && !dryRun).map((p) => `Failed to delete ${p.path}`),
+        metadata: {
+          timeRange: { from: Date.now(), to: Date.now() },
+          eventCount: purged.length,
+          sessionId: null
+        }
+      };
+      return {
+        content: [{ type: "text", text: JSON.stringify(response, null, 2) }]
+      };
+    }
+  );
+  server.tool(
+    "restart_dev_server",
+    "Kill a dev server process, purge build caches in its working directory, and restart it with the same or a custom command. Combines kill_process + purge_caches + spawn into one operation.",
+    {
+      pid: z13.number().describe("PID of the dev server process to restart"),
+      command: z13.string().optional().describe('Custom start command (e.g. "npm run dev"). If omitted, infers from process type.'),
+      skipCachePurge: z13.boolean().optional().describe("If true, skip cache purging (default: false)"),
+      signal: z13.enum(["SIGTERM", "SIGKILL"]).optional().describe("Kill signal (default: SIGTERM)")
+    },
+    async ({ pid, command, skipCachePurge, signal }) => {
+      if (pid < 2 || pid === process.pid) {
+        return {
+          content: [{ type: "text", text: JSON.stringify({
+            summary: `Refusing to restart PID ${pid}: ${pid < 2 ? "system process" : "current process"}.`,
+            data: { success: false, pid },
+            issues: [`Cannot kill PID ${pid}`],
+            metadata: { timeRange: { from: Date.now(), to: Date.now() }, eventCount: 0, sessionId: null }
+          }, null, 2) }]
+        };
+      }
+      processMonitor.scan();
+      const processes = processMonitor.getProcesses();
+      const proc = processes.find((p) => p.pid === pid);
+      if (!proc) {
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({
+              summary: `Process ${pid} not found. It may have already exited.`,
+              data: { pid, found: false },
+              issues: [`Process ${pid} not found`],
+              metadata: { timeRange: { from: Date.now(), to: Date.now() }, eventCount: 0, sessionId: null }
+            }, null, 2)
+          }]
+        };
+      }
+      const cwd = proc.cwd;
+      const startCommand = command ?? inferStartCommand(proc.type, proc.command);
+      const killResult = processMonitor.killProcess(pid, signal ?? "SIGTERM");
+      if (!killResult.success) {
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({
+              summary: `Failed to kill process ${pid}: ${killResult.error}`,
+              data: { pid, killed: false, error: killResult.error },
+              issues: [killResult.error ?? "Unknown error"],
+              metadata: { timeRange: { from: Date.now(), to: Date.now() }, eventCount: 0, sessionId: null }
+            }, null, 2)
+          }]
+        };
+      }
+      await new Promise((r) => setTimeout(r, 500));
+      let cachesFreedMB = 0;
+      let cachesPurged = 0;
+      if (!skipCachePurge && cwd) {
+        const CACHE_TARGETS = [
+          ".next/cache",
+          "node_modules/.cache",
+          "node_modules/.vite",
+          ".turbo",
+          ".cache",
+          ".swc",
+          ".parcel-cache",
+          ".nuxt",
+          "tsconfig.tsbuildinfo"
+        ];
+        for (const target of CACHE_TARGETS) {
+          const fullPath = join(cwd, target);
+          if (!existsSync(fullPath)) continue;
+          const sizeMB = getDirSizeMB(fullPath);
+          try {
+            rmSync(fullPath, { recursive: true, force: true });
+            cachesFreedMB += sizeMB;
+            cachesPurged++;
+          } catch {
+          }
+        }
+      }
+      let restarted = false;
+      let newPid = null;
+      let restartError;
+      if (startCommand && cwd) {
+        try {
+          const child = spawn(startCommand, {
+            cwd,
+            shell: true,
+            detached: true,
+            stdio: "ignore"
+          });
+          child.unref();
+          newPid = child.pid ?? null;
+          restarted = true;
+        } catch (err) {
+          restartError = err.message;
+        }
+      } else if (!startCommand) {
+        restartError = 'Could not infer start command. Provide one via the "command" parameter.';
+      } else if (!cwd) {
+        restartError = "Could not determine working directory for the process. Provide a command and working directory manually.";
+      }
+      const response = {
+        summary: [
+          `Killed ${proc.type} process ${pid}.`,
+          cachesPurged > 0 ? `Purged ${cachesPurged} cache(s) (${cachesFreedMB.toFixed(1)}MB).` : null,
+          restarted ? `Restarted with PID ${newPid} using: ${startCommand}` : null,
+          restartError ? `Restart failed: ${restartError}` : null
+        ].filter(Boolean).join(" "),
+        data: {
+          killed: { pid, type: proc.type, signal: signal ?? "SIGTERM" },
+          cachesPurged: { count: cachesPurged, freedMB: parseFloat(cachesFreedMB.toFixed(1)) },
+          restarted: { success: restarted, newPid, command: startCommand, cwd }
+        },
+        issues: restartError ? [restartError] : [],
+        metadata: {
+          timeRange: { from: Date.now(), to: Date.now() },
+          eventCount: 1,
+          sessionId: null
+        }
+      };
+      return {
+        content: [{ type: "text", text: JSON.stringify(response, null, 2) }]
+      };
+    }
+  );
+}
+function getDirSizeMB(path) {
+  try {
+    const stat = statSync(path);
+    if (stat.isFile()) return stat.size / (1024 * 1024);
+    const output = execSync(`du -sk "${path}" 2>/dev/null`, { encoding: "utf-8", timeout: 5e3 });
+    const kb = parseInt(output.trim().split("	")[0], 10);
+    return isNaN(kb) ? 0 : kb / 1024;
+  } catch {
+    return 0;
+  }
+}
+function inferStartCommand(type, rawCommand) {
+  const defaults = {
+    next: "npx next dev",
+    vite: "npx vite",
+    webpack: "npx webpack serve",
+    wrangler: "npx wrangler dev",
+    prisma: "npx prisma studio",
+    bun: "bun run dev",
+    deno: "deno task dev"
+  };
+  if (defaults[type]) return defaults[type];
+  if (rawCommand.includes("ts-node") || rawCommand.includes("tsx")) {
+    const match = rawCommand.match(/(ts-node|tsx)\s+(.+)/);
+    if (match) return `npx ${match[1]} ${match[2]}`;
+  }
+  if (type === "node") return "npm run dev";
+  return null;
+}
+
+// src/tools/infra-connector.ts
+import { z as z14 } from "zod";
+function registerInfraTools(server, infraConnector) {
+  server.tool(
+    "get_deploy_logs",
+    "Get deployment history from connected platforms (Vercel, Cloudflare, Railway). Shows build status, branch, commit, and timing.",
+    {
+      project: z14.string().optional().describe("Project name"),
+      platform: z14.string().optional().describe("Filter by platform (vercel, cloudflare, railway)"),
+      deploy_id: z14.string().optional().describe("Get details for a specific deployment")
+    },
+    async ({ project, platform, deploy_id }) => {
+      const logs = await infraConnector.getDeployLogs(project ?? "default", platform, deploy_id);
+      const response = {
+        summary: `${logs.length} deployment(s) found.`,
+        data: logs.map((l) => ({
+          id: l.id,
+          platform: l.platform,
+          status: l.status,
+          url: l.url ?? null,
+          branch: l.branch ?? null,
+          commit: l.commit?.slice(0, 8) ?? null,
+          createdAt: new Date(l.createdAt).toISOString(),
+          readyAt: l.readyAt ? new Date(l.readyAt).toISOString() : null,
+          error: l.errorMessage ?? null
+        })),
+        issues: logs.filter((l) => l.status === "error").map((l) => `Deploy ${l.id.slice(0, 8)} failed on ${l.platform}`),
+        metadata: {
+          timeRange: logs.length > 0 ? { from: Math.min(...logs.map((l) => l.createdAt)), to: Math.max(...logs.map((l) => l.createdAt)) } : { from: 0, to: 0 },
+          eventCount: logs.length,
+          sessionId: null
+        }
+      };
+      return {
+        content: [{ type: "text", text: JSON.stringify(response, null, 2) }]
+      };
+    }
+  );
+  server.tool(
+    "get_runtime_logs",
+    "Get runtime error/info logs from connected deployment platforms.",
+    {
+      project: z14.string().optional().describe("Project name"),
+      platform: z14.string().optional().describe("Filter by platform"),
+      level: z14.string().optional().describe("Filter by log level (info, warn, error)"),
+      since_seconds: z14.number().optional().describe("Only return logs from the last N seconds")
+    },
+    async ({ project, platform, level, since_seconds }) => {
+      const since = since_seconds ? Date.now() - since_seconds * 1e3 : void 0;
+      const logs = await infraConnector.getRuntimeLogs(project ?? "default", { platform, since, level });
+      const response = {
+        summary: `${logs.length} runtime log(s) found.`,
+        data: logs.map((l) => ({
+          timestamp: new Date(l.timestamp).toISOString(),
+          level: l.level,
+          message: l.message,
+          source: l.source ?? null,
+          platform: l.platform
+        })),
+        issues: logs.filter((l) => l.level === "error").length > 0 ? [`${logs.filter((l) => l.level === "error").length} error(s) in runtime logs`] : [],
+        metadata: {
+          timeRange: logs.length > 0 ? { from: logs[logs.length - 1].timestamp, to: logs[0].timestamp } : { from: 0, to: 0 },
+          eventCount: logs.length,
+          sessionId: null
+        }
+      };
+      return {
+        content: [{ type: "text", text: JSON.stringify(response, null, 2) }]
+      };
+    }
+  );
+  server.tool(
+    "get_build_status",
+    "Get the current deployment status for each connected platform.",
+    {
+      project: z14.string().optional().describe("Project name")
+    },
+    async ({ project }) => {
+      const statuses = await infraConnector.getBuildStatus(project ?? "default");
+      const response = {
+        summary: `${statuses.length} platform(s) reporting build status.`,
+        data: statuses.map((s) => ({
+          platform: s.platform,
+          project: s.project,
+          status: s.status,
+          url: s.url ?? null,
+          lastDeployed: new Date(s.lastDeployed).toISOString(),
+          deployId: s.latestDeployId
+        })),
+        issues: statuses.filter((s) => s.status === "error").map((s) => `${s.platform}: latest deploy failed`),
+        metadata: {
+          timeRange: { from: 0, to: Date.now() },
+          eventCount: statuses.length,
+          sessionId: null
+        }
+      };
+      return {
+        content: [{ type: "text", text: JSON.stringify(response, null, 2) }]
+      };
+    }
+  );
+  server.tool(
+    "get_infra_overview",
+    "Overview of which platforms a project uses, combining explicit configuration with auto-detection from network traffic.",
+    {
+      project: z14.string().optional().describe("Project name")
+    },
+    async ({ project }) => {
+      const overview = infraConnector.getInfraOverview(project);
+      const response = {
+        summary: overview.length > 0 ? `Infrastructure overview: ${overview[0].platforms.length} configured platform(s), ${overview[0].detectedFromTraffic.length} detected from traffic.` : "No infrastructure information available.",
+        data: overview,
+        issues: [],
+        metadata: {
+          timeRange: { from: 0, to: Date.now() },
+          eventCount: overview.length,
+          sessionId: null
+        }
+      };
+      return {
+        content: [{ type: "text", text: JSON.stringify(response, null, 2) }]
+      };
+    }
+  );
+}
+
+// src/tools/session-diff.ts
+import { z as z15 } from "zod";
+import { compareSessions } from "@runtimescope/collector";
+function registerSessionDiffTools(server, sessionManager) {
+  server.tool(
+    "compare_sessions",
+    "Compare two sessions: render counts, API latency, errors, Web Vitals, and query performance. Shows regressions and improvements.",
+    {
+      session_a: z15.string().describe("First session ID (baseline)"),
+      session_b: z15.string().describe("Second session ID (comparison)"),
+      project: z15.string().optional().describe("Project name")
+    },
+    async ({ session_a, session_b, project }) => {
+      const projectName = project ?? "default";
+      const history = sessionManager.getSessionHistory(projectName, 100);
+      const snapshotA = history.find((s) => s.sessionId === session_a);
+      const snapshotB = history.find((s) => s.sessionId === session_b);
+      if (!snapshotA || !snapshotB) {
+        return {
+          content: [{ type: "text", text: JSON.stringify({
+            summary: "Could not find one or both sessions in history.",
+            data: null,
+            issues: [
+              !snapshotA ? `Session ${session_a} not found` : null,
+              !snapshotB ? `Session ${session_b} not found` : null
+            ].filter(Boolean),
+            metadata: { timeRange: { from: 0, to: 0 }, eventCount: 0, sessionId: null }
+          }, null, 2) }]
+        };
+      }
+      const diff = compareSessions(snapshotA.metrics, snapshotB.metrics);
+      const regressions = [
+        ...diff.endpointDeltas.filter((d) => d.classification === "regression"),
+        ...diff.componentDeltas.filter((d) => d.classification === "regression"),
+        ...diff.webVitalDeltas.filter((d) => d.classification === "regression"),
+        ...diff.queryDeltas.filter((d) => d.classification === "regression")
+      ];
+      const improvements = [
+        ...diff.endpointDeltas.filter((d) => d.classification === "improvement"),
+        ...diff.componentDeltas.filter((d) => d.classification === "improvement"),
+        ...diff.webVitalDeltas.filter((d) => d.classification === "improvement"),
+        ...diff.queryDeltas.filter((d) => d.classification === "improvement")
+      ];
+      const response = {
+        summary: `Session comparison: ${regressions.length} regression(s), ${improvements.length} improvement(s). Error delta: ${diff.overallDelta.errorCountDelta >= 0 ? "+" : ""}${diff.overallDelta.errorCountDelta}.`,
+        data: {
+          endpointDeltas: diff.endpointDeltas.map((d) => ({
+            ...d,
+            before: `${d.before.toFixed(0)}ms`,
+            after: `${d.after.toFixed(0)}ms`,
+            percentChange: `${(d.percentChange * 100).toFixed(1)}%`
+          })),
+          componentDeltas: diff.componentDeltas.map((d) => ({
+            ...d,
+            percentChange: `${(d.percentChange * 100).toFixed(1)}%`
+          })),
+          webVitalDeltas: diff.webVitalDeltas.map((d) => ({
+            ...d,
+            percentChange: `${(d.percentChange * 100).toFixed(1)}%`
+          })),
+          queryDeltas: diff.queryDeltas.map((d) => ({
+            ...d,
+            before: `${d.before.toFixed(0)}ms`,
+            after: `${d.after.toFixed(0)}ms`,
+            percentChange: `${(d.percentChange * 100).toFixed(1)}%`
+          })),
+          overallDelta: diff.overallDelta
+        },
+        issues: regressions.map((r) => `Regression: ${r.key} (${(r.percentChange * 100).toFixed(1)}% worse)`),
+        metadata: {
+          timeRange: { from: snapshotA.createdAt, to: snapshotB.createdAt },
+          eventCount: 2,
+          sessionId: null
+        }
+      };
+      return {
+        content: [{ type: "text", text: JSON.stringify(response, null, 2) }]
+      };
+    }
+  );
+  server.tool(
+    "get_session_history",
+    "List past sessions with build metadata, event counts, and timestamps. Requires SQLite persistence.",
+    {
+      project: z15.string().optional().describe("Project name"),
+      limit: z15.number().optional().describe("Max sessions to return (default 20)")
+    },
+    async ({ project, limit }) => {
+      const projectName = project ?? "default";
+      const history = sessionManager.getSessionHistory(projectName, limit ?? 20);
+      const response = {
+        summary: `${history.length} session(s) in history for project "${projectName}".`,
+        data: history.map((s) => ({
+          sessionId: s.sessionId,
+          project: s.project,
+          createdAt: new Date(s.createdAt).toISOString(),
+          totalEvents: s.metrics.totalEvents,
+          errorCount: s.metrics.errorCount,
+          endpointCount: Object.keys(s.metrics.endpoints).length,
+          componentCount: Object.keys(s.metrics.components).length,
+          buildMeta: s.buildMeta ?? null
+        })),
+        issues: [],
+        metadata: {
+          timeRange: history.length > 0 ? { from: history[history.length - 1].createdAt, to: history[0].createdAt } : { from: 0, to: 0 },
+          eventCount: history.length,
+          sessionId: null
+        }
+      };
+      return {
+        content: [{ type: "text", text: JSON.stringify(response, null, 2) }]
+      };
+    }
+  );
+}
+
+// src/tools/recon-metadata.ts
+import { z as z16 } from "zod";
+function registerReconMetadataTools(server, store, collector) {
+  server.tool(
+    "get_page_metadata",
+    "Get page metadata and tech stack detection for the current page. Returns URL, viewport, meta tags, detected framework/UI library/build tool/hosting, external stylesheets and scripts. Requires the RuntimeScope extension to be connected.",
+    {
+      url: z16.string().optional().describe("Filter by URL substring"),
+      force_refresh: z16.boolean().optional().default(false).describe("Send a recon_scan command to the extension to capture fresh data")
+    },
+    async ({ url, force_refresh }) => {
+      if (force_refresh) {
+        const sessions2 = store.getSessionInfo();
+        const activeSession = sessions2.find((s) => s.isConnected);
+        if (activeSession) {
+          try {
+            await collector.sendCommand(activeSession.sessionId, {
+              command: "recon_scan",
+              requestId: crypto.randomUUID(),
+              params: { categories: ["recon_metadata"] }
+            });
+          } catch {
+          }
+        }
+      }
+      const event = store.getReconMetadata({ url });
+      const sessions = store.getSessionInfo();
+      const sessionId = sessions[0]?.sessionId ?? null;
+      if (!event) {
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({
+              summary: "No page metadata captured yet. Ensure the RuntimeScope extension is connected and has scanned a page.",
+              data: null,
+              issues: ["No recon_metadata events found in the event store"],
+              metadata: { timeRange: { from: 0, to: 0 }, eventCount: 0, sessionId }
+            }, null, 2)
+          }]
+        };
+      }
+      const ts = event.techStack;
+      const stackParts = [];
+      if (ts.framework.name !== "unknown") stackParts.push(`${ts.framework.name}${ts.framework.version ? " " + ts.framework.version : ""}`);
+      if (ts.metaFramework?.name && ts.metaFramework.name !== "unknown") stackParts.push(ts.metaFramework.name);
+      if (ts.uiLibrary?.name && ts.uiLibrary.name !== "unknown") stackParts.push(ts.uiLibrary.name);
+      if (ts.hosting?.name && ts.hosting.name !== "unknown") stackParts.push(`on ${ts.hosting.name}`);
+      const issues = [];
+      if (!event.metaTags["viewport"]) {
+        issues.push("No viewport meta tag detected");
+      }
+      if (ts.framework.confidence === "low") {
+        issues.push(`Framework detection confidence is low: ${ts.framework.name}`);
+      }
+      const response = {
+        summary: `Page: ${event.title || event.url}. Tech stack: ${stackParts.join(" + ") || "unknown"}. ${event.externalStylesheets.length} stylesheets, ${event.externalScripts.length} scripts.`,
+        data: {
+          url: event.url,
+          title: event.title,
+          viewport: event.viewport,
+          documentLang: event.documentLang,
+          metaTags: event.metaTags,
+          techStack: {
+            framework: ts.framework,
+            metaFramework: ts.metaFramework ?? null,
+            uiLibrary: ts.uiLibrary ?? null,
+            buildTool: ts.buildTool ?? null,
+            hosting: ts.hosting ?? null,
+            stateManagement: ts.stateManagement ?? null,
+            additional: ts.additional
+          },
+          externalStylesheets: event.externalStylesheets,
+          externalScripts: event.externalScripts,
+          preloads: event.preloads
+        },
+        issues,
+        metadata: {
+          timeRange: { from: event.timestamp, to: event.timestamp },
+          eventCount: 1,
+          sessionId: event.sessionId
+        }
+      };
+      return {
+        content: [{ type: "text", text: JSON.stringify(response, null, 2) }]
+      };
+    }
+  );
+}
+
+// src/tools/recon-design-tokens.ts
+import { z as z17 } from "zod";
+function registerReconDesignTokenTools(server, store, collector) {
+  server.tool(
+    "get_design_tokens",
+    "Extract the design system from the current page: CSS custom properties (--variables), color palette, typography scale, spacing scale, border radii, box shadows, and CSS architecture detection. Essential for matching a site's visual style when recreating UI.",
+    {
+      url: z17.string().optional().describe("Filter by URL substring"),
+      category: z17.enum(["all", "colors", "typography", "spacing", "custom_properties", "shadows"]).optional().default("all").describe("Return only a specific token category"),
+      force_refresh: z17.boolean().optional().default(false).describe("Send a recon_scan command to capture fresh data")
+    },
+    async ({ url, category, force_refresh }) => {
+      if (force_refresh) {
+        const sessions2 = store.getSessionInfo();
+        const activeSession = sessions2.find((s) => s.isConnected);
+        if (activeSession) {
+          try {
+            await collector.sendCommand(activeSession.sessionId, {
+              command: "recon_scan",
+              requestId: crypto.randomUUID(),
+              params: { categories: ["recon_design_tokens"] }
+            });
+          } catch {
+          }
+        }
+      }
+      const event = store.getReconDesignTokens({ url });
+      const sessions = store.getSessionInfo();
+      const sessionId = sessions[0]?.sessionId ?? null;
+      if (!event) {
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({
+              summary: "No design tokens captured yet. Ensure the RuntimeScope extension is connected and has scanned a page.",
+              data: null,
+              issues: ["No recon_design_tokens events found in the event store"],
+              metadata: { timeRange: { from: 0, to: 0 }, eventCount: 0, sessionId }
+            }, null, 2)
+          }]
+        };
+      }
+      const issues = [];
+      if (event.customProperties.length === 0) {
+        issues.push("No CSS custom properties (--variables) found. The site may use hardcoded values instead of design tokens.");
+      }
+      if (event.colors.length > 30) {
+        issues.push(`${event.colors.length} unique colors found \u2014 this may indicate an inconsistent color system.`);
+      }
+      if (event.typography.length > 15) {
+        issues.push(`${event.typography.length} unique typography combos found \u2014 may indicate inconsistent type scale.`);
+      }
+      const data = {};
+      if (category === "all" || category === "custom_properties") {
+        data.customProperties = event.customProperties;
+      }
+      if (category === "all" || category === "colors") {
+        data.colors = event.colors;
+      }
+      if (category === "all" || category === "typography") {
+        data.typography = event.typography;
+      }
+      if (category === "all" || category === "spacing") {
+        data.spacing = event.spacing;
+      }
+      if (category === "all" || category === "shadows") {
+        data.borderRadii = event.borderRadii;
+        data.boxShadows = event.boxShadows;
+      }
+      if (category === "all") {
+        data.cssArchitecture = event.cssArchitecture;
+        data.classNamingPatterns = event.classNamingPatterns;
+        data.sampleClassNames = event.sampleClassNames;
+      }
+      const summaryParts = [
+        `${event.customProperties.length} CSS variables`,
+        `${event.colors.length} colors`,
+        `${event.typography.length} type combos`,
+        `${event.spacing.length} spacing values`,
+        `CSS architecture: ${event.cssArchitecture}`
+      ];
+      const response = {
+        summary: summaryParts.join(", ") + ".",
+        data,
+        issues,
+        metadata: {
+          timeRange: { from: event.timestamp, to: event.timestamp },
+          eventCount: 1,
+          sessionId: event.sessionId
+        }
+      };
+      return {
+        content: [{ type: "text", text: JSON.stringify(response, null, 2) }]
+      };
+    }
+  );
+}
+
+// src/tools/recon-fonts.ts
+import { z as z18 } from "zod";
+function registerReconFontTools(server, store) {
+  server.tool(
+    "get_font_info",
+    "Get typography details for the current page: @font-face declarations, font families actually used in computed styles, icon fonts with glyph usage, and font loading strategy. Critical for matching typography when recreating UI.",
+    {
+      url: z18.string().optional().describe("Filter by URL substring")
+    },
+    async ({ url }) => {
+      const event = store.getReconFonts({ url });
+      const sessions = store.getSessionInfo();
+      const sessionId = sessions[0]?.sessionId ?? null;
+      if (!event) {
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({
+              summary: "No font data captured yet. Ensure the RuntimeScope extension is connected and has scanned a page.",
+              data: null,
+              issues: ["No recon_fonts events found in the event store"],
+              metadata: { timeRange: { from: 0, to: 0 }, eventCount: 0, sessionId }
+            }, null, 2)
+          }]
+        };
+      }
+      const issues = [];
+      const uniqueFamilies = new Set(event.fontsUsed.map((f) => f.family));
+      if (uniqueFamilies.size > 5) {
+        issues.push(`${uniqueFamilies.size} different font families in use \u2014 may impact page load performance.`);
+      }
+      const missingDisplay = event.fontFaces.filter((f) => !f.display);
+      if (missingDisplay.length > 0) {
+        issues.push(`${missingDisplay.length} @font-face rule(s) without font-display \u2014 may cause FOIT (flash of invisible text).`);
+      }
+      const families = Array.from(uniqueFamilies).join(", ");
+      const response = {
+        summary: `${event.fontFaces.length} @font-face declarations, ${uniqueFamilies.size} font families in use (${families}), ${event.iconFonts.length} icon font(s). Loading: ${event.loadingStrategy}.`,
+        data: {
+          fontFaces: event.fontFaces,
+          fontsUsed: event.fontsUsed,
+          iconFonts: event.iconFonts,
+          loadingStrategy: event.loadingStrategy
+        },
+        issues,
+        metadata: {
+          timeRange: { from: event.timestamp, to: event.timestamp },
+          eventCount: 1,
+          sessionId: event.sessionId
+        }
+      };
+      return {
+        content: [{ type: "text", text: JSON.stringify(response, null, 2) }]
+      };
+    }
+  );
+}
+
+// src/tools/recon-layout.ts
+import { z as z19 } from "zod";
+function registerReconLayoutTools(server, store, collector) {
+  server.tool(
+    "get_layout_tree",
+    "Get the DOM structure with layout information: element tags, classes, bounding rects, display mode (flex/grid/block), flex/grid properties (direction, justify, align, gap, template columns/rows), position, and z-index. Optionally scoped to a CSS selector. Essential for understanding page structure when recreating UI.",
+    {
+      selector: z19.string().optional().describe('CSS selector to scope the tree (e.g., "nav", ".hero", "main"). Omit for full page.'),
+      max_depth: z19.number().optional().default(10).describe("Maximum depth of the tree to return (default 10)"),
+      url: z19.string().optional().describe("Filter by URL substring"),
+      force_refresh: z19.boolean().optional().default(false).describe("Request fresh capture from extension")
+    },
+    async ({ selector, max_depth, url, force_refresh }) => {
+      if (force_refresh) {
+        const sessions2 = store.getSessionInfo();
+        const activeSession = sessions2.find((s) => s.isConnected);
+        if (activeSession) {
+          try {
+            await collector.sendCommand(activeSession.sessionId, {
+              command: "recon_layout_tree",
+              requestId: crypto.randomUUID(),
+              params: { selector, maxDepth: max_depth }
+            });
+          } catch {
+          }
+        }
+      }
+      const event = store.getReconLayoutTree({ url });
+      const sessions = store.getSessionInfo();
+      const sessionId = sessions[0]?.sessionId ?? null;
+      if (!event) {
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({
+              summary: "No layout tree captured yet. Ensure the RuntimeScope extension is connected and has scanned a page.",
+              data: null,
+              issues: ["No recon_layout_tree events found in the event store"],
+              metadata: { timeRange: { from: 0, to: 0 }, eventCount: 0, sessionId }
+            }, null, 2)
+          }]
+        };
+      }
+      let tree = event.tree;
+      let totalElements = event.totalElements;
+      if (selector && !event.rootSelector) {
+        const found = findNode(tree, selector);
+        if (found) {
+          tree = found;
+          totalElements = countNodes(found);
+        }
+      }
+      const pruned = pruneTree(tree, max_depth ?? 10);
+      const issues = [];
+      const flexCount = countByDisplay(tree, "flex");
+      const gridCount = countByDisplay(tree, "grid");
+      const response = {
+        summary: `Layout tree: ${totalElements} elements, max depth ${event.maxDepth}. ${flexCount} flex containers, ${gridCount} grid containers. Viewport: ${event.viewport.width}x${event.viewport.height}.${selector ? ` Scoped to: ${selector}.` : ""}`,
+        data: {
+          viewport: event.viewport,
+          scrollHeight: event.scrollHeight,
+          rootSelector: selector ?? event.rootSelector ?? null,
+          tree: pruned,
+          totalElements,
+          maxDepth: event.maxDepth
+        },
+        issues,
+        metadata: {
+          timeRange: { from: event.timestamp, to: event.timestamp },
+          eventCount: 1,
+          sessionId: event.sessionId
+        }
+      };
+      return {
+        content: [{ type: "text", text: JSON.stringify(response, null, 2) }]
+      };
+    }
+  );
+}
+function findNode(node, selector) {
+  if (matchesSelector(node, selector)) return node;
+  for (const child of node.children) {
+    const found = findNode(child, selector);
+    if (found) return found;
+  }
+  return null;
+}
+function matchesSelector(node, selector) {
+  if (selector.startsWith("#") && node.id === selector.slice(1)) return true;
+  if (selector.startsWith(".") && node.classList.includes(selector.slice(1))) return true;
+  if (node.tag === selector.toLowerCase()) return true;
+  if (selector.startsWith("[role=") && node.role === selector.slice(6, -1).replace(/"/g, "")) return true;
+  return false;
+}
+function countNodes(node) {
+  let count = 1;
+  for (const child of node.children) {
+    count += countNodes(child);
+  }
+  return count;
+}
+function countByDisplay(node, displayType) {
+  let count = node.display?.includes(displayType) ? 1 : 0;
+  for (const child of node.children) {
+    count += countByDisplay(child, displayType);
+  }
+  return count;
+}
+function pruneTree(node, maxDepth, currentDepth = 0) {
+  if (currentDepth >= maxDepth) {
+    return {
+      ...node,
+      children: [],
+      childCount: node.childCount
+    };
+  }
+  return {
+    ...node,
+    children: node.children.map((c) => pruneTree(c, maxDepth, currentDepth + 1))
+  };
+}
+
+// src/tools/recon-accessibility.ts
+import { z as z20 } from "zod";
+function registerReconAccessibilityTools(server, store) {
+  server.tool(
+    "get_accessibility_tree",
+    "Get the accessibility structure of the current page: heading hierarchy (h1-h6), ARIA landmarks (nav, main, aside), form fields with labels, buttons, links, and images with alt text status. Useful for ensuring UI recreations maintain proper semantic HTML and accessibility.",
+    {
+      url: z20.string().optional().describe("Filter by URL substring")
+    },
+    async ({ url }) => {
+      const event = store.getReconAccessibility({ url });
+      const sessions = store.getSessionInfo();
+      const sessionId = sessions[0]?.sessionId ?? null;
+      if (!event) {
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({
+              summary: "No accessibility data captured yet. Ensure the RuntimeScope extension is connected and has scanned a page.",
+              data: null,
+              issues: ["No recon_accessibility events found in the event store"],
+              metadata: { timeRange: { from: 0, to: 0 }, eventCount: 0, sessionId }
+            }, null, 2)
+          }]
+        };
+      }
+      const issues = [...event.issues];
+      const headingLevels = event.headings.map((h) => h.level);
+      if (headingLevels.length > 0 && headingLevels[0] !== 1) {
+        issues.push(`First heading is h${headingLevels[0]}, not h1.`);
+      }
+      for (let i = 1; i < headingLevels.length; i++) {
+        if (headingLevels[i] > headingLevels[i - 1] + 1) {
+          issues.push(`Heading level skip: h${headingLevels[i - 1]} \u2192 h${headingLevels[i]} (missing h${headingLevels[i - 1] + 1}).`);
+          break;
+        }
+      }
+      const missingAlt = event.images.filter((img) => !img.hasAlt);
+      if (missingAlt.length > 0) {
+        issues.push(`${missingAlt.length} image(s) missing alt text.`);
+      }
+      const unlabeled = event.formFields.filter((f) => !f.label && !f.ariaDescribedBy);
+      if (unlabeled.length > 0) {
+        issues.push(`${unlabeled.length} form field(s) without labels.`);
+      }
+      const hasMain = event.landmarks.some((l) => l.role === "main");
+      const hasNav = event.landmarks.some((l) => l.role === "navigation");
+      if (!hasMain) issues.push("No <main> landmark found.");
+      if (!hasNav) issues.push("No <nav> landmark found.");
+      const response = {
+        summary: `${event.headings.length} headings, ${event.landmarks.length} landmarks, ${event.formFields.length} form fields, ${event.buttons.length} buttons, ${event.links.length} links, ${event.images.length} images. ${issues.length} accessibility issue(s).`,
+        data: {
+          headings: event.headings,
+          landmarks: event.landmarks,
+          formFields: event.formFields,
+          buttons: event.buttons,
+          links: event.links,
+          images: event.images
+        },
+        issues,
+        metadata: {
+          timeRange: { from: event.timestamp, to: event.timestamp },
+          eventCount: 1,
+          sessionId: event.sessionId
+        }
+      };
+      return {
+        content: [{ type: "text", text: JSON.stringify(response, null, 2) }]
+      };
+    }
+  );
+}
+
+// src/tools/recon-computed-styles.ts
+import { z as z21 } from "zod";
+var PROPERTY_GROUPS = {
+  colors: [
+    "color",
+    "background-color",
+    "border-color",
+    "border-top-color",
+    "border-right-color",
+    "border-bottom-color",
+    "border-left-color",
+    "outline-color",
+    "text-decoration-color",
+    "box-shadow",
+    "text-shadow"
+  ],
+  typography: [
+    "font-family",
+    "font-size",
+    "font-weight",
+    "font-style",
+    "line-height",
+    "letter-spacing",
+    "text-align",
+    "text-transform",
+    "text-decoration",
+    "word-spacing",
+    "white-space",
+    "text-overflow"
+  ],
+  spacing: [
+    "margin-top",
+    "margin-right",
+    "margin-bottom",
+    "margin-left",
+    "padding-top",
+    "padding-right",
+    "padding-bottom",
+    "padding-left",
+    "gap"
+  ],
+  layout: [
+    "display",
+    "position",
+    "top",
+    "right",
+    "bottom",
+    "left",
+    "width",
+    "height",
+    "min-width",
+    "max-width",
+    "min-height",
+    "max-height",
+    "flex-direction",
+    "justify-content",
+    "align-items",
+    "flex-wrap",
+    "flex-grow",
+    "flex-shrink",
+    "grid-template-columns",
+    "grid-template-rows",
+    "grid-column",
+    "grid-row",
+    "overflow",
+    "z-index"
+  ],
+  borders: [
+    "border-width",
+    "border-style",
+    "border-color",
+    "border-radius",
+    "border-top-width",
+    "border-right-width",
+    "border-bottom-width",
+    "border-left-width",
+    "border-top-left-radius",
+    "border-top-right-radius",
+    "border-bottom-right-radius",
+    "border-bottom-left-radius",
+    "outline-width",
+    "outline-style",
+    "outline-color",
+    "outline-offset"
+  ],
+  visual: [
+    "opacity",
+    "background-color",
+    "background-image",
+    "background-size",
+    "background-position",
+    "box-shadow",
+    "text-shadow",
+    "filter",
+    "backdrop-filter",
+    "transform",
+    "transition",
+    "animation"
+  ]
+};
+function registerReconComputedStyleTools(server, store, collector, scanner) {
+  server.tool(
+    "get_computed_styles",
+    "Get computed CSS styles for elements matching a selector. Returns the actual resolved values the browser uses to render each element. Can filter by property group (colors, typography, spacing, layout, borders, visual) or specific property names. When multiple elements match, highlights variations between them.",
+    {
+      selector: z21.string().describe('CSS selector to query (e.g., ".btn-primary", "nav > ul > li", "[data-testid=hero]")'),
+      properties: z21.enum(["all", "colors", "typography", "spacing", "layout", "borders", "visual"]).optional().default("all").describe('Property group to return, or "all" for everything'),
+      specific_properties: z21.array(z21.string()).optional().describe("Specific CSS property names to return (overrides the properties group)"),
+      force_refresh: z21.boolean().optional().default(false).describe("Request fresh capture from extension or scanner for this selector")
+    },
+    async ({ selector, properties, specific_properties, force_refresh }) => {
+      const propFilter = specific_properties ?? (properties !== "all" ? PROPERTY_GROUPS[properties] : void 0);
+      if (force_refresh) {
+        const sessions2 = store.getSessionInfo();
+        const activeSession = sessions2.find((s) => s.isConnected);
+        if (activeSession) {
+          try {
+            await collector.sendCommand(activeSession.sessionId, {
+              command: "recon_computed_styles",
+              requestId: crypto.randomUUID(),
+              params: { selector, properties: propFilter }
+            });
+          } catch {
+          }
+        }
+      }
+      const events = store.getReconComputedStyles();
+      let event = events.find((e) => e.selector === selector) ?? events[0];
+      if ((!event || event.entries.length === 0) && scanner.getLastScannedUrl()) {
+        const url = scanner.getLastScannedUrl();
+        try {
+          const raw = await scanner.queryComputedStyles(url, selector, propFilter);
+          if (raw.entries.length > 0) {
+            const syntheticEvent = {
+              eventId: `evt-scan-cs-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+              sessionId: `scan-${Date.now()}`,
+              timestamp: Date.now(),
+              eventType: "recon_computed_styles",
+              url,
+              selector: raw.selector,
+              propertyFilter: raw.propertyFilter,
+              entries: raw.entries
+            };
+            store.addEvent(syntheticEvent);
+            event = syntheticEvent;
+          }
+        } catch {
+        }
+      }
+      const sessions = store.getSessionInfo();
+      const sessionId = sessions[0]?.sessionId ?? null;
+      if (!event || event.entries.length === 0) {
+        const hint = scanner.getLastScannedUrl() ? `No elements matched "${selector}" on the scanned page. Check the selector and try again.` : `No computed styles captured for "${selector}". Run scan_website first to scan a page, then query selectors on it.`;
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({
+              summary: hint,
+              data: null,
+              issues: ["No computed style data available for this selector"],
+              metadata: { timeRange: { from: 0, to: 0 }, eventCount: 0, sessionId }
+            }, null, 2)
+          }]
+        };
+      }
+      const issues = [];
+      const entries = event.entries.map((entry) => {
+        let styles = entry.styles;
+        if (specific_properties && specific_properties.length > 0) {
+          const filtered = {};
+          for (const prop of specific_properties) {
+            if (styles[prop] !== void 0) filtered[prop] = styles[prop];
+          }
+          styles = filtered;
+        } else if (properties !== "all" && PROPERTY_GROUPS[properties]) {
+          const group = PROPERTY_GROUPS[properties];
+          const filtered = {};
+          for (const prop of group) {
+            if (styles[prop] !== void 0) filtered[prop] = styles[prop];
+          }
+          styles = filtered;
+        }
+        return {
+          selector: entry.selector,
+          matchCount: entry.matchCount,
+          styles,
+          variations: entry.variations ?? []
+        };
+      });
+      for (const entry of entries) {
+        if (entry.variations.length > 0) {
+          issues.push(
+            `${entry.variations.length} property variation(s) across ${entry.matchCount} matching elements for "${entry.selector}".`
+          );
+        }
+      }
+      const totalProps = entries.reduce((sum, e) => sum + Object.keys(e.styles).length, 0);
+      const response = {
+        summary: `${entries.length} element(s) matched "${selector}". ${totalProps} CSS properties returned${properties !== "all" ? ` (${properties} group)` : ""}.`,
+        data: {
+          selector,
+          propertyFilter: specific_properties ?? properties,
+          entries
+        },
+        issues,
+        metadata: {
+          timeRange: { from: event.timestamp, to: event.timestamp },
+          eventCount: 1,
+          sessionId: event.sessionId
+        }
+      };
+      return {
+        content: [{ type: "text", text: JSON.stringify(response, null, 2) }]
+      };
+    }
+  );
+}
+
+// src/tools/recon-element-snapshot.ts
+import { z as z22 } from "zod";
+function registerReconElementSnapshotTools(server, store, collector, scanner) {
+  server.tool(
+    "get_element_snapshot",
+    'Deep snapshot of a specific element and its children: structure, attributes, text content, bounding rects, and key computed styles for every node. This is the "zoom in" tool \u2014 use it when you need the full picture of a component (a card, a nav bar, a form) for recreation. More detailed than get_layout_tree, more targeted than get_computed_styles.',
+    {
+      selector: z22.string().describe('CSS selector for the root element (e.g., ".card", "#hero", "[data-testid=checkout-form]")'),
+      depth: z22.number().optional().default(5).describe("How many levels deep to capture children (default 5)"),
+      force_refresh: z22.boolean().optional().default(false).describe("Request fresh capture from extension or scanner for this element")
+    },
+    async ({ selector, depth, force_refresh }) => {
+      if (force_refresh) {
+        const sessions2 = store.getSessionInfo();
+        const activeSession = sessions2.find((s) => s.isConnected);
+        if (activeSession) {
+          try {
+            await collector.sendCommand(activeSession.sessionId, {
+              command: "recon_element_snapshot",
+              requestId: crypto.randomUUID(),
+              params: { selector, depth }
+            });
+          } catch {
+          }
+        }
+      }
+      const events = store.getReconElementSnapshots();
+      let event = events.find((e) => e.selector === selector) ?? events[0];
+      if (!event && scanner.getLastScannedUrl()) {
+        const url = scanner.getLastScannedUrl();
+        try {
+          const raw = await scanner.queryElementSnapshot(url, selector, depth);
+          if (raw) {
+            const syntheticEvent = {
+              eventId: `evt-scan-es-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+              sessionId: `scan-${Date.now()}`,
+              timestamp: Date.now(),
+              eventType: "recon_element_snapshot",
+              url,
+              selector: raw.selector,
+              depth: raw.depth,
+              totalNodes: raw.totalNodes,
+              root: raw.root
+            };
+            store.addEvent(syntheticEvent);
+            event = syntheticEvent;
+          }
+        } catch {
+        }
+      }
+      const sessions = store.getSessionInfo();
+      const sessionId = sessions[0]?.sessionId ?? null;
+      if (!event) {
+        const hint = scanner.getLastScannedUrl() ? `No element found matching "${selector}" on the scanned page. Check the selector and try again.` : `No element snapshot captured for "${selector}". Run scan_website first to scan a page, then query selectors on it.`;
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({
+              summary: hint,
+              data: null,
+              issues: ["No element snapshot data available for this selector"],
+              metadata: { timeRange: { from: 0, to: 0 }, eventCount: 0, sessionId }
+            }, null, 2)
+          }]
+        };
+      }
+      const issues = [];
+      const root = event.root;
+      if (root.boundingRect.width === 0 || root.boundingRect.height === 0) {
+        issues.push(`Root element "${selector}" has zero dimensions (${root.boundingRect.width}x${root.boundingRect.height}). It may be hidden.`);
+      }
+      const response = {
+        summary: `Element snapshot for "${selector}": ${event.totalNodes} nodes captured to depth ${event.depth}. Root is <${root.tag}> at ${root.boundingRect.width}x${root.boundingRect.height}px.`,
+        data: {
+          selector: event.selector,
+          depth: event.depth,
+          totalNodes: event.totalNodes,
+          root: event.root
+        },
+        issues,
+        metadata: {
+          timeRange: { from: event.timestamp, to: event.timestamp },
+          eventCount: 1,
+          sessionId: event.sessionId
+        }
+      };
+      return {
+        content: [{ type: "text", text: JSON.stringify(response, null, 2) }]
+      };
+    }
+  );
+}
+
+// src/tools/recon-assets.ts
+import { z as z23 } from "zod";
+function registerReconAssetTools(server, store) {
+  server.tool(
+    "get_asset_inventory",
+    "Sprite-aware asset inventory for the current page. Detects and extracts: standard images, inline SVGs, SVG sprite sheets (<symbol>/<use> references), CSS background sprites (with crop coordinates and extracted frames), CSS mask sprites, and icon fonts (with glyph codepoints). For CSS sprites, calculates the exact crop rectangle from background-position/size and can provide extracted individual frames as data URLs.",
+    {
+      category: z23.enum(["all", "images", "svg", "sprites", "icon_fonts"]).optional().default("all").describe("Filter by asset category"),
+      url: z23.string().optional().describe("Filter by page URL substring")
+    },
+    async ({ category, url }) => {
+      const event = store.getReconAssetInventory({ url });
+      const sessions = store.getSessionInfo();
+      const sessionId = sessions[0]?.sessionId ?? null;
+      if (!event) {
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({
+              summary: "No asset inventory captured yet. Ensure the RuntimeScope extension is connected and has scanned a page.",
+              data: null,
+              issues: ["No recon_asset_inventory events found in the event store"],
+              metadata: { timeRange: { from: 0, to: 0 }, eventCount: 0, sessionId }
+            }, null, 2)
+          }]
+        };
+      }
+      const issues = [];
+      const data = {};
+      if (category === "all" || category === "images") {
+        data.images = event.images;
+        const missingAlt = event.images.filter((img) => !img.alt);
+        if (missingAlt.length > 0) {
+          issues.push(`${missingAlt.length} image(s) missing alt text.`);
+        }
+        const oversized = event.images.filter(
+          (img) => img.naturalWidth && img.width && img.naturalWidth > img.width * 2
+        );
+        if (oversized.length > 0) {
+          issues.push(`${oversized.length} image(s) are significantly larger than their display size \u2014 consider resizing.`);
+        }
+      }
+      if (category === "all" || category === "svg") {
+        data.inlineSVGs = event.inlineSVGs;
+        data.svgSprites = event.svgSprites;
+      }
+      if (category === "all" || category === "sprites") {
+        data.backgroundSprites = event.backgroundSprites;
+        data.maskSprites = event.maskSprites;
+        data.svgSprites = event.svgSprites;
+        const totalBgFrames = event.backgroundSprites.reduce((sum, s) => sum + s.frames.length, 0);
+        const totalMaskFrames = event.maskSprites.reduce((sum, s) => sum + s.frames.length, 0);
+        const totalSvgSymbols = event.svgSprites.length;
+        if (totalBgFrames > 0 || totalMaskFrames > 0 || totalSvgSymbols > 0) {
+          const spriteParts = [];
+          if (totalBgFrames > 0) spriteParts.push(`${totalBgFrames} background sprite frame(s) from ${event.backgroundSprites.length} sheet(s)`);
+          if (totalMaskFrames > 0) spriteParts.push(`${totalMaskFrames} mask sprite frame(s) from ${event.maskSprites.length} sheet(s)`);
+          if (totalSvgSymbols > 0) spriteParts.push(`${totalSvgSymbols} SVG symbol(s)`);
+          issues.push(`Sprite detection: ${spriteParts.join(", ")}.`);
+        }
+      }
+      if (category === "all" || category === "icon_fonts") {
+        data.iconFonts = event.iconFonts;
+        const totalGlyphs2 = event.iconFonts.reduce((sum, f) => sum + f.glyphs.length, 0);
+        if (totalGlyphs2 > 0) {
+          issues.push(`${totalGlyphs2} icon font glyph(s) from ${event.iconFonts.length} font(s) detected.`);
+        }
+      }
+      const summaryParts = [];
+      summaryParts.push(`${event.images.length} images`);
+      summaryParts.push(`${event.inlineSVGs.length} inline SVGs`);
+      const bgFrames = event.backgroundSprites.reduce((sum, s) => sum + s.frames.length, 0);
+      if (bgFrames > 0) summaryParts.push(`${bgFrames} CSS sprite frames`);
+      if (event.svgSprites.length > 0) summaryParts.push(`${event.svgSprites.length} SVG symbols`);
+      if (event.maskSprites.length > 0) {
+        const maskFrames = event.maskSprites.reduce((sum, s) => sum + s.frames.length, 0);
+        summaryParts.push(`${maskFrames} mask sprite frames`);
+      }
+      const totalGlyphs = event.iconFonts.reduce((sum, f) => sum + f.glyphs.length, 0);
+      if (totalGlyphs > 0) summaryParts.push(`${totalGlyphs} icon font glyphs`);
+      summaryParts.push(`${event.totalAssets} total assets`);
+      const response = {
+        summary: summaryParts.join(", ") + ".",
+        data,
+        issues,
+        metadata: {
+          timeRange: { from: event.timestamp, to: event.timestamp },
+          eventCount: 1,
+          sessionId: event.sessionId
+        }
+      };
+      return {
+        content: [{ type: "text", text: JSON.stringify(response, null, 2) }]
+      };
+    }
+  );
+}
+
+// src/tools/recon-style-diff.ts
+import { z as z24 } from "zod";
+var VISUAL_PROPERTIES = [
+  "color",
+  "background-color",
+  "border-color",
+  "border-radius",
+  "font-family",
+  "font-size",
+  "font-weight",
+  "line-height",
+  "letter-spacing",
+  "padding-top",
+  "padding-right",
+  "padding-bottom",
+  "padding-left",
+  "margin-top",
+  "margin-right",
+  "margin-bottom",
+  "margin-left",
+  "width",
+  "height",
+  "display",
+  "position",
+  "gap",
+  "flex-direction",
+  "justify-content",
+  "align-items",
+  "box-shadow",
+  "text-shadow",
+  "opacity",
+  "border-width",
+  "border-style",
+  "text-align",
+  "text-transform",
+  "text-decoration",
+  "overflow",
+  "grid-template-columns",
+  "grid-template-rows"
+];
+function registerReconStyleDiffTools(server, store) {
+  server.tool(
+    "get_style_diff",
+    "Compare computed styles between two captured element snapshots to check how closely a recreation matches the original. Compares two selectors from stored computed style events and reports property-by-property differences with a match percentage. Use this to verify UI recreation fidelity.",
+    {
+      source_selector: z24.string().describe("CSS selector for the source/original element"),
+      target_selector: z24.string().describe("CSS selector for the target/recreation element"),
+      properties: z24.enum(["visual", "all"]).optional().default("visual").describe('"visual" compares only visually-significant properties (colors, typography, spacing, layout). "all" compares everything.'),
+      specific_properties: z24.array(z24.string()).optional().describe("Specific CSS property names to compare (overrides properties group)")
+    },
+    async ({ source_selector, target_selector, properties, specific_properties }) => {
+      const events = store.getReconComputedStyles();
+      const sessions = store.getSessionInfo();
+      const sessionId = sessions[0]?.sessionId ?? null;
+      const sourceEvent = events.find(
+        (e) => e.entries.some((entry) => entry.selector === source_selector)
+      );
+      const targetEvent = events.find(
+        (e) => e.entries.some((entry) => entry.selector === target_selector)
+      );
+      if (!sourceEvent || !targetEvent) {
+        const missing = [];
+        if (!sourceEvent) missing.push(`source "${source_selector}"`);
+        if (!targetEvent) missing.push(`target "${target_selector}"`);
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({
+              summary: `Missing computed styles for ${missing.join(" and ")}. Capture computed styles for both selectors first using get_computed_styles with force_refresh=true.`,
+              data: null,
+              issues: [`No captured styles for: ${missing.join(", ")}`],
+              metadata: { timeRange: { from: 0, to: 0 }, eventCount: 0, sessionId }
+            }, null, 2)
+          }]
+        };
+      }
+      const sourceEntry = sourceEvent.entries.find((e) => e.selector === source_selector);
+      const targetEntry = targetEvent.entries.find((e) => e.selector === target_selector);
+      let propsToCompare;
+      if (specific_properties && specific_properties.length > 0) {
+        propsToCompare = specific_properties;
+      } else if (properties === "visual") {
+        propsToCompare = VISUAL_PROPERTIES;
+      } else {
+        propsToCompare = Array.from(
+          /* @__PURE__ */ new Set([...Object.keys(sourceEntry.styles), ...Object.keys(targetEntry.styles)])
+        );
+      }
+      const diffs = [];
+      let matchCount = 0;
+      let diffCount = 0;
+      for (const prop of propsToCompare) {
+        const sourceVal = sourceEntry.styles[prop] ?? "(not set)";
+        const targetVal = targetEntry.styles[prop] ?? "(not set)";
+        const match = normalizeValue(sourceVal) === normalizeValue(targetVal);
+        if (match) matchCount++;
+        else diffCount++;
+        const entry = { property: prop, sourceValue: sourceVal, targetValue: targetVal, match };
+        if (!match) {
+          const sourceNum = parseNumericValue(sourceVal);
+          const targetNum = parseNumericValue(targetVal);
+          if (sourceNum !== null && targetNum !== null) {
+            const diff = targetNum - sourceNum;
+            entry.delta = `${diff > 0 ? "+" : ""}${diff.toFixed(1)}px`;
+          }
+        }
+        diffs.push(entry);
+      }
+      const matchPercentage = propsToCompare.length > 0 ? Math.round(matchCount / propsToCompare.length * 100) : 100;
+      const issues = [];
+      const significantDiffs = diffs.filter((d) => !d.match);
+      if (significantDiffs.length > 0) {
+        const topDiffs = significantDiffs.slice(0, 10);
+        for (const d of topDiffs) {
+          issues.push(`${d.property}: "${d.sourceValue}" \u2192 "${d.targetValue}"${d.delta ? ` (${d.delta})` : ""}`);
+        }
+        if (significantDiffs.length > 10) {
+          issues.push(`...and ${significantDiffs.length - 10} more differences.`);
+        }
+      }
+      const response = {
+        summary: `Style comparison: ${matchPercentage}% match (${matchCount}/${propsToCompare.length} properties). ${diffCount} difference(s) between "${source_selector}" and "${target_selector}".`,
+        data: {
+          sourceSelector: source_selector,
+          targetSelector: target_selector,
+          matchPercentage,
+          totalProperties: propsToCompare.length,
+          matches: matchCount,
+          differences: diffCount,
+          diffs: diffs.filter((d) => !d.match),
+          // Only return differences
+          matchingProperties: diffs.filter((d) => d.match).map((d) => d.property)
+        },
+        issues,
+        metadata: {
+          timeRange: {
+            from: Math.min(sourceEvent.timestamp, targetEvent.timestamp),
+            to: Math.max(sourceEvent.timestamp, targetEvent.timestamp)
+          },
+          eventCount: 2,
+          sessionId
+        }
+      };
+      return {
+        content: [{ type: "text", text: JSON.stringify(response, null, 2) }]
+      };
+    }
+  );
+}
+function normalizeValue(value) {
+  return value.trim().toLowerCase().replace(/\s+/g, " ");
+}
+function parseNumericValue(value) {
+  const match = value.match(/^(-?[\d.]+)\s*(px|rem|em|%)$/);
+  if (!match) return null;
+  const num = parseFloat(match[1]);
+  const unit = match[2];
+  if (unit === "rem" || unit === "em") return num * 16;
+  return num;
+}
+
+// src/scanner/index.ts
+import { readFileSync } from "fs";
+import { resolve, dirname } from "path";
+import { fileURLToPath } from "url";
+import { TechnologyDatabase, detect } from "@runtimescope/extension";
+
+// src/scanner/signal-collector.ts
+async function collectDetectionSignals(page, mainResponse, jsGlobalPaths, domSelectors) {
+  const url = page.url();
+  const headers = {};
+  if (mainResponse) {
+    const allHeaders = await mainResponse.allHeaders();
+    for (const [key, value] of Object.entries(allHeaders)) {
+      headers[key.toLowerCase()] = value;
+    }
+  }
+  const cookies = {};
+  const rawCookies = await page.context().cookies();
+  for (const c of rawCookies) {
+    cookies[c.name] = c.value;
+  }
+  const pageSignals = await page.evaluate(() => {
+    const meta = {};
+    document.querySelectorAll("meta[name],meta[property],meta[http-equiv]").forEach((el) => {
+      const name = el.getAttribute("name") || el.getAttribute("property") || el.getAttribute("http-equiv");
+      const content = el.getAttribute("content");
+      if (name && content) meta[name.toLowerCase()] = content;
+    });
+    const scriptSrc = [];
+    document.querySelectorAll("script[src]").forEach((el) => {
+      const src = el.getAttribute("src");
+      if (src) scriptSrc.push(src);
+    });
+    const scripts = [];
+    document.querySelectorAll("script:not([src])").forEach((el) => {
+      const text = el.textContent?.trim();
+      if (text && scripts.length < 50) {
+        scripts.push(text.slice(0, 500));
+      }
+    });
+    const css = [];
+    const rootStyles = getComputedStyle(document.documentElement);
+    const cssVarNames = [];
+    for (let i = 0; i < rootStyles.length; i++) {
+      const prop = rootStyles[i];
+      if (prop.startsWith("--")) cssVarNames.push(prop);
+    }
+    if (cssVarNames.length > 0) {
+      css.push(cssVarNames.map((v) => `${v}: ${rootStyles.getPropertyValue(v)}`).join("; "));
+    }
+    document.querySelectorAll("style").forEach((el) => {
+      const text = el.textContent?.trim();
+      if (text && css.length < 20) css.push(text.slice(0, 2e3));
+    });
+    return { meta, scriptSrc, scripts, css };
+  });
+  const fullHtml = await page.content();
+  const html = fullHtml.slice(0, 5e4);
+  const js = await page.evaluate((paths) => {
+    const results = {};
+    for (const path of paths) {
+      try {
+        const parts = path.split(".");
+        let current = window;
+        for (const part of parts) {
+          if (current == null) break;
+          current = current[part];
+        }
+        if (current !== void 0) {
+          results[path] = typeof current === "string" ? current : typeof current === "number" ? String(current) : "";
+        }
+      } catch {
+      }
+    }
+    return results;
+  }, jsGlobalPaths);
+  const dom = await page.evaluate((selectors) => {
+    const results = {};
+    for (const selector of selectors) {
+      try {
+        const elements = document.querySelectorAll(selector);
+        if (elements.length === 0) continue;
+        const elResults = [];
+        const limit = Math.min(elements.length, 3);
+        for (let i = 0; i < limit; i++) {
+          const el = elements[i];
+          const attributes = {};
+          for (const attr of el.attributes) {
+            attributes[attr.name] = attr.value;
+          }
+          const properties = {};
+          const propsToCheck = ["_reactRootContainer", "__vue__", "__svelte", "ng-version"];
+          for (const prop of propsToCheck) {
+            if (prop in el) {
+              properties[prop] = String(el[prop] ?? "");
+            }
+          }
+          elResults.push({
+            exists: true,
+            attributes,
+            properties,
+            text: (el.textContent || "").trim().slice(0, 200)
+          });
+        }
+        results[selector] = elResults;
+      } catch {
+      }
+    }
+    return results;
+  }, domSelectors);
+  return {
+    url,
+    headers,
+    cookies,
+    meta: pageSignals.meta,
+    scriptSrc: pageSignals.scriptSrc,
+    scripts: pageSignals.scripts,
+    html,
+    css: pageSignals.css,
+    js,
+    dom
+    // xhr: not collected in one-shot scan (would need request interception over time)
+  };
+}
+function extractJsGlobalPaths(technologies) {
+  const paths = /* @__PURE__ */ new Set();
+  for (const tech of technologies) {
+    if (tech.js) {
+      for (const path of Object.keys(tech.js)) {
+        paths.add(path);
+      }
+    }
+  }
+  return Array.from(paths);
+}
+function extractDomSelectors(technologies) {
+  const selectors = /* @__PURE__ */ new Set();
+  for (const tech of technologies) {
+    if (tech.dom) {
+      for (const selector of Object.keys(tech.dom)) {
+        selectors.add(selector);
+      }
+    }
+  }
+  return Array.from(selectors);
+}
+
+// src/scanner/recon-collectors.ts
+async function collectDesignTokens(page) {
+  return page.evaluate(() => {
+    const rootStyle = getComputedStyle(document.documentElement);
+    const customProperties = [];
+    for (let i = 0; i < rootStyle.length; i++) {
+      const prop = rootStyle[i];
+      if (prop.startsWith("--")) {
+        customProperties.push({ name: prop, value: rootStyle.getPropertyValue(prop).trim(), source: ":root" });
+      }
+    }
+    const colorMap = /* @__PURE__ */ new Map();
+    const typoMap = /* @__PURE__ */ new Map();
+    const spacingMap = /* @__PURE__ */ new Map();
+    const radiusMap = /* @__PURE__ */ new Map();
+    const shadowMap = /* @__PURE__ */ new Map();
+    const allElements = document.querySelectorAll("body *");
+    const sampleLimit = Math.min(allElements.length, 200);
+    for (let i = 0; i < sampleLimit; i++) {
+      const el = allElements[i];
+      const elRect = el.getBoundingClientRect();
+      if (elRect.width === 0 && elRect.height === 0) continue;
+      const cs = getComputedStyle(el);
+      const cls = el.getAttribute("class") || "";
+      const selector = el.tagName.toLowerCase() + (cls ? "." + cls.split(" ")[0] : "");
+      for (const prop of ["color", "background-color", "border-color"]) {
+        const val = cs.getPropertyValue(prop);
+        if (val && val !== "rgba(0, 0, 0, 0)" && val !== "transparent") {
+          const entry = colorMap.get(val) || { count: 0, properties: /* @__PURE__ */ new Set(), selectors: /* @__PURE__ */ new Set() };
+          entry.count++;
+          entry.properties.add(prop);
+          if (entry.selectors.size < 3) entry.selectors.add(selector);
+          colorMap.set(val, entry);
+        }
+      }
+      const typoKey = `${cs.fontFamily}|${cs.fontSize}|${cs.fontWeight}|${cs.lineHeight}|${cs.letterSpacing}`;
+      const typoEntry = typoMap.get(typoKey) || {
+        count: 0,
+        selectors: /* @__PURE__ */ new Set(),
+        parsed: { fontFamily: cs.fontFamily, fontSize: cs.fontSize, fontWeight: cs.fontWeight, lineHeight: cs.lineHeight, letterSpacing: cs.letterSpacing }
+      };
+      typoEntry.count++;
+      if (typoEntry.selectors.size < 3) typoEntry.selectors.add(selector);
+      typoMap.set(typoKey, typoEntry);
+      for (const prop of ["padding-top", "padding-right", "padding-bottom", "padding-left", "margin-top", "margin-right", "margin-bottom", "margin-left", "gap"]) {
+        const val = cs.getPropertyValue(prop);
+        if (val && val !== "0px" && val !== "normal" && val !== "auto") {
+          const entry = spacingMap.get(val) || { count: 0, properties: /* @__PURE__ */ new Set() };
+          entry.count++;
+          entry.properties.add(prop.replace(/-(?:top|right|bottom|left)/, ""));
+          spacingMap.set(val, entry);
+        }
+      }
+      const radius = cs.borderRadius;
+      if (radius && radius !== "0px") {
+        radiusMap.set(radius, (radiusMap.get(radius) || 0) + 1);
+      }
+      const shadow = cs.boxShadow;
+      if (shadow && shadow !== "none") {
+        shadowMap.set(shadow, (shadowMap.get(shadow) || 0) + 1);
+      }
+    }
+    function rgbToHex(rgb) {
+      const match = rgb.match(/rgba?\((\d+),\s*(\d+),\s*(\d+)/);
+      if (!match) return rgb;
+      return "#" + [match[1], match[2], match[3]].map((n) => parseInt(n).toString(16).padStart(2, "0")).join("");
+    }
+    const colors = Array.from(colorMap.entries()).map(([value, data]) => ({
+      value,
+      hex: rgbToHex(value),
+      usageCount: data.count,
+      properties: Array.from(data.properties),
+      sampleSelectors: Array.from(data.selectors)
+    })).sort((a, b) => b.usageCount - a.usageCount).slice(0, 50);
+    const typography = Array.from(typoMap.values()).map((data) => ({
+      ...data.parsed,
+      usageCount: data.count,
+      sampleSelectors: Array.from(data.selectors)
+    })).sort((a, b) => b.usageCount - a.usageCount).slice(0, 30);
+    const spacing = Array.from(spacingMap.entries()).map(([value, data]) => ({
+      value,
+      pixels: parseFloat(value) || 0,
+      usageCount: data.count,
+      properties: Array.from(data.properties)
+    })).sort((a, b) => b.usageCount - a.usageCount).slice(0, 30);
+    const borderRadii = Array.from(radiusMap.entries()).map(([value, count]) => ({ value, usageCount: count })).sort((a, b) => b.usageCount - a.usageCount);
+    const boxShadows = Array.from(shadowMap.entries()).map(([value, count]) => ({ value, usageCount: count })).sort((a, b) => b.usageCount - a.usageCount);
+    const sampleClassNames = [];
+    const classCounts = { tailwind: 0, bem: 0, modules: 0, atomic: 0, vanilla: 0 };
+    document.querySelectorAll("[class]").forEach((el) => {
+      if (sampleClassNames.length < 20) {
+        for (const c of el.classList) sampleClassNames.push(c);
+      }
+      for (const c of el.classList) {
+        if (/^(flex|grid|text-|bg-|p-|m-|w-|h-|gap-|items-|justify-)/.test(c)) classCounts.tailwind++;
+        else if (/^[a-z]+--.+/.test(c) || /__/.test(c)) classCounts.bem++;
+        else if (/^[a-zA-Z]+_[a-zA-Z0-9_]{5,}$/.test(c)) classCounts.modules++;
+      }
+    });
+    let cssArchitecture = "vanilla";
+    const classNamingPatterns = [];
+    if (classCounts.tailwind > 10) {
+      cssArchitecture = "tailwind";
+      classNamingPatterns.push("tailwind utilities");
+    } else if (classCounts.bem > 5) {
+      cssArchitecture = "bem";
+      classNamingPatterns.push("BEM naming");
+    } else if (classCounts.modules > 5) {
+      cssArchitecture = "css-modules";
+      classNamingPatterns.push("CSS Modules");
+    }
+    return {
+      customProperties,
+      colors,
+      typography,
+      spacing,
+      borderRadii,
+      boxShadows,
+      cssArchitecture,
+      classNamingPatterns,
+      sampleClassNames: sampleClassNames.slice(0, 20)
+    };
+  });
+}
+async function collectLayoutTree(page, maxDepth = 6) {
+  return page.evaluate((maxD) => {
+    function walkNode(el, depth) {
+      if (depth > maxD) return null;
+      const cs = getComputedStyle(el);
+      if (cs.display === "none") return null;
+      const rect = el.getBoundingClientRect();
+      const tag = el.tagName.toLowerCase();
+      const dataAttributes = {};
+      for (const attr of el.attributes) {
+        if (attr.name.startsWith("data-")) dataAttributes[attr.name] = attr.value;
+      }
+      const children = [];
+      let childCount = 0;
+      for (const child of el.children) {
+        childCount++;
+        if (children.length < 20) {
+          const childNode = walkNode(child, depth + 1);
+          if (childNode) children.push(childNode);
+        }
+      }
+      const node = {
+        tag,
+        classList: Array.from(el.classList),
+        dataAttributes,
+        boundingRect: { x: Math.round(rect.x), y: Math.round(rect.y), width: Math.round(rect.width), height: Math.round(rect.height) },
+        display: cs.display,
+        position: cs.position,
+        children,
+        childCount
+      };
+      if (el.id) node.id = el.id;
+      if (el.getAttribute("role")) node.role = el.getAttribute("role");
+      if (el.getAttribute("aria-label")) node.ariaLabel = el.getAttribute("aria-label");
+      if (cs.display.includes("flex")) {
+        node.flexDirection = cs.flexDirection;
+        node.justifyContent = cs.justifyContent;
+        node.alignItems = cs.alignItems;
+      }
+      if (cs.display.includes("grid")) {
+        node.gridTemplateColumns = cs.gridTemplateColumns;
+        node.gridTemplateRows = cs.gridTemplateRows;
+        node.gap = cs.gap;
+      }
+      if (el.children.length === 0 && el.textContent) {
+        node.textContent = el.textContent.trim().slice(0, 100);
+      }
+      return node;
+    }
+    const body = document.body;
+    const tree = walkNode(body, 0) || {
+      tag: "body",
+      classList: [],
+      dataAttributes: {},
+      boundingRect: { x: 0, y: 0, width: 0, height: 0 },
+      display: "block",
+      position: "static",
+      children: [],
+      childCount: 0
+    };
+    let totalElements = 0;
+    function countDepth(node, d) {
+      totalElements++;
+      let max = d;
+      for (const child of node.children) {
+        max = Math.max(max, countDepth(child, d + 1));
+      }
+      return max;
+    }
+    const maxDepth2 = countDepth(tree, 0);
+    return {
+      viewport: { width: window.innerWidth, height: window.innerHeight },
+      scrollHeight: document.documentElement.scrollHeight,
+      tree,
+      totalElements,
+      maxDepth: maxDepth2
+    };
+  }, maxDepth);
+}
+async function collectAccessibility(page) {
+  return page.evaluate(() => {
+    function getSelector(el) {
+      if (el.id) return `#${el.id}`;
+      const tag = el.tagName.toLowerCase();
+      const cls = el.classList[0];
+      return cls ? `${tag}.${cls}` : tag;
+    }
+    const headings = [];
+    document.querySelectorAll("h1,h2,h3,h4,h5,h6").forEach((el) => {
+      headings.push({
+        level: parseInt(el.tagName[1]),
+        text: (el.textContent || "").trim().slice(0, 100),
+        selector: getSelector(el)
+      });
+    });
+    const landmarks = [];
+    const landmarkEls = document.querySelectorAll('nav,main,aside,header,footer,section[aria-label],form[aria-label],[role="navigation"],[role="main"],[role="complementary"],[role="banner"],[role="contentinfo"],[role="search"]');
+    landmarkEls.forEach((el) => {
+      const role = el.getAttribute("role") || el.tagName.toLowerCase();
+      const label = el.getAttribute("aria-label") || el.getAttribute("aria-labelledby") || void 0;
+      landmarks.push({ role, label, selector: getSelector(el) });
+    });
+    const formFields = [];
+    document.querySelectorAll("input,select,textarea").forEach((el) => {
+      const input = el;
+      const id = input.id;
+      const label = id ? document.querySelector(`label[for="${id}"]`)?.textContent?.trim() : void 0;
+      formFields.push({
+        tag: el.tagName.toLowerCase(),
+        type: input.type || void 0,
+        name: input.name || void 0,
+        label: label || input.getAttribute("aria-label") || input.placeholder || void 0,
+        required: input.required,
+        selector: getSelector(el)
+      });
+    });
+    const links = [];
+    document.querySelectorAll("a[href]").forEach((el) => {
+      if (links.length >= 50) return;
+      const a = el;
+      links.push({
+        tag: "a",
+        text: (a.textContent || "").trim().slice(0, 80),
+        href: a.getAttribute("href") || "",
+        selector: getSelector(el)
+      });
+    });
+    const buttons = [];
+    document.querySelectorAll('button,[role="button"],input[type="submit"],input[type="button"]').forEach((el) => {
+      buttons.push({
+        tag: el.tagName.toLowerCase(),
+        text: (el.textContent || el.value || "").trim().slice(0, 80),
+        role: el.getAttribute("role") || void 0,
+        selector: getSelector(el)
+      });
+    });
+    const images = [];
+    document.querySelectorAll("img").forEach((el) => {
+      const img = el;
+      images.push({
+        src: img.src,
+        alt: img.alt,
+        hasAlt: img.hasAttribute("alt") && img.alt.length > 0,
+        selector: getSelector(el)
+      });
+    });
+    const issues = [];
+    let prevLevel = 0;
+    for (const h of headings) {
+      if (h.level > prevLevel + 1 && prevLevel > 0) {
+        issues.push(`Heading level skip: h${prevLevel} \u2192 h${h.level}`);
+      }
+      prevLevel = h.level;
+    }
+    if (!landmarks.some((l) => l.role === "main")) {
+      issues.push("No <main> landmark found");
+    }
+    const missingAlt = images.filter((i) => !i.hasAlt);
+    if (missingAlt.length > 0) {
+      issues.push(`${missingAlt.length} image(s) missing alt text`);
+    }
+    return { headings, landmarks, formFields, links, buttons, images, issues };
+  });
+}
+async function collectFonts(page) {
+  return page.evaluate(() => {
+    const fontFaces = [];
+    try {
+      for (const face of document.fonts) {
+        fontFaces.push({
+          family: face.family.replace(/"/g, ""),
+          weight: face.weight,
+          style: face.style,
+          src: "",
+          // Not accessible from API
+          display: face.display || void 0
+        });
+      }
+    } catch {
+    }
+    try {
+      for (const sheet of document.styleSheets) {
+        try {
+          for (const rule of sheet.cssRules) {
+            if (rule instanceof CSSFontFaceRule) {
+              const style = rule.style;
+              const family = style.getPropertyValue("font-family").replace(/["']/g, "");
+              if (family && !fontFaces.some((f) => f.family === family && f.weight === style.getPropertyValue("font-weight"))) {
+                fontFaces.push({
+                  family,
+                  weight: style.getPropertyValue("font-weight") || "400",
+                  style: style.getPropertyValue("font-style") || "normal",
+                  src: style.getPropertyValue("src") || "",
+                  display: style.getPropertyValue("font-display") || void 0
+                });
+              }
+            }
+          }
+        } catch {
+        }
+      }
+    } catch {
+    }
+    const fontUsageMap = /* @__PURE__ */ new Map();
+    const elements = document.querySelectorAll("body *");
+    const limit = Math.min(elements.length, 200);
+    for (let i = 0; i < limit; i++) {
+      const el = elements[i];
+      const elRect = el.getBoundingClientRect();
+      if (elRect.width === 0 && elRect.height === 0) continue;
+      const cs = getComputedStyle(el);
+      const key = `${cs.fontFamily}|${cs.fontWeight}|${cs.fontStyle}`;
+      const entry = fontUsageMap.get(key) || { count: 0, selectors: /* @__PURE__ */ new Set() };
+      entry.count++;
+      const cls = el.getAttribute("class") || "";
+      const selector = el.tagName.toLowerCase() + (cls ? "." + cls.split(" ")[0] : "");
+      if (entry.selectors.size < 3) entry.selectors.add(selector);
+      fontUsageMap.set(key, entry);
+    }
+    const fontsUsed = Array.from(fontUsageMap.entries()).map(([key, data]) => {
+      const [family, weight, style] = key.split("|");
+      return {
+        family: family.split(",")[0].trim().replace(/["']/g, ""),
+        weight,
+        style,
+        usageCount: data.count,
+        sampleSelectors: Array.from(data.selectors)
+      };
+    }).sort((a, b) => b.usageCount - a.usageCount);
+    const strategies = [];
+    const hasPreload = document.querySelector('link[rel="preload"][as="font"]');
+    if (hasPreload) strategies.push("preloaded");
+    if (fontFaces.some((f) => f.display === "swap")) strategies.push("font-display: swap");
+    if (fontFaces.some((f) => f.src.includes("woff2"))) strategies.push("woff2");
+    const loadingStrategy = strategies.length > 0 ? strategies.join(" + ") : "default";
+    return { fontFaces, fontsUsed, iconFonts: [], loadingStrategy };
+  });
+}
+async function collectAssets(page) {
+  return page.evaluate(() => {
+    function getSelector(el) {
+      if (el.id) return `#${el.id}`;
+      const tag = el.tagName.toLowerCase();
+      const cls = el.classList[0];
+      return cls ? `${tag}.${cls}` : tag;
+    }
+    const images = [];
+    document.querySelectorAll("img").forEach((el) => {
+      const img = el;
+      const src = img.src;
+      const ext = src.split(".").pop()?.split("?")[0]?.toLowerCase() || "";
+      const format = { webp: "webp", png: "png", jpg: "jpeg", jpeg: "jpeg", gif: "gif", svg: "svg", avif: "avif" }[ext] || ext;
+      images.push({
+        src,
+        alt: img.alt,
+        width: img.width,
+        height: img.height,
+        naturalWidth: img.naturalWidth,
+        naturalHeight: img.naturalHeight,
+        format,
+        selector: getSelector(el)
+      });
+    });
+    const inlineSVGs = [];
+    document.querySelectorAll("svg").forEach((el) => {
+      const svg = el;
+      if (svg.closest("symbol") || svg.closest('[style*="display: none"]')) return;
+      const rect = svg.getBoundingClientRect();
+      if (rect.width === 0 && rect.height === 0) return;
+      inlineSVGs.push({
+        selector: getSelector(el),
+        viewBox: svg.getAttribute("viewBox") || "",
+        width: Math.round(rect.width),
+        height: Math.round(rect.height),
+        source: svg.outerHTML.slice(0, 500)
+      });
+    });
+    const svgSprites = [];
+    document.querySelectorAll("svg symbol[id]").forEach((el) => {
+      const symbol = el;
+      const id = symbol.id;
+      const refs = [];
+      document.querySelectorAll(`use[href="#${id}"],use[xlink\\:href="#${id}"]`).forEach((use) => {
+        refs.push(getSelector(use.closest("svg") || use));
+      });
+      svgSprites.push({
+        id,
+        viewBox: symbol.getAttribute("viewBox") || "",
+        paths: symbol.innerHTML.slice(0, 200),
+        referencedBy: refs
+      });
+    });
+    const backgroundSprites = [];
+    const bgSpriteMap = /* @__PURE__ */ new Map();
+    document.querySelectorAll("*").forEach((el) => {
+      const cs = getComputedStyle(el);
+      const bgImage = cs.backgroundImage;
+      if (!bgImage || bgImage === "none" || !bgImage.startsWith("url(")) return;
+      const bgPos = cs.backgroundPosition;
+      const bgSize = cs.backgroundSize;
+      if (bgSize === "cover" || bgSize === "contain" || bgSize === "auto") return;
+      const urlMatch = bgImage.match(/url\(["']?(.+?)["']?\)/);
+      if (!urlMatch) return;
+      const url = urlMatch[1];
+      const rect = el.getBoundingClientRect();
+      const posMatch = bgPos.match(/([-\d.]+)px\s+([-\d.]+)px/);
+      if (!posMatch) return;
+      const frames = bgSpriteMap.get(url) || [];
+      frames.push({
+        selector: getSelector(el),
+        cropX: Math.abs(parseFloat(posMatch[1])),
+        cropY: Math.abs(parseFloat(posMatch[2])),
+        cropWidth: Math.round(rect.width),
+        cropHeight: Math.round(rect.height)
+      });
+      bgSpriteMap.set(url, frames);
+    });
+    for (const [url, frames] of bgSpriteMap.entries()) {
+      if (frames.length >= 2) {
+        backgroundSprites.push({ sheetUrl: url, sheetWidth: 0, sheetHeight: 0, frames });
+      }
+    }
+    const totalAssets = images.length + inlineSVGs.length + svgSprites.length + backgroundSprites.reduce((s, b) => s + b.frames.length, 0);
+    return {
+      images,
+      inlineSVGs,
+      svgSprites,
+      backgroundSprites,
+      maskSprites: [],
+      iconFonts: [],
+      totalAssets
+    };
+  });
+}
+async function collectComputedStyles(page, selector, propertyFilter) {
+  return page.evaluate(
+    ({ sel, propFilter }) => {
+      const elements = document.querySelectorAll(sel);
+      if (elements.length === 0) {
+        return { selector: sel, propertyFilter: propFilter, entries: [] };
+      }
+      const DEFAULT_PROPS = [
+        "color",
+        "background-color",
+        "border-color",
+        "font-family",
+        "font-size",
+        "font-weight",
+        "font-style",
+        "line-height",
+        "letter-spacing",
+        "text-align",
+        "text-transform",
+        "text-decoration",
+        "display",
+        "position",
+        "top",
+        "right",
+        "bottom",
+        "left",
+        "width",
+        "height",
+        "min-width",
+        "max-width",
+        "min-height",
+        "max-height",
+        "margin-top",
+        "margin-right",
+        "margin-bottom",
+        "margin-left",
+        "padding-top",
+        "padding-right",
+        "padding-bottom",
+        "padding-left",
+        "gap",
+        "flex-direction",
+        "justify-content",
+        "align-items",
+        "flex-wrap",
+        "grid-template-columns",
+        "grid-template-rows",
+        "border-width",
+        "border-style",
+        "border-radius",
+        "box-shadow",
+        "text-shadow",
+        "opacity",
+        "overflow",
+        "z-index",
+        "transform",
+        "transition",
+        "background-image",
+        "background-size",
+        "cursor",
+        "pointer-events"
+      ];
+      const propsToCapture = propFilter && propFilter.length > 0 ? propFilter : DEFAULT_PROPS;
+      const allStyles = [];
+      const limit = Math.min(elements.length, 50);
+      for (let i = 0; i < limit; i++) {
+        const cs = getComputedStyle(elements[i]);
+        const styles = {};
+        for (const prop of propsToCapture) {
+          const val = cs.getPropertyValue(prop);
+          if (val) styles[prop] = val;
+        }
+        allStyles.push(styles);
+      }
+      const baseStyles = allStyles[0] || {};
+      const variations = [];
+      if (allStyles.length > 1) {
+        for (const prop of propsToCapture) {
+          const valueCounts = /* @__PURE__ */ new Map();
+          for (const s of allStyles) {
+            const val = s[prop] || "";
+            valueCounts.set(val, (valueCounts.get(val) || 0) + 1);
+          }
+          if (valueCounts.size > 1) {
+            variations.push({
+              property: prop,
+              values: Array.from(valueCounts.entries()).map(([value, count]) => ({ value, count })).sort((a, b) => b.count - a.count)
+            });
+          }
+        }
+      }
+      return {
+        selector: sel,
+        propertyFilter: propFilter,
+        entries: [{
+          selector: sel,
+          matchCount: elements.length,
+          styles: baseStyles,
+          variations
+        }]
+      };
+    },
+    { sel: selector, propFilter: propertyFilter }
+  );
+}
+async function collectElementSnapshot(page, selector, maxDepth = 5) {
+  return page.evaluate(
+    ({ sel, maxD }) => {
+      const rootEl = document.querySelector(sel);
+      if (!rootEl) return null;
+      const KEY_STYLES = [
+        "display",
+        "position",
+        "color",
+        "background-color",
+        "font-family",
+        "font-size",
+        "font-weight",
+        "line-height",
+        "width",
+        "height",
+        "margin",
+        "padding",
+        "border",
+        "flex-direction",
+        "justify-content",
+        "align-items",
+        "gap",
+        "grid-template-columns",
+        "grid-template-rows",
+        "border-radius",
+        "box-shadow",
+        "opacity",
+        "overflow",
+        "z-index"
+      ];
+      let totalNodes = 0;
+      function walk(el, depth) {
+        totalNodes++;
+        const rect = el.getBoundingClientRect();
+        const cs = getComputedStyle(el);
+        const attributes = {};
+        for (const attr of el.attributes) {
+          if (!["class", "id", "style"].includes(attr.name)) {
+            attributes[attr.name] = attr.value.slice(0, 200);
+          }
+        }
+        const computedStyles = {};
+        for (const prop of KEY_STYLES) {
+          const val = cs.getPropertyValue(prop);
+          if (val) computedStyles[prop] = val;
+        }
+        const children = [];
+        if (depth < maxD) {
+          const childLimit = Math.min(el.children.length, 30);
+          for (let i = 0; i < childLimit; i++) {
+            children.push(walk(el.children[i], depth + 1));
+          }
+        }
+        const node = {
+          tag: el.tagName.toLowerCase(),
+          classList: Array.from(el.classList),
+          attributes,
+          boundingRect: {
+            x: Math.round(rect.x),
+            y: Math.round(rect.y),
+            width: Math.round(rect.width),
+            height: Math.round(rect.height)
+          },
+          computedStyles,
+          children
+        };
+        if (el.id) node.id = el.id;
+        if (el.children.length === 0 && el.textContent) {
+          node.textContent = el.textContent.trim().slice(0, 200);
+        }
+        return node;
+      }
+      const root = walk(rootEl, 0);
+      return {
+        selector: sel,
+        depth: maxD,
+        totalNodes,
+        root
+      };
+    },
+    { sel: selector, maxD: maxDepth }
+  );
+}
+
+// src/scanner/event-builder.ts
+function makeEventId() {
+  return `evt-scan-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+}
+function buildReconEvents(url, title, sessionId, techResults, tokens, layout, a11y, fonts, assets, viewport, meta, scriptSrcs, stylesheetHrefs) {
+  const timestamp = Date.now();
+  const events = [];
+  const framework = techResults.find((t) => t.categories.some((c) => c.id === 12));
+  const metaFramework = techResults.find(
+    (t) => t.categories.some((c) => c.id === 18 || c.id === 57) && t.name !== framework?.name
+  );
+  const uiLib = techResults.find((t) => t.categories.some((c) => c.id === 66));
+  const buildTool = techResults.find(
+    (t) => t.categories.some((c) => c.id === 19) || t.name.match(/webpack|vite|parcel|turbopack|esbuild|rollup/i)
+  );
+  const hosting = techResults.find(
+    (t) => t.categories.some((c) => c.id === 62 || c.id === 31) || t.name.match(/vercel|netlify|cloudflare|aws|heroku/i)
+  );
+  function toDetection(result) {
+    if (!result) return { name: "unknown", confidence: "low", evidence: [] };
+    return {
+      name: result.name.toLowerCase(),
+      confidence: result.confidence >= 75 ? "high" : result.confidence >= 40 ? "medium" : "low",
+      version: result.version || void 0,
+      evidence: [`Detected by scanner (confidence: ${result.confidence}%)`]
+    };
+  }
+  const metadataEvent = {
+    eventId: makeEventId(),
+    sessionId,
+    timestamp,
+    eventType: "recon_metadata",
+    url,
+    title,
+    viewport,
+    documentLang: "",
+    // Not critical for this use case
+    metaTags: meta,
+    techStack: {
+      framework: toDetection(framework),
+      metaFramework: metaFramework ? toDetection(metaFramework) : void 0,
+      uiLibrary: uiLib ? toDetection(uiLib) : void 0,
+      buildTool: buildTool ? toDetection(buildTool) : void 0,
+      hosting: hosting ? toDetection(hosting) : void 0,
+      additional: techResults.filter((t) => t !== framework && t !== metaFramework && t !== uiLib && t !== buildTool && t !== hosting).slice(0, 20).map((t) => ({
+        name: t.name,
+        confidence: t.confidence >= 75 ? "high" : t.confidence >= 40 ? "medium" : "low",
+        version: t.version || void 0,
+        evidence: [`${t.categories.map((c) => c.name).join(", ")}`]
+      }))
+    },
+    externalStylesheets: stylesheetHrefs.map((href) => ({ href, crossOrigin: !href.startsWith(url) })),
+    externalScripts: scriptSrcs.map((src) => ({ src, async: false, defer: false, type: "text/javascript" })),
+    preloads: []
+  };
+  events.push(metadataEvent);
+  const designTokensEvent = {
+    eventId: makeEventId(),
+    sessionId,
+    timestamp,
+    eventType: "recon_design_tokens",
+    url,
+    ...tokens
+  };
+  events.push(designTokensEvent);
+  const layoutEvent = {
+    eventId: makeEventId(),
+    sessionId,
+    timestamp,
+    eventType: "recon_layout_tree",
+    url,
+    viewport: layout.viewport,
+    scrollHeight: layout.scrollHeight,
+    tree: layout.tree,
+    totalElements: layout.totalElements,
+    maxDepth: layout.maxDepth
+  };
+  events.push(layoutEvent);
+  const a11yEvent = {
+    eventId: makeEventId(),
+    sessionId,
+    timestamp,
+    eventType: "recon_accessibility",
+    url,
+    ...a11y
+  };
+  events.push(a11yEvent);
+  const fontsEvent = {
+    eventId: makeEventId(),
+    sessionId,
+    timestamp,
+    eventType: "recon_fonts",
+    url,
+    ...fonts
+  };
+  events.push(fontsEvent);
+  const assetsEvent = {
+    eventId: makeEventId(),
+    sessionId,
+    timestamp,
+    eventType: "recon_asset_inventory",
+    url,
+    ...assets
+  };
+  events.push(assetsEvent);
+  return events;
+}
+
+// src/scanner/index.ts
+var PlaywrightScanner = class _PlaywrightScanner {
+  db = null;
+  jsGlobalPaths = [];
+  domSelectors = [];
+  browser = null;
+  idleTimer = null;
+  static IDLE_TIMEOUT = 6e4;
+  // Close browser after 60s idle
+  lastScannedUrl = null;
+  /**
+   * Lazily load the technology database.
+   */
+  ensureDb() {
+    if (this.db) return this.db;
+    const __dirname = dirname(fileURLToPath(import.meta.url));
+    const possiblePaths = [
+      resolve(__dirname, "../../../node_modules/@runtimescope/extension/src/data"),
+      resolve(__dirname, "../../extension/src/data")
+    ];
+    let techData = null;
+    let catData = null;
+    for (const basePath of possiblePaths) {
+      try {
+        techData = JSON.parse(readFileSync(resolve(basePath, "technologies.json"), "utf-8"));
+        catData = JSON.parse(readFileSync(resolve(basePath, "categories.json"), "utf-8"));
+        break;
+      } catch {
+        continue;
+      }
+    }
+    if (!techData || !catData) {
+      throw new Error("Could not load technology database. Ensure @runtimescope/extension is built.");
+    }
+    this.db = new TechnologyDatabase(techData, catData);
+    const allTechs = this.db.getAll();
+    this.jsGlobalPaths = extractJsGlobalPaths(allTechs);
+    this.domSelectors = extractDomSelectors(allTechs);
+    console.error(`[RuntimeScope] Scanner loaded: ${this.db.size} technologies, ${this.jsGlobalPaths.length} JS paths, ${this.domSelectors.length} DOM selectors`);
+    return this.db;
+  }
+  /**
+   * Lazily launch or reuse a Chromium browser.
+   */
+  async ensureBrowser() {
+    if (this.idleTimer) {
+      clearTimeout(this.idleTimer);
+      this.idleTimer = null;
+    }
+    const pw = await import("playwright");
+    if (!this.browser || !this.browser.isConnected()) {
+      this.browser = await pw.chromium.launch({ headless: true });
+      console.error("[RuntimeScope] Scanner: Chromium launched");
+    }
+    this.idleTimer = setTimeout(() => {
+      this.shutdown().catch(() => {
+      });
+    }, _PlaywrightScanner.IDLE_TIMEOUT);
+    return { chromium: pw.chromium, browser: this.browser };
+  }
+  /**
+   * Scan a website: collect all signals, detect tech stack, build recon events.
+   */
+  async scan(url, options = {}) {
+    const startTime = Date.now();
+    const {
+      viewportWidth = 1280,
+      viewportHeight = 720,
+      waitFor = "networkidle",
+      timeout = 6e4
+    } = options;
+    const db = this.ensureDb();
+    const { browser } = await this.ensureBrowser();
+    const br = browser;
+    const context = await br.newContext({
+      viewport: { width: viewportWidth, height: viewportHeight },
+      userAgent: "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36"
+    });
+    const page = await context.newPage();
+    try {
+      let mainResponse = null;
+      page.on("response", (response) => {
+        if (!mainResponse && response.request().resourceType() === "document") {
+          mainResponse = response;
+        }
+      });
+      await page.goto(url, {
+        waitUntil: waitFor,
+        timeout
+      });
+      const title = await page.title();
+      const sessionId = `scan-${Date.now()}`;
+      const stylesheetHrefs = await page.evaluate(
+        () => Array.from(document.querySelectorAll('link[rel="stylesheet"]')).map((el) => el.getAttribute("href") || "")
+      );
+      const [signals, tokens, layout, a11y, fonts, assets] = await Promise.all([
+        collectDetectionSignals(page, mainResponse, this.jsGlobalPaths, this.domSelectors),
+        collectDesignTokens(page),
+        collectLayoutTree(page),
+        collectAccessibility(page),
+        collectFonts(page),
+        collectAssets(page)
+      ]);
+      const techStack = detect(signals, db);
+      const events = buildReconEvents(
+        url,
+        title,
+        sessionId,
+        techStack,
+        tokens,
+        layout,
+        a11y,
+        fonts,
+        assets,
+        { width: viewportWidth, height: viewportHeight },
+        signals.meta || {},
+        signals.scriptSrc || [],
+        stylesheetHrefs
+      );
+      const topTechs = techStack.slice(0, 10).map((t) => `${t.name}${t.version ? " " + t.version : ""} (${t.confidence}%)`);
+      const summaryParts = [
+        `Scanned: ${title || url}`,
+        `Tech stack: ${topTechs.join(", ") || "none detected"}`,
+        `Design: ${tokens.customProperties.length} CSS vars, ${tokens.colors.length} colors, ${tokens.typography.length} type combos`,
+        `Layout: ${layout.totalElements} elements, depth ${layout.maxDepth}`,
+        `Fonts: ${fonts.fontFaces.length} faces, ${fonts.fontsUsed.length} used`,
+        `Assets: ${assets.images.length} images, ${assets.inlineSVGs.length} SVGs, ${assets.totalAssets} total`,
+        `Accessibility: ${a11y.headings.length} headings, ${a11y.landmarks.length} landmarks, ${a11y.issues.length} issues`
+      ];
+      const scanDurationMs = Date.now() - startTime;
+      this.lastScannedUrl = page.url();
+      return {
+        url: page.url(),
+        title,
+        techStack,
+        events,
+        summary: summaryParts.join(". ") + `. Scan took ${scanDurationMs}ms.`,
+        scanDurationMs
+      };
+    } finally {
+      await context.close();
+    }
+  }
+  /**
+   * Get the last scanned URL (so tools know a scan was performed).
+   */
+  getLastScannedUrl() {
+    return this.lastScannedUrl;
+  }
+  /**
+   * On-demand: query computed styles for a selector on a previously scanned URL.
+   * Opens a fresh page, navigates, collects, closes.
+   */
+  async queryComputedStyles(url, selector, propertyFilter) {
+    const { browser } = await this.ensureBrowser();
+    const br = browser;
+    const context = await br.newContext({
+      viewport: { width: 1280, height: 720 }
+    });
+    const page = await context.newPage();
+    try {
+      await page.goto(url, { waitUntil: "networkidle", timeout: 6e4 });
+      return await collectComputedStyles(page, selector, propertyFilter);
+    } finally {
+      await context.close();
+    }
+  }
+  /**
+   * On-demand: query element snapshot for a selector on a previously scanned URL.
+   * Opens a fresh page, navigates, collects, closes.
+   */
+  async queryElementSnapshot(url, selector, depth = 5) {
+    const { browser } = await this.ensureBrowser();
+    const br = browser;
+    const context = await br.newContext({
+      viewport: { width: 1280, height: 720 }
+    });
+    const page = await context.newPage();
+    try {
+      await page.goto(url, { waitUntil: "networkidle", timeout: 6e4 });
+      return await collectElementSnapshot(page, selector, depth);
+    } finally {
+      await context.close();
+    }
+  }
+  /**
+   * Shutdown: close browser if open.
+   */
+  async shutdown() {
+    if (this.idleTimer) {
+      clearTimeout(this.idleTimer);
+      this.idleTimer = null;
+    }
+    if (this.browser) {
+      try {
+        await this.browser.close();
+      } catch {
+      }
+      this.browser = null;
+      console.error("[RuntimeScope] Scanner: Chromium closed");
+    }
+  }
+};
+
+// src/tools/scanner.ts
+import { z as z25 } from "zod";
+var COLLECTOR_PORT = process.env.RUNTIMESCOPE_PORT ?? "9090";
+var HTTP_PORT = process.env.RUNTIMESCOPE_HTTP_PORT ?? "9091";
+function registerScannerTools(server, store, scanner) {
+  server.tool(
+    "get_sdk_snippet",
+    "Generate a ready-to-paste code snippet to connect any web application to RuntimeScope for live runtime monitoring. Works with ANY tech stack \u2014 React, Vue, Angular, Svelte, plain HTML, Flask/Django templates, Rails ERB, PHP, WordPress, etc. Returns the appropriate installation method based on the project type.",
+    {
+      app_name: z25.string().optional().default("my-app").describe('Name for the app in RuntimeScope (e.g., "echo-frontend", "dashboard")'),
+      framework: z25.enum(["html", "react", "vue", "angular", "svelte", "nextjs", "nuxt", "flask", "django", "rails", "php", "wordpress", "other"]).optional().default("html").describe('The framework/tech stack of the project. Use "html" for any plain HTML or server-rendered pages.')
+    },
+    async ({ app_name, framework }) => {
+      const scriptTagSnippet = `<!-- RuntimeScope \u2014 paste before </body> -->
+<script src="http://localhost:${HTTP_PORT}/runtimescope.js"></script>
+<script>
+  RuntimeScope.init({
+    appName: '${app_name}',
+    endpoint: 'ws://localhost:${COLLECTOR_PORT}',
+  });
+</script>`;
+      const npmSnippet = `// npm install @runtimescope/sdk
+import { RuntimeScope } from '@runtimescope/sdk';
+
+RuntimeScope.init({
+  appName: '${app_name}',
+  endpoint: 'ws://localhost:${COLLECTOR_PORT}',
+});`;
+      const usesNpm = ["react", "vue", "angular", "svelte", "nextjs", "nuxt"].includes(framework);
+      const primarySnippet = usesNpm ? npmSnippet : scriptTagSnippet;
+      const placementHints = {
+        html: "Paste the <script> tags before </body> in your HTML file(s).",
+        react: "Add the import to your entry file (src/index.tsx or src/main.tsx), before ReactDOM.render/createRoot.",
+        vue: "Add the import to your entry file (src/main.ts), before createApp().",
+        angular: "Add the import to your main.ts, before bootstrapApplication().",
+        svelte: "Add the import to your entry file (src/main.ts), before new App().",
+        nextjs: "Add the import to your app/layout.tsx or pages/_app.tsx. For App Router, use a client component wrapper.",
+        nuxt: "Create a plugin file (plugins/runtimescope.client.ts) with the init call.",
+        flask: "Add the <script> tags to your base template (templates/base.html) before </body>.",
+        django: "Add the <script> tags to your base template (templates/base.html) before </body>.",
+        rails: "Add the <script> tags to your application layout (app/views/layouts/application.html.erb) before </body>.",
+        php: "Add the <script> tags to your layout/footer file before </body>.",
+        wordpress: "Add the <script> tags to your theme's footer.php before </body>, or use a custom HTML plugin.",
+        other: "Add the <script> tags to your HTML template before </body>. Works in any HTML page."
+      };
+      const response = {
+        summary: `SDK snippet for ${framework} project "${app_name}". ${usesNpm ? "Uses npm import." : "Uses <script> tag \u2014 no build system required."}`,
+        data: {
+          snippet: primarySnippet,
+          placement: placementHints[framework] || placementHints.other,
+          alternativeSnippet: usesNpm ? scriptTagSnippet : npmSnippet,
+          alternativeNote: usesNpm ? "If you prefer, you can also use a <script> tag instead of npm:" : "If the project uses npm/Node.js, you can also install via:",
+          requirements: [
+            "RuntimeScope MCP server must be running (it starts automatically with Claude Code)",
+            `SDK bundle served at http://localhost:${HTTP_PORT}/runtimescope.js`,
+            `WebSocket collector at ws://localhost:${COLLECTOR_PORT}`
+          ],
+          whatItCaptures: [
+            "Network requests (fetch/XHR) with timing and headers",
+            "Console logs, warnings, and errors with stack traces",
+            "React/Vue/Svelte component renders (if applicable)",
+            "State store changes (Redux, Zustand, Pinia)",
+            "Web Vitals (LCP, FCP, CLS, TTFB, INP)",
+            "Unhandled errors and promise rejections"
+          ]
+        },
+        issues: [],
+        metadata: { timeRange: { from: 0, to: 0 }, eventCount: 0, sessionId: null }
+      };
+      return {
+        content: [{ type: "text", text: JSON.stringify(response, null, 2) }]
+      };
+    }
+  );
+  server.tool(
+    "scan_website",
+    "Visit a website with a headless browser and extract comprehensive data: tech stack (7,221 technologies), design tokens (colors, typography, spacing, CSS variables), layout tree (DOM with bounding rects, flex/grid), accessibility structure, fonts, and asset inventory (images, SVGs, sprites). After scanning, all recon tools (get_design_tokens, get_layout_tree, get_font_info, etc.) will return data from the scanned page. This is the primary way to analyze any website.",
+    {
+      url: z25.string().describe('The full URL to scan (e.g., "https://stripe.com")'),
+      viewport_width: z25.number().optional().default(1280).describe("Viewport width in pixels (default: 1280)"),
+      viewport_height: z25.number().optional().default(720).describe("Viewport height in pixels (default: 720)"),
+      wait_for: z25.enum(["load", "networkidle", "domcontentloaded"]).optional().default("networkidle").describe("Wait condition before scanning (default: networkidle)")
+    },
+    async ({ url, viewport_width, viewport_height, wait_for }) => {
+      try {
+        const result = await scanner.scan(url, {
+          viewportWidth: viewport_width,
+          viewportHeight: viewport_height,
+          waitFor: wait_for
+        });
+        for (const event of result.events) {
+          store.addEvent(event);
+        }
+        const topTech = result.techStack.slice(0, 15).map((t) => ({
+          name: t.name,
+          version: t.version || void 0,
+          confidence: t.confidence,
+          categories: t.categories.map((c) => c.name)
+        }));
+        const issues = [];
+        if (result.techStack.length === 0) {
+          issues.push("No technologies detected \u2014 the page may use server-rendered HTML with no identifiable framework.");
+        }
+        const response = {
+          summary: result.summary,
+          data: {
+            url: result.url,
+            title: result.title,
+            techStack: topTech,
+            totalTechnologiesDetected: result.techStack.length,
+            eventsStored: result.events.length,
+            availableTools: [
+              "get_page_metadata \u2014 tech stack details",
+              "get_design_tokens \u2014 colors, typography, spacing, CSS variables",
+              "get_layout_tree \u2014 DOM structure with layout info",
+              "get_font_info \u2014 font faces and usage",
+              "get_accessibility_tree \u2014 headings, landmarks, forms",
+              "get_asset_inventory \u2014 images, SVGs, sprites",
+              "get_computed_styles \u2014 CSS values for specific selectors",
+              "get_element_snapshot \u2014 deep snapshot of an element",
+              "get_style_diff \u2014 compare styles between selectors"
+            ]
+          },
+          issues,
+          metadata: {
+            timeRange: { from: Date.now() - result.scanDurationMs, to: Date.now() },
+            eventCount: result.events.length,
+            sessionId: result.events[0]?.sessionId ?? null,
+            scanDurationMs: result.scanDurationMs
+          }
+        };
+        return {
+          content: [{ type: "text", text: JSON.stringify(response, null, 2) }]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        let hint = "";
+        if (message.includes("browserType.launch")) {
+          hint = " Ensure Chromium is installed: npx playwright install chromium";
+        } else if (message.includes("net::ERR_")) {
+          hint = " The URL may be unreachable or blocked.";
+        } else if (message.includes("Timeout")) {
+          hint = ' The page took too long to load. Try with wait_for: "load" instead of "networkidle".';
+        }
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({
+              summary: `Scan failed: ${message}${hint}`,
+              data: null,
+              issues: [`Scan error: ${message}${hint}`],
+              metadata: { timeRange: { from: 0, to: 0 }, eventCount: 0, sessionId: null }
+            }, null, 2)
+          }]
+        };
+      }
+    }
+  );
+}
+
+// src/tools/history.ts
+import { z as z26 } from "zod";
+var EVENT_TYPES = [
+  "network",
+  "console",
+  "session",
+  "state",
+  "render",
+  "dom_snapshot",
+  "performance",
+  "database",
+  "recon_metadata",
+  "recon_design_tokens",
+  "recon_fonts",
+  "recon_layout_tree",
+  "recon_accessibility",
+  "recon_computed_styles",
+  "recon_element_snapshot",
+  "recon_asset_inventory"
+];
+function parseDateParam(value) {
+  if (!value) return void 0;
+  const relMatch = value.match(/^(\d+)(m|h|d|w)$/);
+  if (relMatch) {
+    const amount = parseInt(relMatch[1], 10);
+    const unit = relMatch[2];
+    const ms = { m: 6e4, h: 36e5, d: 864e5, w: 6048e5 }[unit];
+    return Date.now() - amount * ms;
+  }
+  const num = Number(value);
+  if (!isNaN(num) && num > 1e12) return num;
+  const date = new Date(value);
+  if (!isNaN(date.getTime())) return date.getTime();
+  return void 0;
+}
+function registerHistoryTools(server, collector, projectManager) {
+  server.tool(
+    "get_historical_events",
+    "Query past events from persistent SQLite storage. Use this to access events beyond the in-memory buffer (last 10K events). Events persist across Claude Code restarts. Filter by project, event type, time range, and session.",
+    {
+      project: z26.string().describe("Project/app name (the appName used in SDK init)"),
+      event_types: z26.array(z26.enum(EVENT_TYPES)).optional().describe('Filter by event types (e.g., ["network", "console"])'),
+      since: z26.string().optional().describe('Start time \u2014 relative ("2h", "7d", "30m") or ISO date string'),
+      until: z26.string().optional().describe("End time \u2014 relative or ISO date string"),
+      session_id: z26.string().optional().describe("Filter by specific session ID"),
+      limit: z26.number().optional().default(200).describe("Max events to return (default 200, max 1000)"),
+      offset: z26.number().optional().default(0).describe("Pagination offset")
+    },
+    async ({ project, event_types, since, until, session_id, limit, offset }) => {
+      const sqliteStore = collector.getSqliteStore(project);
+      if (!sqliteStore) {
+        const projects = projectManager.listProjects();
+        const hint = projects.length > 0 ? ` Available projects: ${projects.join(", ")}` : " No projects have connected yet.";
+        return {
+          content: [{ type: "text", text: JSON.stringify({
+            summary: `No historical data for project "${project}".${hint}`,
+            data: null,
+            issues: [`Project "${project}" has no SQLite store. Connect an SDK with appName: "${project}" first.`],
+            metadata: { timeRange: { from: 0, to: 0 }, eventCount: 0, sessionId: null }
+          }, null, 2) }]
+        };
+      }
+      const sinceMs = parseDateParam(since);
+      const untilMs = parseDateParam(until);
+      const cappedLimit = Math.min(limit, 1e3);
+      const events = sqliteStore.getEvents({
+        project,
+        sessionId: session_id,
+        eventTypes: event_types,
+        since: sinceMs,
+        until: untilMs,
+        limit: cappedLimit,
+        offset
+      });
+      const totalCount = sqliteStore.getEventCount({
+        project,
+        sessionId: session_id,
+        eventTypes: event_types,
+        since: sinceMs,
+        until: untilMs
+      });
+      const timeRange = events.length > 0 ? { from: events[0].timestamp, to: events[events.length - 1].timestamp } : { from: 0, to: 0 };
+      const typeCounts = {};
+      for (const e of events) {
+        typeCounts[e.eventType] = (typeCounts[e.eventType] || 0) + 1;
+      }
+      const typeBreakdown = Object.entries(typeCounts).map(([type, count]) => `${type}: ${count}`).join(", ");
+      const response = {
+        summary: `${events.length} events returned (${totalCount} total matching). ${typeBreakdown || "No events."}${totalCount > cappedLimit + offset ? ` Use offset=${offset + cappedLimit} for next page.` : ""}`,
+        data: {
+          events,
+          pagination: {
+            returned: events.length,
+            total: totalCount,
+            limit: cappedLimit,
+            offset,
+            hasMore: offset + cappedLimit < totalCount
+          }
+        },
+        issues: [],
+        metadata: {
+          timeRange,
+          eventCount: events.length,
+          sessionId: session_id ?? null
+        }
+      };
+      return {
+        content: [{ type: "text", text: JSON.stringify(response, null, 2) }]
+      };
+    }
+  );
+  server.tool(
+    "list_projects",
+    "List all projects with stored historical data. Shows project names, event counts, session counts, and date ranges from SQLite persistence.",
+    {},
+    async () => {
+      const projectNames = projectManager.listProjects();
+      const projects = projectNames.map((name) => {
+        const sqliteStore = collector.getSqliteStore(name);
+        if (!sqliteStore) {
+          return {
+            name,
+            eventCount: 0,
+            sessionCount: 0,
+            isConnected: false,
+            note: "Project directory exists but no active SQLite store (SDK has not connected this session)"
+          };
+        }
+        const eventCount = sqliteStore.getEventCount({ project: name });
+        const sessions = sqliteStore.getSessions(name, 100);
+        const connectedSessions = sessions.filter((s) => s.isConnected);
+        return {
+          name,
+          eventCount,
+          sessionCount: sessions.length,
+          activeSessions: connectedSessions.length,
+          isConnected: connectedSessions.length > 0,
+          oldestSession: sessions.length > 0 ? new Date(sessions[sessions.length - 1].connectedAt).toISOString() : null,
+          newestSession: sessions.length > 0 ? new Date(sessions[0].connectedAt).toISOString() : null
+        };
+      });
+      const totalEvents = projects.reduce((s, p) => s + p.eventCount, 0);
+      const connectedCount = projects.filter((p) => p.isConnected).length;
+      const response = {
+        summary: `${projects.length} project(s), ${totalEvents} total events, ${connectedCount} currently connected.`,
+        data: projects,
+        issues: [],
+        metadata: {
+          timeRange: { from: 0, to: 0 },
+          eventCount: projects.length,
+          sessionId: null
+        }
+      };
+      return {
+        content: [{ type: "text", text: JSON.stringify(response, null, 2) }]
+      };
+    }
+  );
+}
+
+// src/index.ts
+var COLLECTOR_PORT2 = parseInt(process.env.RUNTIMESCOPE_PORT ?? "9090", 10);
+var HTTP_PORT2 = parseInt(process.env.RUNTIMESCOPE_HTTP_PORT ?? "9091", 10);
+var BUFFER_SIZE = parseInt(process.env.RUNTIMESCOPE_BUFFER_SIZE ?? "10000", 10);
+function killStaleProcess(port) {
+  try {
+    const pids = execSync2(`lsof -ti :${port} 2>/dev/null`, { encoding: "utf-8" }).trim();
+    if (pids) {
+      const myPid = process.pid.toString();
+      for (const pid of pids.split("\n")) {
+        if (pid && pid !== myPid) {
+          console.error(`[RuntimeScope] Killing stale process ${pid} on port ${port}`);
+          try {
+            process.kill(parseInt(pid, 10), "SIGTERM");
+          } catch {
+          }
+        }
+      }
+    }
+  } catch {
+  }
+}
+async function main() {
+  const projectManager = new ProjectManager();
+  projectManager.ensureGlobalDir();
+  const globalConfig = projectManager.getGlobalConfig();
+  const authManager = new AuthManager({
+    enabled: globalConfig.auth?.enabled ?? false,
+    apiKeys: globalConfig.auth?.apiKeys ?? []
+  });
+  const tlsConfig = resolveTlsConfig() ?? globalConfig.tls ?? void 0;
+  const redactor = new Redactor({
+    enabled: globalConfig.redaction?.enabled ?? false,
+    useBuiltIn: true,
+    rules: globalConfig.redaction?.rules?.map((r) => ({
+      name: r.name,
+      pattern: new RegExp(r.pattern, "gi"),
+      replacement: r.replacement
+    }))
+  });
+  const corsOrigins = process.env.RUNTIMESCOPE_CORS_ORIGINS?.split(",").map((s) => s.trim()) ?? globalConfig.corsOrigins;
+  if (authManager.isEnabled()) {
+    console.error(`[RuntimeScope] Auth enabled (${globalConfig.auth?.apiKeys?.length ?? 0} API keys)`);
+  }
+  if (tlsConfig) {
+    console.error(`[RuntimeScope] TLS enabled (cert: ${tlsConfig.certPath})`);
+  }
+  if (redactor.isEnabled()) {
+    console.error("[RuntimeScope] Payload redaction enabled");
+  }
+  killStaleProcess(COLLECTOR_PORT2);
+  killStaleProcess(HTTP_PORT2);
+  const collector = new CollectorServer({
+    bufferSize: BUFFER_SIZE,
+    projectManager,
+    authManager,
+    rateLimits: globalConfig.rateLimits,
+    tls: tlsConfig
+  });
+  await collector.start({ port: COLLECTOR_PORT2, maxRetries: 5, retryDelayMs: 1e3 });
+  const store = collector.getStore();
+  if (redactor.isEnabled()) {
+    store.setRedactor(redactor);
+  }
+  const apiDiscovery = new ApiDiscoveryEngine(store);
+  const connectionManager = new ConnectionManager();
+  const schemaIntrospector = new SchemaIntrospector();
+  const dataBrowser = new DataBrowser();
+  const processMonitor = new ProcessMonitor(store);
+  processMonitor.start();
+  const infraConnector = new InfraConnector(store);
+  const sqliteStores = collector.getSqliteStores();
+  const sessionManager = new SessionManager(projectManager, sqliteStores, store);
+  collector.onDisconnect((sessionId, projectName) => {
+    try {
+      sessionManager.createSnapshot(sessionId, projectName);
+      console.error(`[RuntimeScope] Session ${sessionId} metrics saved to SQLite`);
+    } catch {
+    }
+  });
+  const RETENTION_DAYS = parseInt(process.env.RUNTIMESCOPE_RETENTION_DAYS ?? "30", 10);
+  const cutoffMs = Date.now() - RETENTION_DAYS * 24 * 60 * 60 * 1e3;
+  for (const projectName of projectManager.listProjects()) {
+    const dbPath = projectManager.getProjectDbPath(projectName);
+    if (existsSync2(dbPath)) {
+      try {
+        const tempStore = new SqliteStore({ dbPath });
+        const deleted = tempStore.deleteOldEvents(cutoffMs);
+        if (deleted > 0) {
+          console.error(`[RuntimeScope] Pruned ${deleted} events older than ${RETENTION_DAYS}d from "${projectName}"`);
+        }
+        tempStore.close();
+      } catch {
+      }
+    }
+  }
+  const httpServer = new HttpServer(store, processMonitor, {
+    authManager,
+    allowedOrigins: corsOrigins
+  });
+  try {
+    await httpServer.start({ port: HTTP_PORT2, tls: tlsConfig });
+  } catch (err) {
+    console.error("[RuntimeScope] HTTP API failed to start:", err.message);
+  }
+  const scanner = new PlaywrightScanner();
+  const mcp = new McpServer({
+    name: "runtimescope",
+    version: "0.6.0"
+  });
+  registerNetworkTools(mcp, store);
+  registerConsoleTools(mcp, store);
+  registerSessionTools(mcp, store);
+  registerIssueTools(mcp, store, apiDiscovery, processMonitor);
+  registerTimelineTools(mcp, store);
+  registerStateTools(mcp, store);
+  registerRenderTools(mcp, store);
+  registerPerformanceTools(mcp, store);
+  registerDomSnapshotTools(mcp, store, collector);
+  registerHarTools(mcp, store);
+  registerErrorTools(mcp, store);
+  registerApiDiscoveryTools(mcp, store, apiDiscovery);
+  registerDatabaseTools(mcp, store, connectionManager, schemaIntrospector, dataBrowser);
+  registerProcessMonitorTools(mcp, processMonitor);
+  registerInfraTools(mcp, infraConnector);
+  registerSessionDiffTools(mcp, sessionManager);
+  registerReconMetadataTools(mcp, store, collector);
+  registerReconDesignTokenTools(mcp, store, collector);
+  registerReconFontTools(mcp, store);
+  registerReconLayoutTools(mcp, store, collector);
+  registerReconAccessibilityTools(mcp, store);
+  registerReconComputedStyleTools(mcp, store, collector, scanner);
+  registerReconElementSnapshotTools(mcp, store, collector, scanner);
+  registerReconAssetTools(mcp, store);
+  registerReconStyleDiffTools(mcp, store);
+  registerScannerTools(mcp, store, scanner);
+  registerHistoryTools(mcp, collector, projectManager);
+  const transport = new StdioServerTransport();
+  await mcp.connect(transport);
+  console.error("[RuntimeScope] MCP server running on stdio (v0.6.0 \u2014 46 tools)");
+  console.error(`[RuntimeScope] SDK snippet at http://127.0.0.1:${HTTP_PORT2}/snippet`);
+  console.error(`[RuntimeScope] SDK should connect to ws://127.0.0.1:${COLLECTOR_PORT2}`);
+  console.error(`[RuntimeScope] HTTP API at http://127.0.0.1:${HTTP_PORT2}`);
+  let shuttingDown = false;
+  const shutdown = async () => {
+    if (shuttingDown) return;
+    shuttingDown = true;
+    processMonitor.stop();
+    await scanner.shutdown();
+    await connectionManager.closeAll();
+    await httpServer.stop();
+    collector.stop();
+    process.exit(0);
+  };
+  process.on("SIGINT", () => {
+    shutdown();
+  });
+  process.on("SIGTERM", () => {
+    shutdown();
+  });
+  process.on("beforeExit", () => {
+    shutdown();
+  });
+  process.stdin.on("end", () => {
+    shutdown();
+  });
+  process.stdin.on("close", () => {
+    shutdown();
+  });
+}
+main().catch((err) => {
+  console.error("[RuntimeScope] Fatal error:", err);
+  process.exit(1);
+});
+//# sourceMappingURL=index.js.map