@runtimescope/mcp-server 0.9.1 → 0.9.2

package/dist/index.js

@@ -1,10 +1,10 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import { existsSync as existsSync2 } from "fs";
+import { existsSync as existsSync3 } from "fs";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { join as join2 } from "path";
+import { join as join3 } from "path";
 import {
   CollectorServer,
   ProjectManager,
@@ -2285,16 +2285,412 @@ function registerSessionDiffTools(server, sessionManager, collector, projectMana
   );
 }
 
-// src/tools/recon-metadata.ts
+// src/tools/qa-check.ts
 import { z as z17 } from "zod";
+import { detectIssues as detectIssues2 } from "@runtimescope/collector";
+function registerQaCheckTools(server, store, sessionManager, collector, apiDiscovery) {
+  server.tool(
+    "runtime_qa_check",
+    "Quick health check \u2014 snapshots the current session state and runs all issue detectors in one call. Use after making code changes to verify nothing is broken. Returns a snapshot (for later comparison) plus any detected issues. Combines create_session_snapshot + detect_issues into a single action.",
+    {
+      project_id: projectIdParam,
+      label: z17.string().optional().describe('Label for the snapshot (e.g., "after-fix", "pre-deploy", "baseline")'),
+      since_seconds: z17.number().optional().describe("Only detect issues from events in the last N seconds (default: all)")
+    },
+    async ({ project_id, label, since_seconds }) => {
+      const { sessionId } = resolveSessionContext(store, project_id);
+      if (!sessionId) {
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({
+              summary: "No active session found. Connect an SDK first.",
+              data: null,
+              issues: ["No active sessions \u2014 connect an SDK with RuntimeScope.init()"],
+              metadata: { timeRange: { from: 0, to: 0 }, eventCount: 0, sessionId: null, projectId: project_id ?? null }
+            }, null, 2)
+          }]
+        };
+      }
+      const projectName = collector.getProjectForSession(sessionId) ?? "default";
+      const snapshot = sessionManager.createSnapshot(sessionId, projectName, label ?? "qa-check");
+      const events = store.getAllEvents(since_seconds, void 0, project_id);
+      const allIssues = [...detectIssues2(events)];
+      if (apiDiscovery) {
+        try {
+          allIssues.push(...apiDiscovery.detectIssues());
+        } catch {
+        }
+      }
+      const severityOrder = { high: 0, medium: 1, low: 2 };
+      allIssues.sort((a, b) => (severityOrder[a.severity] ?? 2) - (severityOrder[b.severity] ?? 2));
+      const highCount = allIssues.filter((i) => i.severity === "high").length;
+      const medCount = allIssues.filter((i) => i.severity === "medium").length;
+      const lowCount = allIssues.filter((i) => i.severity === "low").length;
+      const issuesSummary = allIssues.length === 0 ? "No issues detected." : `${allIssues.length} issue(s): ${highCount} high, ${medCount} medium, ${lowCount} low.`;
+      const metricsSummary = [
+        `${snapshot.metrics.totalEvents} events`,
+        `${snapshot.metrics.errorCount} errors`,
+        `${Object.keys(snapshot.metrics.endpoints).length} endpoints`,
+        `${Object.keys(snapshot.metrics.components).length} components`
+      ].join(", ");
+      const webVitalsSummary = Object.entries(snapshot.metrics.webVitals).map(([name, v]) => `${name}: ${typeof v.value === "number" ? v.value.toFixed(1) : v.value} (${v.rating})`).join(", ");
+      const response = {
+        summary: `QA Check complete. Snapshot saved${label ? ` as "${label}"` : ""}. ${metricsSummary}. ${issuesSummary}`,
+        data: {
+          snapshot: {
+            id: snapshot.id,
+            sessionId: snapshot.sessionId,
+            project: snapshot.project,
+            label: snapshot.label ?? null,
+            createdAt: new Date(snapshot.createdAt).toISOString(),
+            metrics: {
+              totalEvents: snapshot.metrics.totalEvents,
+              errorCount: snapshot.metrics.errorCount,
+              endpointCount: Object.keys(snapshot.metrics.endpoints).length,
+              componentCount: Object.keys(snapshot.metrics.components).length,
+              webVitals: snapshot.metrics.webVitals,
+              queryCount: Object.keys(snapshot.metrics.queries).length
+            }
+          },
+          issues: allIssues.map((i) => ({
+            severity: i.severity,
+            pattern: i.pattern,
+            title: i.title,
+            description: i.description,
+            evidence: i.evidence,
+            suggestion: i.suggestion
+          })),
+          nextSteps: allIssues.length > 0 ? "Fix the issues above, then run runtime_qa_check again to compare. Use compare_sessions with the snapshot ID to see what changed." : "All clear! Use compare_sessions later to track regressions."
+        },
+        issues: allIssues.map((i) => `[${i.severity.toUpperCase()}] ${i.title}`),
+        metadata: {
+          timeRange: {
+            from: snapshot.metrics.connectedAt,
+            to: snapshot.metrics.disconnectedAt || Date.now()
+          },
+          eventCount: snapshot.metrics.totalEvents,
+          sessionId,
+          projectId: project_id ?? null,
+          webVitals: webVitalsSummary || null
+        }
+      };
+      return {
+        content: [{ type: "text", text: JSON.stringify(response, null, 2) }]
+      };
+    }
+  );
+}
+
+// src/tools/setup.ts
+import { z as z18 } from "zod";
+import { readFileSync, existsSync as existsSync2, writeFileSync } from "fs";
+import { join as join2, basename } from "path";
+import { homedir } from "os";
+import {
+  scaffoldProjectConfig
+} from "@runtimescope/collector";
+var COLLECTOR_PORT = process.env.RUNTIMESCOPE_PORT ?? "9090";
+var HTTP_PORT = process.env.RUNTIMESCOPE_HTTP_PORT ?? "9091";
+function detectFrameworks(projectDir) {
+  const detected = [];
+  let pkg = {};
+  try {
+    pkg = JSON.parse(readFileSync(join2(projectDir, "package.json"), "utf-8"));
+  } catch {
+  }
+  const allDeps = {
+    ...pkg.dependencies ?? {},
+    ...pkg.devDependencies ?? {}
+  };
+  if (existsSync2(join2(projectDir, "wrangler.toml")) || existsSync2(join2(projectDir, "wrangler.jsonc")) || allDeps["@cloudflare/workers-types"] || allDeps["wrangler"]) {
+    const entryFile = existsSync2(join2(projectDir, "src/index.ts")) ? "src/index.ts" : existsSync2(join2(projectDir, "src/index.js")) ? "src/index.js" : void 0;
+    detected.push({ framework: "workers", sdkType: "workers", entryFile, installCmd: "npm install @runtimescope/workers-sdk" });
+  }
+  if (allDeps["express"] || allDeps["fastify"] || allDeps["hono"] || allDeps["koa"]) {
+    detected.push({ framework: "other", sdkType: "server", installCmd: "npm install @runtimescope/server-sdk" });
+  }
+  if (allDeps["next"]) {
+    const entryFile = existsSync2(join2(projectDir, "app/providers.tsx")) ? "app/providers.tsx" : existsSync2(join2(projectDir, "src/app/providers.tsx")) ? "src/app/providers.tsx" : existsSync2(join2(projectDir, "app/layout.tsx")) ? "app/layout.tsx" : existsSync2(join2(projectDir, "pages/_app.tsx")) ? "pages/_app.tsx" : void 0;
+    detected.push({ framework: "nextjs", sdkType: "browser", entryFile, installCmd: "npm install @runtimescope/sdk" });
+    detected.push({ framework: "nextjs", sdkType: "server", installCmd: "npm install @runtimescope/server-sdk" });
+  } else if (allDeps["react"] || allDeps["react-dom"]) {
+    const entryFile = existsSync2(join2(projectDir, "src/main.tsx")) ? "src/main.tsx" : existsSync2(join2(projectDir, "src/index.tsx")) ? "src/index.tsx" : existsSync2(join2(projectDir, "src/main.jsx")) ? "src/main.jsx" : void 0;
+    detected.push({ framework: "react", sdkType: "browser", entryFile, installCmd: "npm install @runtimescope/sdk" });
+  } else if (allDeps["vue"]) {
+    const entryFile = existsSync2(join2(projectDir, "src/main.ts")) ? "src/main.ts" : void 0;
+    detected.push({ framework: "vue", sdkType: "browser", entryFile, installCmd: "npm install @runtimescope/sdk" });
+  } else if (allDeps["nuxt"]) {
+    detected.push({ framework: "nuxt", sdkType: "browser", installCmd: "npm install @runtimescope/sdk" });
+  } else if (allDeps["svelte"] || allDeps["@sveltejs/kit"]) {
+    detected.push({ framework: "svelte", sdkType: "browser", installCmd: "npm install @runtimescope/sdk" });
+  } else if (allDeps["@angular/core"]) {
+    detected.push({ framework: "angular", sdkType: "browser", installCmd: "npm install @runtimescope/sdk" });
+  }
+  if (existsSync2(join2(projectDir, "requirements.txt")) || existsSync2(join2(projectDir, "pyproject.toml"))) {
+    if (existsSync2(join2(projectDir, "manage.py"))) {
+      detected.push({ framework: "django", sdkType: "browser" });
+    } else {
+      detected.push({ framework: "flask", sdkType: "browser" });
+    }
+  }
+  if (existsSync2(join2(projectDir, "Gemfile"))) {
+    detected.push({ framework: "rails", sdkType: "browser" });
+  }
+  if (existsSync2(join2(projectDir, "composer.json"))) {
+    detected.push({ framework: "php", sdkType: "browser" });
+  }
+  if (existsSync2(join2(projectDir, "wp-config.php"))) {
+    detected.push({ framework: "wordpress", sdkType: "browser" });
+  }
+  if (detected.length === 0 && Object.keys(pkg).length > 0) {
+    detected.push({ framework: "html", sdkType: "browser", installCmd: "npm install @runtimescope/sdk" });
+  }
+  if (detected.length === 0) {
+    detected.push({ framework: "html", sdkType: "browser" });
+  }
+  return detected;
+}
+function generateSnippet(framework, sdkType, appName, projectId) {
+  const projectIdLine = `
+    projectId: '${projectId}',`;
+  if (sdkType === "workers") {
+    return {
+      snippet: `import { withRuntimeScope, scopeD1, scopeKV, scopeR2 } from '@runtimescope/workers-sdk';
+
+export default withRuntimeScope({
+  async fetch(request, env, ctx) {
+    // const db = scopeD1(env.DB);
+    // const kv = scopeKV(env.KV);
+    return yourApp.fetch(request, env, ctx);
+  },
+}, {
+  appName: '${appName}',${projectIdLine}
+  httpEndpoint: 'http://localhost:${HTTP_PORT}/api/events',
+});`,
+      placement: "Wrap your default export in the Worker entry file (src/index.ts).",
+      installCmd: "npm install @runtimescope/workers-sdk"
+    };
+  }
+  if (sdkType === "server") {
+    return {
+      snippet: `import { RuntimeScope } from '@runtimescope/server-sdk';
+
+RuntimeScope.connect({
+  appName: '${appName}',${projectIdLine}
+  captureConsole: true,
+  captureHttp: true,
+  capturePerformance: true,
+});
+
+// Instrument your ORM:
+// RuntimeScope.instrumentPrisma(prisma);
+// RuntimeScope.instrumentDrizzle(db);`,
+      placement: framework === "nextjs" ? "Add to instrumentation.ts (Next.js instrumentation hook)." : "Add to your server entry file before starting the server.",
+      installCmd: "npm install @runtimescope/server-sdk"
+    };
+  }
+  const usesNpm = ["react", "vue", "angular", "svelte", "nextjs", "nuxt"].includes(framework);
+  if (usesNpm) {
+    return {
+      snippet: `import { RuntimeScope } from '@runtimescope/sdk';
+
+RuntimeScope.init({
+  appName: '${appName}',${projectIdLine}
+  endpoint: 'ws://localhost:${COLLECTOR_PORT}',
+  capturePerformance: true,
+  captureRenders: true,
+});`,
+      placement: framework === "nextjs" ? "Add to app/providers.tsx (client component) or pages/_app.tsx." : framework === "react" ? "Add to src/main.tsx before createRoot()." : framework === "vue" ? "Add to src/main.ts before createApp()." : "Add to your entry file before the app initializes.",
+      installCmd: "npm install @runtimescope/sdk"
+    };
+  }
+  const placements = {
+    flask: "Add to templates/base.html before </body>.",
+    django: "Add to templates/base.html before </body>.",
+    rails: "Add to app/views/layouts/application.html.erb before </body>.",
+    php: "Add to your layout/footer file before </body>.",
+    wordpress: "Add to your theme's footer.php before </body>.",
+    html: "Add before </body> in your HTML files."
+  };
+  return {
+    snippet: `<script src="http://localhost:${HTTP_PORT}/runtimescope.js"></script>
+<script>
+  RuntimeScope.init({
+    appName: '${appName}',${projectIdLine}
+    endpoint: 'ws://localhost:${COLLECTOR_PORT}',
+  });
+</script>`,
+    placement: placements[framework] ?? placements.html
+  };
+}
+function checkAndRegisterHooks() {
+  const settingsPath = join2(homedir(), ".claude", "settings.json");
+  let settings = {};
+  try {
+    settings = JSON.parse(readFileSync(settingsPath, "utf-8"));
+  } catch {
+  }
+  const hooks = settings.hooks;
+  if (hooks?.PostToolUse) {
+    const existing = JSON.stringify(hooks.PostToolUse);
+    if (existing.includes("9091") || existing.includes("runtimescope")) {
+      return { registered: true, alreadyExists: true, message: "RuntimeScope hooks already registered." };
+    }
+  }
+  if (!settings.hooks) settings.hooks = {};
+  const h = settings.hooks;
+  if (!h.PostToolUse) h.PostToolUse = [];
+  h.PostToolUse.push({
+    matcher: ".*",
+    hooks: [{
+      type: "command",
+      command: `mkdir -p ~/.runtimescope/hooks && _RS_DIR=$(basename "$PWD") && _RS_PID=$(cat "$PWD/.runtimescope/config.json" 2>/dev/null | grep -o '"projectId":"[^"]*"' | cut -d'"' -f4) && echo '{"ts":'$(date +%s)',"tool":"'"$CLAUDE_TOOL_NAME"'","exit":"'"$CLAUDE_TOOL_EXIT_CODE"'","dir":"'"$_RS_DIR"'","projectId":"'"$_RS_PID"'"}' >> ~/.runtimescope/hooks/tool-events.jsonl && curl -s -X POST http://localhost:${HTTP_PORT}/api/events -H 'Content-Type: application/json' -d '{"sessionId":"claude-hooks","appName":"'"$_RS_DIR"'","events":[{"eventId":"hook-'$(date +%s%N)'","sessionId":"claude-hooks","timestamp":'$(date +%s000)',"eventType":"custom","name":"tool_use","properties":{"tool":"'"$CLAUDE_TOOL_NAME"'","exitCode":"'"$CLAUDE_TOOL_EXIT_CODE"'","projectId":"'"$_RS_PID"'"}}]}' >/dev/null 2>&1 &`
+    }]
+  });
+  try {
+    writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n", "utf-8");
+    return { registered: true, alreadyExists: false, message: "RuntimeScope hooks registered in ~/.claude/settings.json." };
+  } catch (err) {
+    return { registered: false, alreadyExists: false, message: `Failed to register hooks: ${err.message}` };
+  }
+}
+function registerSetupTools(server, store, collector, projectManager) {
+  server.tool(
+    "setup_project",
+    "Set up RuntimeScope in a project \u2014 detects framework, creates .runtimescope/config.json, generates SDK snippets, and registers Claude hooks. Returns everything needed to install the SDK in one call. Use this instead of manual setup steps.",
+    {
+      project_dir: z18.string().describe("Absolute path to the project root directory"),
+      app_name: z18.string().optional().describe("App name for RuntimeScope (defaults to directory name or package.json name)"),
+      register_hooks: z18.boolean().optional().default(true).describe("Register Claude Code hooks for tool timing (default: true)")
+    },
+    async ({ project_dir, app_name, register_hooks }) => {
+      const issues = [];
+      if (!existsSync2(project_dir)) {
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({
+              summary: `Directory not found: ${project_dir}`,
+              data: null,
+              issues: [`Project directory does not exist: ${project_dir}`],
+              metadata: { timeRange: { from: 0, to: 0 }, eventCount: 0, sessionId: null }
+            }, null, 2)
+          }]
+        };
+      }
+      let resolvedAppName = app_name;
+      if (!resolvedAppName) {
+        try {
+          const pkg = JSON.parse(readFileSync(join2(project_dir, "package.json"), "utf-8"));
+          resolvedAppName = pkg.name;
+        } catch {
+        }
+      }
+      if (!resolvedAppName) {
+        resolvedAppName = basename(project_dir);
+      }
+      const frameworks = detectFrameworks(project_dir);
+      const primaryFramework = frameworks[0];
+      const config = scaffoldProjectConfig(project_dir, {
+        appName: resolvedAppName,
+        framework: primaryFramework.framework,
+        sdkType: primaryFramework.sdkType
+      });
+      for (const fw of frameworks.slice(1)) {
+        if (!config.sdks.some((s) => s.type === fw.sdkType)) {
+          config.sdks.push({ type: fw.sdkType, framework: fw.framework, entryFile: fw.entryFile });
+        }
+      }
+      projectManager.ensureProjectDir(resolvedAppName);
+      projectManager.setProjectIdForApp(resolvedAppName, config.projectId);
+      const snippets = frameworks.map((fw) => ({
+        sdkType: fw.sdkType,
+        framework: fw.framework,
+        entryFile: fw.entryFile,
+        ...generateSnippet(fw.framework, fw.sdkType, resolvedAppName, config.projectId)
+      }));
+      const uniqueSnippets = snippets.filter((s, i, arr) => arr.findIndex((x) => x.sdkType === s.sdkType) === i);
+      const sessions = store.getSessionInfo();
+      const projectSessions = sessions.filter((s) => s.projectId === config.projectId || s.appName === resolvedAppName);
+      const isConnected = projectSessions.some((s) => s.isConnected);
+      let hookResult = { registered: false, alreadyExists: false, message: "Hooks not requested." };
+      if (register_hooks) {
+        hookResult = checkAndRegisterHooks();
+      }
+      const sdkInstalled = existsSync2(join2(project_dir, "node_modules", "@runtimescope"));
+      const phase = isConnected ? "connected" : sdkInstalled ? "installed_not_connected" : "awaiting_installation";
+      const nextSteps = [];
+      if (phase === "awaiting_installation") {
+        for (const s of uniqueSnippets) {
+          if (s.installCmd) nextSteps.push(`Run: ${s.installCmd}`);
+          nextSteps.push(`Add SDK init to ${s.entryFile ?? "your entry file"}: ${s.placement}`);
+        }
+        nextSteps.push("Start your app and verify with get_session_info");
+      } else if (phase === "installed_not_connected") {
+        nextSteps.push("Start your app to establish the WebSocket connection");
+        nextSteps.push("Verify with get_session_info");
+      }
+      if (!hookResult.alreadyExists && hookResult.registered) {
+        nextSteps.push("Hooks registered \u2014 tool timing will be tracked automatically");
+      }
+      const response = {
+        summary: phase === "connected" ? `${resolvedAppName} is set up and connected (${config.projectId}). ${projectSessions.length} active session(s).` : `${resolvedAppName} set up (${config.projectId}). ${uniqueSnippets.length} SDK snippet(s) generated. ${phase === "awaiting_installation" ? "Install the SDK to connect." : "Start your app to connect."}`,
+        data: {
+          phase,
+          project: {
+            projectId: config.projectId,
+            appName: resolvedAppName,
+            configPath: join2(project_dir, ".runtimescope", "config.json"),
+            frameworks: frameworks.map((f) => ({ framework: f.framework, sdkType: f.sdkType, entryFile: f.entryFile }))
+          },
+          snippets: uniqueSnippets.map((s) => ({
+            sdkType: s.sdkType,
+            framework: s.framework,
+            snippet: s.snippet,
+            placement: s.placement,
+            installCmd: s.installCmd,
+            entryFile: s.entryFile
+          })),
+          connection: {
+            connected: isConnected,
+            sessionCount: projectSessions.length,
+            sessions: projectSessions.map((s) => ({
+              sessionId: s.sessionId,
+              appName: s.appName,
+              sdkVersion: s.sdkVersion,
+              eventCount: s.eventCount
+            }))
+          },
+          hooks: hookResult,
+          sdkInstalled,
+          nextSteps
+        },
+        issues,
+        metadata: {
+          timeRange: { from: 0, to: Date.now() },
+          eventCount: 0,
+          sessionId: projectSessions[0]?.sessionId ?? null,
+          projectId: config.projectId
+        }
+      };
+      return {
+        content: [{ type: "text", text: JSON.stringify(response, null, 2) }]
+      };
+    }
+  );
+}
+
+// src/tools/recon-metadata.ts
+import { z as z19 } 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.",
     {
       project_id: projectIdParam,
-      url: z17.string().optional().describe("Filter by URL substring"),
-      force_refresh: z17.boolean().optional().default(false).describe("Send a recon_scan command to the extension to capture fresh data")
+      url: z19.string().optional().describe("Filter by URL substring"),
+      force_refresh: z19.boolean().optional().default(false).describe("Send a recon_scan command to the extension to capture fresh data")
     },
     async ({ project_id, url, force_refresh }) => {
       if (force_refresh) {
@@ -2376,16 +2772,16 @@ function registerReconMetadataTools(server, store, collector) {
 }
 
 // src/tools/recon-design-tokens.ts
-import { z as z18 } from "zod";
+import { z as z20 } 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.",
     {
       project_id: projectIdParam,
-      url: z18.string().optional().describe("Filter by URL substring"),
-      category: z18.enum(["all", "colors", "typography", "spacing", "custom_properties", "shadows"]).optional().default("all").describe("Return only a specific token category"),
-      force_refresh: z18.boolean().optional().default(false).describe("Send a recon_scan command to capture fresh data")
+      url: z20.string().optional().describe("Filter by URL substring"),
+      category: z20.enum(["all", "colors", "typography", "spacing", "custom_properties", "shadows"]).optional().default("all").describe("Return only a specific token category"),
+      force_refresh: z20.boolean().optional().default(false).describe("Send a recon_scan command to capture fresh data")
     },
     async ({ project_id, url, category, force_refresh }) => {
       if (force_refresh) {
@@ -2475,14 +2871,14 @@ function registerReconDesignTokenTools(server, store, collector) {
 }
 
 // src/tools/recon-fonts.ts
-import { z as z19 } from "zod";
+import { z as z21 } 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.",
     {
       project_id: projectIdParam,
-      url: z19.string().optional().describe("Filter by URL substring")
+      url: z21.string().optional().describe("Filter by URL substring")
     },
     async ({ project_id, url }) => {
       const event = store.getReconFonts({ url });
@@ -2534,17 +2930,17 @@ function registerReconFontTools(server, store) {
 }
 
 // src/tools/recon-layout.ts
-import { z as z20 } from "zod";
+import { z as z22 } 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.",
     {
       project_id: projectIdParam,
-      selector: z20.string().optional().describe('CSS selector to scope the tree (e.g., "nav", ".hero", "main"). Omit for full page.'),
-      max_depth: z20.number().optional().default(10).describe("Maximum depth of the tree to return (default 10)"),
-      url: z20.string().optional().describe("Filter by URL substring"),
-      force_refresh: z20.boolean().optional().default(false).describe("Request fresh capture from extension")
+      selector: z22.string().optional().describe('CSS selector to scope the tree (e.g., "nav", ".hero", "main"). Omit for full page.'),
+      max_depth: z22.number().optional().default(10).describe("Maximum depth of the tree to return (default 10)"),
+      url: z22.string().optional().describe("Filter by URL substring"),
+      force_refresh: z22.boolean().optional().default(false).describe("Request fresh capture from extension")
     },
     async ({ project_id, selector, max_depth, url, force_refresh }) => {
       if (force_refresh) {
@@ -2657,14 +3053,14 @@ function pruneTree(node, maxDepth, currentDepth = 0) {
 }
 
 // src/tools/recon-accessibility.ts
-import { z as z21 } from "zod";
+import { z as z23 } 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.",
     {
       project_id: projectIdParam,
-      url: z21.string().optional().describe("Filter by URL substring")
+      url: z23.string().optional().describe("Filter by URL substring")
     },
     async ({ project_id, url }) => {
       const event = store.getReconAccessibility({ url });
@@ -2731,7 +3127,7 @@ function registerReconAccessibilityTools(server, store) {
 }
 
 // src/tools/recon-computed-styles.ts
-import { z as z22 } from "zod";
+import { z as z24 } from "zod";
 var PROPERTY_GROUPS = {
   colors: [
     "color",
@@ -2836,10 +3232,10 @@ function registerReconComputedStyleTools(server, store, collector, scanner) {
     "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.",
     {
       project_id: projectIdParam,
-      selector: z22.string().describe('CSS selector to query (e.g., ".btn-primary", "nav > ul > li", "[data-testid=hero]")'),
-      properties: z22.enum(["all", "colors", "typography", "spacing", "layout", "borders", "visual"]).optional().default("all").describe('Property group to return, or "all" for everything'),
-      specific_properties: z22.array(z22.string()).optional().describe("Specific CSS property names to return (overrides the properties group)"),
-      force_refresh: z22.boolean().optional().default(false).describe("Request fresh capture from extension or scanner for this selector")
+      selector: z24.string().describe('CSS selector to query (e.g., ".btn-primary", "nav > ul > li", "[data-testid=hero]")'),
+      properties: z24.enum(["all", "colors", "typography", "spacing", "layout", "borders", "visual"]).optional().default("all").describe('Property group to return, or "all" for everything'),
+      specific_properties: z24.array(z24.string()).optional().describe("Specific CSS property names to return (overrides the properties group)"),
+      force_refresh: z24.boolean().optional().default(false).describe("Request fresh capture from extension or scanner for this selector")
     },
     async ({ project_id, selector, properties, specific_properties, force_refresh }) => {
       const propFilter = specific_properties ?? (properties !== "all" ? PROPERTY_GROUPS[properties] : void 0);
@@ -2950,16 +3346,16 @@ function registerReconComputedStyleTools(server, store, collector, scanner) {
 }
 
 // src/tools/recon-element-snapshot.ts
-import { z as z23 } from "zod";
+import { z as z25 } 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.',
     {
       project_id: projectIdParam,
-      selector: z23.string().describe('CSS selector for the root element (e.g., ".card", "#hero", "[data-testid=checkout-form]")'),
-      depth: z23.number().optional().default(5).describe("How many levels deep to capture children (default 5)"),
-      force_refresh: z23.boolean().optional().default(false).describe("Request fresh capture from extension or scanner for this element")
+      selector: z25.string().describe('CSS selector for the root element (e.g., ".card", "#hero", "[data-testid=checkout-form]")'),
+      depth: z25.number().optional().default(5).describe("How many levels deep to capture children (default 5)"),
+      force_refresh: z25.boolean().optional().default(false).describe("Request fresh capture from extension or scanner for this element")
     },
     async ({ project_id, selector, depth, force_refresh }) => {
       if (force_refresh) {
@@ -3044,15 +3440,15 @@ function registerReconElementSnapshotTools(server, store, collector, scanner) {
 }
 
 // src/tools/recon-assets.ts
-import { z as z24 } from "zod";
+import { z as z26 } 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.",
     {
       project_id: projectIdParam,
-      category: z24.enum(["all", "images", "svg", "sprites", "icon_fonts"]).optional().default("all").describe("Filter by asset category"),
-      url: z24.string().optional().describe("Filter by page URL substring")
+      category: z26.enum(["all", "images", "svg", "sprites", "icon_fonts"]).optional().default("all").describe("Filter by asset category"),
+      url: z26.string().optional().describe("Filter by page URL substring")
     },
     async ({ project_id, category, url }) => {
       const event = store.getReconAssetInventory({ url });
@@ -3143,7 +3539,7 @@ function registerReconAssetTools(server, store) {
 }
 
 // src/tools/recon-style-diff.ts
-import { z as z25 } from "zod";
+import { z as z27 } from "zod";
 var VISUAL_PROPERTIES = [
   "color",
   "background-color",
@@ -3188,10 +3584,10 @@ function registerReconStyleDiffTools(server, store) {
     "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.",
     {
       project_id: projectIdParam,
-      source_selector: z25.string().describe("CSS selector for the source/original element"),
-      target_selector: z25.string().describe("CSS selector for the target/recreation element"),
-      properties: z25.enum(["visual", "all"]).optional().default("visual").describe('"visual" compares only visually-significant properties (colors, typography, spacing, layout). "all" compares everything.'),
-      specific_properties: z25.array(z25.string()).optional().describe("Specific CSS property names to compare (overrides properties group)")
+      source_selector: z27.string().describe("CSS selector for the source/original element"),
+      target_selector: z27.string().describe("CSS selector for the target/recreation element"),
+      properties: z27.enum(["visual", "all"]).optional().default("visual").describe('"visual" compares only visually-significant properties (colors, typography, spacing, layout). "all" compares everything.'),
+      specific_properties: z27.array(z27.string()).optional().describe("Specific CSS property names to compare (overrides properties group)")
     },
     async ({ project_id, source_selector, target_selector, properties, specific_properties }) => {
       const events = store.getReconComputedStyles();
@@ -3305,7 +3701,7 @@ function parseNumericValue(value) {
 }
 
 // src/scanner/index.ts
-import { readFileSync } from "fs";
+import { readFileSync as readFileSync2 } from "fs";
 import { resolve, dirname } from "path";
 import { fileURLToPath } from "url";
 import { TechnologyDatabase, detect } from "@runtimescope/extension";
@@ -4256,8 +4652,8 @@ var PlaywrightScanner = class _PlaywrightScanner {
     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"));
+        techData = JSON.parse(readFileSync2(resolve(basePath, "technologies.json"), "utf-8"));
+        catData = JSON.parse(readFileSync2(resolve(basePath, "categories.json"), "utf-8"));
         break;
       } catch {
         continue;
@@ -4449,29 +4845,42 @@ var PlaywrightScanner = class _PlaywrightScanner {
 };
 
 // src/tools/scanner.ts
-import { z as z26 } from "zod";
-import { getOrCreateProjectId } from "@runtimescope/collector";
-var COLLECTOR_PORT = process.env.RUNTIMESCOPE_PORT ?? "9090";
-var HTTP_PORT = process.env.RUNTIMESCOPE_HTTP_PORT ?? "9091";
+import { z as z28 } from "zod";
+import { getOrCreateProjectId, scaffoldProjectConfig as scaffoldProjectConfig2, readProjectConfig as readProjectConfig2 } from "@runtimescope/collector";
+var COLLECTOR_PORT2 = process.env.RUNTIMESCOPE_PORT ?? "9090";
+var HTTP_PORT2 = process.env.RUNTIMESCOPE_HTTP_PORT ?? "9091";
 function registerScannerTools(server, store, scanner, projectManager) {
   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: z26.string().optional().default("my-app").describe('Name for the app in RuntimeScope (e.g., "echo-frontend", "dashboard")'),
-      framework: z26.enum(["html", "react", "vue", "angular", "svelte", "nextjs", "nuxt", "flask", "django", "rails", "php", "wordpress", "workers", "other"]).optional().default("html").describe('The framework/tech stack of the project. Use "html" for any plain HTML or server-rendered pages. Use "workers" for Cloudflare Workers.'),
-      project_id: z26.string().optional().describe("Existing project ID to use (proj_xxx). If omitted, one is auto-generated and persisted.")
+      app_name: z28.string().optional().default("my-app").describe('Name for the app in RuntimeScope (e.g., "echo-frontend", "dashboard")'),
+      framework: z28.enum(["html", "react", "vue", "angular", "svelte", "nextjs", "nuxt", "flask", "django", "rails", "php", "wordpress", "workers", "other"]).optional().default("html").describe('The framework/tech stack of the project. Use "html" for any plain HTML or server-rendered pages. Use "workers" for Cloudflare Workers.'),
+      project_id: z28.string().optional().describe("Existing project ID to use (proj_xxx). If omitted, one is auto-generated and persisted."),
+      project_dir: z28.string().optional().describe("Absolute path to the project root directory. If provided, creates .runtimescope/config.json with the project config.")
     },
-    async ({ app_name, framework, project_id }) => {
-      const resolvedProjectId = project_id ?? (projectManager ? getOrCreateProjectId(projectManager, app_name) : void 0);
+    async ({ app_name, framework, project_id, project_dir }) => {
+      let resolvedProjectId = project_id;
+      if (project_dir) {
+        const sdkType = framework === "workers" ? "workers" : ["flask", "django", "rails", "php", "wordpress"].includes(framework) ? "browser" : "browser";
+        const config = scaffoldProjectConfig2(project_dir, {
+          appName: app_name,
+          framework,
+          sdkType
+        });
+        resolvedProjectId = resolvedProjectId ?? config.projectId;
+      }
+      if (!resolvedProjectId) {
+        resolvedProjectId = projectManager ? getOrCreateProjectId(projectManager, app_name) : void 0;
+      }
       const projectIdLine = resolvedProjectId ? `
     projectId: '${resolvedProjectId}',` : "";
       const scriptTagSnippet = `<!-- RuntimeScope \u2014 paste before </body> -->
-<script src="http://localhost:${HTTP_PORT}/runtimescope.js"></script>
+<script src="http://localhost:${HTTP_PORT2}/runtimescope.js"></script>
 <script>
   RuntimeScope.init({
     appName: '${app_name}',${projectIdLine}
-    endpoint: 'ws://localhost:${COLLECTOR_PORT}',
+    endpoint: 'ws://localhost:${COLLECTOR_PORT2}',
   });
 </script>`;
       const npmSnippet = `// npm install @runtimescope/sdk
@@ -4479,7 +4888,7 @@ import { RuntimeScope } from '@runtimescope/sdk';
 
 RuntimeScope.init({
   appName: '${app_name}',${projectIdLine}
-  endpoint: 'ws://localhost:${COLLECTOR_PORT}',
+  endpoint: 'ws://localhost:${COLLECTOR_PORT2}',
 });`;
       const workersSnippet = `// npm install @runtimescope/workers-sdk
 import { withRuntimeScope, scopeD1, scopeKV, scopeR2, track, addBreadcrumb } from '@runtimescope/workers-sdk';
@@ -4501,7 +4910,7 @@ export default withRuntimeScope({
   },
 }, {
   appName: '${app_name}',${projectIdLine}
-  httpEndpoint: 'http://localhost:${HTTP_PORT}/api/events',
+  httpEndpoint: 'http://localhost:${HTTP_PORT2}/api/events',
   // captureConsole: true,    // Capture console.log/warn/error (default: true)
   // captureHeaders: false,   // Include request/response headers (default: false)
   // sampleRate: 1.0,         // 0.0-1.0 probabilistic sampling (default: 1.0)
@@ -4551,15 +4960,21 @@ export default withRuntimeScope({
           alternativeNote: isWorkers ? void 0 : 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: isWorkers ? [
             "RuntimeScope collector must be reachable from your Worker",
-            `HTTP collector endpoint at http://localhost:${HTTP_PORT}/api/events`,
+            `HTTP collector endpoint at http://localhost:${HTTP_PORT2}/api/events`,
             "Add nodejs_compat to compatibility_flags in wrangler.toml",
             "For production: set httpEndpoint to your hosted collector URL"
           ] : [
             "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}`
+            `SDK bundle served at http://localhost:${HTTP_PORT2}/runtimescope.js`,
+            `WebSocket collector at ws://localhost:${COLLECTOR_PORT2}`
           ],
-          whatItCaptures: isWorkers ? workersCaptures : browserCaptures
+          whatItCaptures: isWorkers ? workersCaptures : browserCaptures,
+          projectConfig: project_dir ? {
+            created: true,
+            path: `${project_dir}/.runtimescope/config.json`,
+            projectId: resolvedProjectId,
+            note: "Project config created. Commit .runtimescope/ to git to share settings across environments."
+          } : void 0
         },
         issues: [],
         metadata: { timeRange: { from: 0, to: 0 }, eventCount: 0, sessionId: null, projectId: resolvedProjectId ?? null }
@@ -4569,14 +4984,49 @@ export default withRuntimeScope({
       };
     }
   );
+  server.tool(
+    "get_project_config",
+    "Read the .runtimescope/config.json from a project directory. Returns the project ID, SDK entries, capture settings, and metadata. Use this to understand what RuntimeScope features are configured for a project.",
+    {
+      project_dir: z28.string().describe("Absolute path to the project root directory")
+    },
+    async ({ project_dir }) => {
+      const config = readProjectConfig2(project_dir);
+      if (!config) {
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({
+              summary: `No .runtimescope/config.json found in ${project_dir}. Run get_sdk_snippet with project_dir to create one, or use /setup.`,
+              data: null,
+              issues: ["No project config found. Create one with get_sdk_snippet or /setup."],
+              metadata: { timeRange: { from: 0, to: 0 }, eventCount: 0, sessionId: null }
+            }, null, 2)
+          }]
+        };
+      }
+      const sdkSummary = config.sdks.length > 0 ? config.sdks.map((s) => `${s.type}${s.framework ? ` (${s.framework})` : ""}`).join(", ") : "none installed";
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify({
+            summary: `Project "${config.appName}" (${config.projectId}). SDKs: ${sdkSummary}. Phase: ${config.phase ?? "not set"}.`,
+            data: config,
+            issues: [],
+            metadata: { timeRange: { from: 0, to: 0 }, eventCount: 0, sessionId: null, projectId: config.projectId }
+          }, 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: z26.string().describe('The full URL to scan (e.g., "https://stripe.com")'),
-      viewport_width: z26.number().optional().default(1280).describe("Viewport width in pixels (default: 1280)"),
-      viewport_height: z26.number().optional().default(720).describe("Viewport height in pixels (default: 720)"),
-      wait_for: z26.enum(["load", "networkidle", "domcontentloaded"]).optional().default("networkidle").describe("Wait condition before scanning (default: networkidle)")
+      url: z28.string().describe('The full URL to scan (e.g., "https://stripe.com")'),
+      viewport_width: z28.number().optional().default(1280).describe("Viewport width in pixels (default: 1280)"),
+      viewport_height: z28.number().optional().default(720).describe("Viewport height in pixels (default: 720)"),
+      wait_for: z28.enum(["load", "networkidle", "domcontentloaded"]).optional().default("networkidle").describe("Wait condition before scanning (default: networkidle)")
     },
     async ({ url, viewport_width, viewport_height, wait_for }) => {
       try {
@@ -4656,16 +5106,16 @@ export default withRuntimeScope({
 }
 
 // src/tools/custom-events.ts
-import { z as z27 } from "zod";
+import { z as z29 } from "zod";
 function registerCustomEventTools(server, store) {
   server.tool(
     "get_custom_events",
     "Get custom business/product events tracked via RuntimeScope.track(). Shows event catalog (all unique event names with counts) and recent occurrences. Use this to see what events are being tracked and their frequency.",
     {
       project_id: projectIdParam,
-      name: z27.string().optional().describe("Filter by event name (exact match)"),
-      since_seconds: z27.number().optional().describe("Only events from the last N seconds (default: 300)"),
-      session_id: z27.string().optional().describe("Filter by session ID")
+      name: z29.string().optional().describe("Filter by event name (exact match)"),
+      since_seconds: z29.number().optional().describe("Only events from the last N seconds (default: 300)"),
+      session_id: z29.string().optional().describe("Filter by session ID")
     },
     async ({ project_id, name, since_seconds, session_id }) => {
       const sinceSeconds = since_seconds ?? 300;
@@ -4726,9 +5176,9 @@ function registerCustomEventTools(server, store) {
     "Analyze a user flow as a funnel. Given an ordered list of custom event names (steps), shows how many sessions completed each step, where drop-offs happen, and what errors/failures occurred between steps. Each step includes correlated telemetry (network errors, console errors, failed DB queries) that happened between the previous step and this one \u2014 this is the key to finding WHY a step failed.",
     {
       project_id: projectIdParam,
-      steps: z27.array(z27.string()).min(2).describe('Ordered list of custom event names representing the flow (e.g. ["create_profile", "generate_campaign", "export_ad"])'),
-      since_seconds: z27.number().optional().describe("Only analyze events from the last N seconds (default: 3600)"),
-      session_id: z27.string().optional().describe("Analyze a specific session (default: all sessions)")
+      steps: z29.array(z29.string()).min(2).describe('Ordered list of custom event names representing the flow (e.g. ["create_profile", "generate_campaign", "export_ad"])'),
+      since_seconds: z29.number().optional().describe("Only analyze events from the last N seconds (default: 3600)"),
+      session_id: z29.string().optional().describe("Analyze a specific session (default: all sessions)")
     },
     async ({ project_id, steps, since_seconds, session_id }) => {
       const sinceSeconds = since_seconds ?? 3600;
@@ -4894,7 +5344,7 @@ function dedup(arr, limit) {
 }
 
 // src/tools/breadcrumbs.ts
-import { z as z28 } from "zod";
+import { z as z30 } from "zod";
 function eventToBreadcrumb(event, anchorTs) {
   const base = {
     timestamp: new Date(event.timestamp).toISOString(),
@@ -4986,12 +5436,12 @@ function registerBreadcrumbTools(server, store) {
     "Get the chronological trail of user actions, navigation, clicks, console logs, network requests, and state changes leading up to a point in time (or an error). This is the primary debugging context tool \u2014 use it when investigating errors, unexpected behavior, or user-reported issues.",
     {
       project_id: projectIdParam,
-      since_seconds: z28.number().optional().describe("How far back to look (default: 60 seconds)"),
-      session_id: z28.string().optional().describe("Filter to a specific session"),
-      before_timestamp: z28.number().optional().describe('Only show breadcrumbs before this Unix ms timestamp (useful for "what happened before this error")'),
-      categories: z28.array(z28.string()).optional().describe("Filter to specific categories: navigation, ui.click, breadcrumb, console.error, console.warn, console.log, http, state, custom.*"),
-      level: z28.enum(["debug", "info", "warning", "error"]).optional().describe("Minimum breadcrumb level to include (default: debug = show all)"),
-      limit: z28.number().optional().describe(`Max breadcrumbs to return (default/max: ${MAX_BREADCRUMBS})`)
+      since_seconds: z30.number().optional().describe("How far back to look (default: 60 seconds)"),
+      session_id: z30.string().optional().describe("Filter to a specific session"),
+      before_timestamp: z30.number().optional().describe('Only show breadcrumbs before this Unix ms timestamp (useful for "what happened before this error")'),
+      categories: z30.array(z30.string()).optional().describe("Filter to specific categories: navigation, ui.click, breadcrumb, console.error, console.warn, console.log, http, state, custom.*"),
+      level: z30.enum(["debug", "info", "warning", "error"]).optional().describe("Minimum breadcrumb level to include (default: debug = show all)"),
+      limit: z30.number().optional().describe(`Max breadcrumbs to return (default/max: ${MAX_BREADCRUMBS})`)
     },
     async ({ project_id, since_seconds, session_id, before_timestamp, categories, level, limit }) => {
       const sinceSeconds = since_seconds ?? 60;
@@ -5056,7 +5506,7 @@ function countCategories(breadcrumbs) {
 }
 
 // src/tools/history.ts
-import { z as z29 } from "zod";
+import { z as z31 } from "zod";
 var EVENT_TYPES = [
   "network",
   "console",
@@ -5095,14 +5545,14 @@ function registerHistoryTools(server, collector, projectManager) {
     "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: z29.string().optional().describe("Project/app name (the appName used in SDK init). Required unless project_id is provided."),
-      project_id: z29.string().optional().describe("Project ID (proj_xxx). Alternative to project name \u2014 resolves to the app name automatically."),
-      event_types: z29.array(z29.enum(EVENT_TYPES)).optional().describe('Filter by event types (e.g., ["network", "console"])'),
-      since: z29.string().optional().describe('Start time \u2014 relative ("2h", "7d", "30m") or ISO date string'),
-      until: z29.string().optional().describe("End time \u2014 relative or ISO date string"),
-      session_id: z29.string().optional().describe("Filter by specific session ID"),
-      limit: z29.number().optional().default(200).describe("Max events to return (default 200, max 1000)"),
-      offset: z29.number().optional().default(0).describe("Pagination offset")
+      project: z31.string().optional().describe("Project/app name (the appName used in SDK init). Required unless project_id is provided."),
+      project_id: z31.string().optional().describe("Project ID (proj_xxx). Alternative to project name \u2014 resolves to the app name automatically."),
+      event_types: z31.array(z31.enum(EVENT_TYPES)).optional().describe('Filter by event types (e.g., ["network", "console"])'),
+      since: z31.string().optional().describe('Start time \u2014 relative ("2h", "7d", "30m") or ISO date string'),
+      until: z31.string().optional().describe("End time \u2014 relative or ISO date string"),
+      session_id: z31.string().optional().describe("Filter by specific session ID"),
+      limit: z31.number().optional().default(200).describe("Max events to return (default 200, max 1000)"),
+      offset: z31.number().optional().default(0).describe("Pagination offset")
     },
     async ({ project, project_id, event_types, since, until, session_id, limit, offset }) => {
       const resolvedProject = project ?? (project_id ? projectManager.getAppForProjectId(project_id) : void 0);
@@ -5232,8 +5682,8 @@ function registerHistoryTools(server, collector, projectManager) {
 }
 
 // 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 COLLECTOR_PORT3 = parseInt(process.env.RUNTIMESCOPE_PORT ?? "9090", 10);
+var HTTP_PORT3 = parseInt(process.env.RUNTIMESCOPE_HTTP_PORT ?? "9091", 10);
 var BUFFER_SIZE = parseInt(process.env.RUNTIMESCOPE_BUFFER_SIZE ?? "10000", 10);
 function killStaleProcess(port) {
   try {
@@ -5279,8 +5729,8 @@ async function main() {
   if (redactor.isEnabled()) {
     console.error("[RuntimeScope] Payload redaction enabled");
   }
-  killStaleProcess(COLLECTOR_PORT2);
-  killStaleProcess(HTTP_PORT2);
+  killStaleProcess(COLLECTOR_PORT3);
+  killStaleProcess(HTTP_PORT3);
   const collector = new CollectorServer({
     bufferSize: BUFFER_SIZE,
     projectManager,
@@ -5288,7 +5738,7 @@ async function main() {
     rateLimits: globalConfig.rateLimits,
     tls: tlsConfig
   });
-  await collector.start({ port: COLLECTOR_PORT2, maxRetries: 5, retryDelayMs: 1e3 });
+  await collector.start({ port: COLLECTOR_PORT3, maxRetries: 5, retryDelayMs: 1e3 });
   const store = collector.getStore();
   if (redactor.isEnabled()) {
     store.setRedactor(redactor);
@@ -5328,7 +5778,7 @@ async function main() {
     const cutoffMs = Date.now() - RETENTION_DAYS * 24 * 60 * 60 * 1e3;
     for (const projectName of projectManager.listProjects()) {
       const dbPath = projectManager.getProjectDbPath(projectName);
-      if (existsSync2(dbPath)) {
+      if (existsSync3(dbPath)) {
         try {
           const tempStore = new SqliteStore({ dbPath });
           const deleted = tempStore.deleteOldEvents(cutoffMs);
@@ -5344,7 +5794,7 @@ async function main() {
   let pmStore;
   let discovery;
   if (isSqliteAvailable()) {
-    const pmDbPath = join2(projectManager.rootDir, "pm.db");
+    const pmDbPath = join3(projectManager.rootDir, "pm.db");
     pmStore = new PmStore({ dbPath: pmDbPath });
     discovery = new ProjectDiscovery(pmStore, projectManager);
     discovery.discoverAll().then((result) => {
@@ -5363,7 +5813,7 @@ async function main() {
     getConnectedSessions: () => collector.getConnectedSessions()
   });
   try {
-    await httpServer.start({ port: HTTP_PORT2, tls: tlsConfig });
+    await httpServer.start({ port: HTTP_PORT3, tls: tlsConfig });
   } catch (err) {
     console.error("[RuntimeScope] HTTP API failed to start:", err.message);
   }
@@ -5400,6 +5850,8 @@ async function main() {
   registerProcessMonitorTools(mcp, processMonitor);
   registerInfraTools(mcp, infraConnector);
   registerSessionDiffTools(mcp, sessionManager, collector, projectManager);
+  registerQaCheckTools(mcp, store, sessionManager, collector, apiDiscovery);
+  registerSetupTools(mcp, store, collector, projectManager);
   registerReconMetadataTools(mcp, store, collector);
   registerReconDesignTokenTools(mcp, store, collector);
   registerReconFontTools(mcp, store);
@@ -5416,9 +5868,9 @@ async function main() {
   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}`);
+  console.error(`[RuntimeScope] SDK snippet at http://127.0.0.1:${HTTP_PORT3}/snippet`);
+  console.error(`[RuntimeScope] SDK should connect to ws://127.0.0.1:${COLLECTOR_PORT3}`);
+  console.error(`[RuntimeScope] HTTP API at http://127.0.0.1:${HTTP_PORT3}`);
   let shuttingDown = false;
   const shutdown = async () => {
     if (shuttingDown) return;