@recapt/mcp 0.0.19-beta → 0.0.20-beta

package/dist/index.js

@@ -1,54 +1,3175 @@
 #!/usr/bin/env node
-/**
- * MCP Server entry point.
- *
- * Exposes recapt behavioral intelligence as tools for AI coding agents.
- * Uses a search_tools + call_tool pattern to minimize context while
- * providing access to 40+ analysis tools.
- *
- * Exposed tools (11):
- * - search_tools: Discover tools by intent
- * - call_tool: Execute discovered tools
- * - get_domains: List tracked domains
- * - run_full_diagnostic: Self-improvement entry point
- * - triage_sessions: Find sessions needing attention
- * - get_upgrade_options: Check available plan upgrades
- * - memory_save, memory_recall, memory_list, memory_delete, memory_clear
- *
- * Hidden tools (50+): Accessible via call_tool after discovery with search_tools
- */
+
+// src/index.ts
 import "dotenv/config";
-// @ts-ignore - MCP SDK types are complex
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-// @ts-ignore - MCP SDK types are complex
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { isApiConfigured, getApiUrl, allTools, hiddenTools, getDomainsTool, runFullDiagnosticTool, triageSessionsTool, getUpgradeOptionsTool, } from "@glimt/mcp-tools";
-import { registerSearchTools, registerCallTool, registerToolHandler, } from "./tools/catalog/index.js";
-import { registerMemoryTools } from "./tools/memory.js";
-// ─────────────────────────────────────────────────────────────────────────────
-// Tool Registration
-// ─────────────────────────────────────────────────────────────────────────────
-/**
- * Register a tool definition with the MCP server.
- * The MCP SDK accepts Zod schemas directly via .shape
- */
+
+// ../../libraries/mcp-tools/dist/client.js
+var DEFAULT_API_URL = "https://api.recapt.app";
+var REQUEST_TIMEOUT_MS = 12e4;
+var _config = {};
+function getApiUrl() {
+  return _config.apiUrl || process.env.RECAPT_API_URL || process.env.MCP_API_URL || process.env.EXTERNAL_API_URL || DEFAULT_API_URL;
+}
+function getSecretKey() {
+  return _config.secretKey || process.env.RECAPT_SECRET_KEY || process.env.MCP_SECRET_KEY;
+}
+function getOrganizationId() {
+  return _config.organizationId || process.env.MCP_ORGANIZATION_ID;
+}
+function isApiConfigured() {
+  return !!getSecretKey();
+}
+async function request(options) {
+  const { method, path, params, body } = options;
+  const secretKey = getSecretKey();
+  if (!secretKey) {
+    return { error: "RECAPT_SECRET_KEY not configured" };
+  }
+  const apiUrl = getApiUrl();
+  const url = new URL(`${apiUrl}/v1beta/query${path}`);
+  if (params) {
+    for (const [key, value] of Object.entries(params)) {
+      if (value !== void 0) {
+        url.searchParams.set(key, String(value));
+      }
+    }
+  }
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS);
+  const headers = {
+    "x-private-key": secretKey,
+    "Content-Type": "application/json"
+  };
+  const orgId = getOrganizationId();
+  if (orgId) {
+    headers["x-organization-id"] = orgId;
+  }
+  try {
+    const res = await fetch(url.toString(), {
+      method,
+      headers,
+      body: body ? JSON.stringify(body) : void 0,
+      signal: controller.signal
+    });
+    clearTimeout(timeout);
+    if (!res.ok) {
+      const errorBody = await res.json().catch(() => ({}));
+      return { error: errorBody.error || `HTTP ${res.status}` };
+    }
+    const data = await res.json();
+    return { data };
+  } catch (err) {
+    clearTimeout(timeout);
+    if (err instanceof Error && err.name === "AbortError") {
+      return { error: `Request timed out after ${REQUEST_TIMEOUT_MS / 1e3}s` };
+    }
+    return { error: err instanceof Error ? err.message : String(err) };
+  }
+}
+function apiGet(path, params) {
+  return request({ method: "GET", path, params });
+}
+function apiPost(path, body = {}) {
+  return request({ method: "POST", path, body });
+}
+function apiPatch(path, body = {}) {
+  return request({ method: "PATCH", path, body });
+}
+function apiDelete(path) {
+  return request({ method: "DELETE", path });
+}
+
+// ../../libraries/mcp-tools/dist/handlers.js
+function createApiHandler(method, endpoint, buildParams) {
+  return async (args) => {
+    if (!isApiConfigured()) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({ error: "API not configured" })
+          }
+        ],
+        isError: true
+      };
+    }
+    const url = typeof endpoint === "function" ? endpoint(args) : endpoint;
+    const params = buildParams ? buildParams(args) : args;
+    const apiCall = {
+      GET: () => apiGet(url, params),
+      POST: () => apiPost(url, params),
+      PATCH: () => apiPatch(url, params),
+      DELETE: () => apiDelete(url)
+    }[method];
+    const { data, error } = await apiCall();
+    if (error) {
+      return {
+        content: [{ type: "text", text: JSON.stringify({ error }) }],
+        isError: true
+      };
+    }
+    return { content: [{ type: "text", text: JSON.stringify(data) }] };
+  };
+}
+var toolHandlers = /* @__PURE__ */ new Map();
+function registerAllToolHandlers() {
+  toolHandlers.set("get_page_metrics", createApiHandler("GET", "/pages"));
+  toolHandlers.set("get_element_friction", createApiHandler("GET", "/elements"));
+  toolHandlers.set("get_page_trends", createApiHandler("GET", "/trends"));
+  toolHandlers.set("get_dead_clicks", createApiHandler("GET", "/dead-clicks"));
+  toolHandlers.set("get_console_errors", createApiHandler("GET", "/console-errors"));
+  toolHandlers.set("get_form_friction", createApiHandler("GET", "/forms/friction"));
+  toolHandlers.set("list_pages", createApiHandler("GET", "/pages/list"));
+  toolHandlers.set("scan_site", createApiHandler("GET", "/site/overview", (args) => ({
+    top_n: args.top_n ?? 10,
+    offset: args.offset ?? 0
+  })));
+  toolHandlers.set("get_ux_health_report", createApiHandler("GET", "/health-report"));
+  toolHandlers.set("analyze_flow", createApiHandler("POST", "/flows/analyze"));
+  toolHandlers.set("analyze_funnel", createApiHandler("POST", "/flows/funnel"));
+  toolHandlers.set("get_flow_friction", createApiHandler("GET", "/flow-friction"));
+  toolHandlers.set("get_journey_patterns", createApiHandler("GET", "/flows/patterns"));
+  toolHandlers.set("get_issues", createApiHandler("GET", "/issues"));
+  toolHandlers.set("get_actionable_issues", createApiHandler("GET", "/actionable-issues"));
+  toolHandlers.set("get_anomalies", createApiHandler("GET", "/anomalies"));
+  toolHandlers.set("detect_regressions", createApiHandler("GET", "/regressions"));
+  toolHandlers.set("detect_drift", createApiHandler("GET", "/drift"));
+  toolHandlers.set("compare_cohorts", createApiHandler("POST", "/cohorts/compare"));
+  toolHandlers.set("compare_periods", createApiHandler("POST", "/pages/compare-periods"));
+  toolHandlers.set("discover_personas", createApiHandler("GET", "/personas"));
+  toolHandlers.set("search_sessions", createApiHandler("POST", "/sessions/search"));
+  toolHandlers.set("list_sessions", createApiHandler("GET", "/sessions"));
+  toolHandlers.set("get_session_pages", async (args) => {
+    if (!isApiConfigured()) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({ error: "API not configured" })
+          }
+        ],
+        isError: true
+      };
+    }
+    const { session_id, session_ids } = args;
+    if (!session_id && (!session_ids || session_ids.length === 0)) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({
+              error: "Either session_id or session_ids must be provided"
+            })
+          }
+        ],
+        isError: true
+      };
+    }
+    const isSingleSession = session_id && !session_ids;
+    const { data, error } = isSingleSession ? await apiGet(`/sessions/${session_id}/pages`) : await apiPost("/sessions/pages", {
+      session_ids: session_ids ?? [session_id]
+    });
+    if (error) {
+      return {
+        content: [{ type: "text", text: JSON.stringify({ error }) }],
+        isError: true
+      };
+    }
+    return { content: [{ type: "text", text: JSON.stringify(data) }] };
+  });
+  toolHandlers.set("get_session_details", async (args) => {
+    if (!isApiConfigured()) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({ error: "API not configured" })
+          }
+        ],
+        isError: true
+      };
+    }
+    const { session_id, session_ids } = args;
+    if (!session_id && (!session_ids || session_ids.length === 0)) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({
+              error: "Either session_id or session_ids must be provided"
+            })
+          }
+        ],
+        isError: true
+      };
+    }
+    const isSingleSession = session_id && !session_ids;
+    const { data, error } = isSingleSession ? await apiGet(`/sessions/${session_id}`) : await apiPost("/sessions/details", {
+      session_ids: session_ids ?? [session_id]
+    });
+    if (error) {
+      return {
+        content: [{ type: "text", text: JSON.stringify({ error }) }],
+        isError: true
+      };
+    }
+    return { content: [{ type: "text", text: JSON.stringify(data) }] };
+  });
+  toolHandlers.set("predict_outcomes", createApiHandler("POST", "/predict"));
+  toolHandlers.set("run_full_diagnostic", createApiHandler("GET", "/diagnostic/full", (args) => ({
+    days: args.days ?? 7
+  })));
+  toolHandlers.set("investigate_issue", createApiHandler("GET", (args) => `/issues/${args.issue_id}/investigate`, (args) => ({ days: args.days ?? 7 })));
+  toolHandlers.set("validate_issue", createApiHandler("POST", (args) => `/issues/${args.issue_id}/validate`, (args) => ({ lookback_days: args.lookback_days ?? 3 })));
+  toolHandlers.set("dismiss_issue", createApiHandler("POST", (args) => `/issues/${args.issue_id}/dismiss`, (args) => ({
+    reason: args.reason,
+    explanation: args.explanation,
+    create_knowledge: args.create_knowledge ?? true
+  })));
+  toolHandlers.set("mark_intended_behavior", createApiHandler("POST", (args) => `/issues/${args.issue_id}/mark-intended`, (args) => ({ explanation: args.explanation })));
+  toolHandlers.set("get_issue_history", createApiHandler("GET", (args) => `/issues/${args.issue_id}/history`));
+  toolHandlers.set("propose_fix", createApiHandler("POST", "/remediations"));
+  toolHandlers.set("list_pending_fixes", createApiHandler("GET", "/remediations/pending"));
+  toolHandlers.set("list_remediations", createApiHandler("GET", "/remediations"));
+  toolHandlers.set("confirm_deployment", createApiHandler("PATCH", (args) => `/remediations/${args.remediation_id}/deploy`, () => ({})));
+  toolHandlers.set("evaluate_fix", createApiHandler("POST", (args) => `/remediations/${args.remediation_id}/evaluate`, (args) => ({ min_hours: args.min_hours ?? 24 })));
+  toolHandlers.set("get_fix_history", createApiHandler("GET", (args) => `/remediations/history/${args.issue_id}`));
+  toolHandlers.set("list_remediations_by_status", createApiHandler("GET", "/remediations/by-status"));
+  toolHandlers.set("get_remediation_by_pr", createApiHandler("GET", (args) => `/remediations/by-pr/${args.pr_number}`));
+  toolHandlers.set("update_remediation_status", createApiHandler("PATCH", (args) => `/remediations/${args.remediation_id}/status`));
+  toolHandlers.set("get_site_knowledge", createApiHandler("GET", "/knowledge"));
+  toolHandlers.set("add_site_knowledge", createApiHandler("POST", "/knowledge", (args) => ({
+    ...args,
+    source: "agent"
+  })));
+  toolHandlers.set("delete_site_knowledge", createApiHandler("DELETE", (args) => `/knowledge/${args.knowledge_id}`));
+  toolHandlers.set("get_similar_fixes", createApiHandler("GET", "/knowledge/similar-fixes"));
+  toolHandlers.set("start_improvement_run", createApiHandler("POST", "/improvement-runs"));
+  toolHandlers.set("update_improvement_run", createApiHandler("PATCH", (args) => `/improvement-runs/${args.run_id}`));
+  toolHandlers.set("record_improvement_action", createApiHandler("POST", (args) => `/improvement-runs/${args.run_id}/actions`));
+  toolHandlers.set("update_improvement_action", createApiHandler("PATCH", (args) => `/improvement-runs/${args.run_id}/actions/${args.action_id}`));
+  toolHandlers.set("get_improvement_run", createApiHandler("GET", (args) => `/improvement-runs/${args.run_id}`));
+  toolHandlers.set("list_improvement_runs", createApiHandler("GET", "/improvement-runs"));
+  toolHandlers.set("get_domains", createApiHandler("GET", "/domains"));
+  toolHandlers.set("triage_sessions", createApiHandler("GET", "/sessions/triage", (args) => {
+    const { session_ids, days, page_path, min_severity, limit } = args;
+    return {
+      session_ids: session_ids?.join(","),
+      days: session_ids?.length ? void 0 : days ?? 7,
+      page_path: session_ids?.length ? void 0 : page_path,
+      min_severity,
+      limit: session_ids?.length ? session_ids.length : limit ?? 20
+    };
+  }));
+  toolHandlers.set("get_upgrade_options", createApiHandler("GET", "/upgrade-options"));
+}
+registerAllToolHandlers();
+
+// ../../node_modules/zod-to-json-schema/dist/esm/selectParser.js
+import { ZodFirstPartyTypeKind as ZodFirstPartyTypeKind3 } from "zod/v3";
+
+// ../../node_modules/zod-to-json-schema/dist/esm/parsers/array.js
+import { ZodFirstPartyTypeKind } from "zod/v3";
+
+// ../../node_modules/zod-to-json-schema/dist/esm/parsers/record.js
+import { ZodFirstPartyTypeKind as ZodFirstPartyTypeKind2 } from "zod/v3";
+
+// ../../node_modules/zod-to-json-schema/dist/esm/parsers/string.js
+var ALPHA_NUMERIC = new Set("ABCDEFGHIJKLMNOPQRSTUVXYZabcdefghijklmnopqrstuvxyz0123456789");
+
+// ../../libraries/mcp-tools/dist/tools/analyzeFlow.js
+import { z } from "zod";
+
+// ../../libraries/mcp-tools/dist/tools/_utils.js
+function errorResult(message) {
+  return {
+    content: [{ type: "text", text: JSON.stringify({ error: message }) }],
+    isError: true
+  };
+}
+function successResult(data) {
+  return {
+    content: [{ type: "text", text: JSON.stringify(data) }]
+  };
+}
+function apiNotConfiguredResult() {
+  return errorResult("API not configured");
+}
+
+// ../../libraries/mcp-tools/dist/tools/analyzeFlow.js
+var analyzeFlowTool = {
+  name: "analyze_flow",
+  description: "Analyze user navigation flows between pages. Returns paths with steps, behavioral metrics (frustration, confusion), success rates, and bottlenecks. Use this to understand how users navigate between specific pages.",
+  inputSchema: z.object({
+    start_page: z.string().optional().describe("Starting page path (e.g., /pricing). Partial match supported."),
+    end_page: z.string().optional().describe("Ending page path (e.g., /checkout). Partial match supported."),
+    days: z.number().optional().default(7).describe("Number of days to analyze (default: 7)")
+  }),
+  handler: async (args) => {
+    const { start_page, end_page, days } = args;
+    if (!isApiConfigured()) {
+      return apiNotConfiguredResult();
+    }
+    if (!start_page && !end_page) {
+      return errorResult("At least one of start_page or end_page is required");
+    }
+    const { data, error } = await apiPost("/flows/analyze", {
+      start_page,
+      end_page,
+      days: days ?? 7
+    });
+    if (error) {
+      return errorResult(error);
+    }
+    return successResult(data);
+  }
+};
+
+// ../../libraries/mcp-tools/dist/tools/analyzeFunnel.js
+import { z as z2 } from "zod";
+var analyzeFunnelTool = {
+  name: "analyze_funnel",
+  description: 'Analyze a conversion funnel through a sequence of pages. Returns per-step metrics (entered, converted, dropped, dwell time, frustration, confusion) and dropoff analysis showing where users exit. Supports wildcards: "/checkout*" matches all checkout pages.',
+  inputSchema: z2.object({
+    steps: z2.array(z2.string()).min(2).describe('Ordered page paths forming the funnel (e.g., ["/cart", "/checkout", "/payment"])'),
+    days: z2.number().optional().default(7).describe("Number of days to analyze (default: 7)")
+  }),
+  handler: async (args) => {
+    const { steps, days } = args;
+    if (!isApiConfigured()) {
+      return apiNotConfiguredResult();
+    }
+    if (!steps || steps.length < 2) {
+      return errorResult("At least 2 steps are required for funnel analysis");
+    }
+    const { data, error } = await apiPost("/flows/funnel", {
+      steps,
+      days: days ?? 7
+    });
+    if (error) {
+      return errorResult(error);
+    }
+    return successResult(data);
+  }
+};
+
+// ../../libraries/mcp-tools/dist/tools/compareCohorts.js
+import { z as z3 } from "zod";
+var cohortFilterSchema = z3.object({
+  device: z3.enum(["desktop", "tablet", "mobile"]).optional().describe("Filter by device type"),
+  outcome: z3.enum(["COMPLETED", "STRUGGLED", "BLOCKED", "DISENGAGED"]).optional().describe("Filter by session outcome"),
+  pattern: z3.string().optional().describe("Filter by behavioral pattern"),
+  page_path: z3.string().optional().describe("Filter by page path"),
+  has_friction: z3.boolean().optional().describe("Filter for sessions with friction"),
+  has_rage_clicks: z3.boolean().optional().describe("Filter for sessions with rage clicks")
+});
+var compareCohortsTool = {
+  name: "compare_cohorts",
+  description: 'Compare two user cohorts side by side. Each cohort is defined by filter criteria: device (desktop/tablet/mobile), outcome (COMPLETED/STRUGGLED/BLOCKED/DISENGAGED), pattern, has_friction, has_rage_clicks, or page_path. Returns behavioral metrics for each cohort and statistically significant differences. Use this to answer "how do mobile users differ from desktop?", "what distinguishes users who complete vs abandon?", or "do form users struggle more than non-form users?"',
+  inputSchema: z3.object({
+    cohort_a: cohortFilterSchema.describe('Filters for cohort A, e.g. {"device": "mobile"} or {"outcome": "COMPLETED"}'),
+    cohort_b: cohortFilterSchema.describe('Filters for cohort B, e.g. {"device": "desktop"} or {"outcome": "BLOCKED"}'),
+    cohort_a_label: z3.string().optional().describe("Human label for cohort A"),
+    cohort_b_label: z3.string().optional().describe("Human label for cohort B"),
+    page_path: z3.string().optional().describe("Scope comparison to a specific page"),
+    date_from: z3.string().optional().describe("Start date (ISO format)"),
+    date_to: z3.string().optional().describe("End date (ISO format)")
+  }),
+  handler: async (args) => {
+    const { cohort_a, cohort_b, cohort_a_label, cohort_b_label, page_path, date_from, date_to } = args;
+    if (!isApiConfigured()) {
+      return apiNotConfiguredResult();
+    }
+    const { data, error } = await apiPost("/cohorts/compare", {
+      cohort_a,
+      cohort_b,
+      cohort_a_label,
+      cohort_b_label,
+      page_path,
+      date_from,
+      date_to
+    });
+    if (error) {
+      return errorResult(error);
+    }
+    return successResult(data);
+  }
+};
+
+// ../../libraries/mcp-tools/dist/tools/comparePeriods.js
+import { z as z4 } from "zod";
+var comparePeriodsTool = {
+  name: "compare_periods",
+  description: "Compare behavioral metrics between two time periods for a specific page. Returns metrics for each period and the deltas between them. Use this to measure the impact of changes or compare week-over-week performance.",
+  inputSchema: z4.object({
+    page_path: z4.string().describe("Page path to compare"),
+    period_a: z4.object({
+      from: z4.string().describe("Start date for period A (ISO format)"),
+      to: z4.string().describe("End date for period A (ISO format)")
+    }).describe("First time period"),
+    period_b: z4.object({
+      from: z4.string().describe("Start date for period B (ISO format)"),
+      to: z4.string().describe("End date for period B (ISO format)")
+    }).describe("Second time period")
+  }),
+  handler: async (args) => {
+    const { page_path, period_a, period_b } = args;
+    if (!isApiConfigured()) {
+      return apiNotConfiguredResult();
+    }
+    const { data, error } = await apiPost("/pages/compare-periods", {
+      page_path,
+      period_a,
+      period_b
+    });
+    if (error) {
+      return errorResult(error);
+    }
+    return successResult(data);
+  }
+};
+
+// ../../libraries/mcp-tools/dist/tools/detectDrift.js
+import { z as z5 } from "zod";
+var detectDriftTool = {
+  name: "detect_drift",
+  description: "Detect behavioral drift over time by analyzing how user behavior patterns change. Splits data into time windows and measures centroid shift between consecutive periods. Use this for long-term monitoring to detect gradual UX degradation.",
+  inputSchema: z5.object({
+    page_path: z5.string().optional().describe("Scope drift detection to a specific page"),
+    days: z5.number().optional().default(30).describe("Number of days to analyze (default 30)"),
+    window_size: z5.number().optional().default(7).describe("Size of each time window in days (default 7)")
+  }),
+  handler: async (args) => {
+    const { page_path, days, window_size } = args;
+    if (!isApiConfigured()) {
+      return apiNotConfiguredResult();
+    }
+    const { data, error } = await apiGet("/drift", {
+      page_path,
+      days: days ?? 30,
+      window_size: window_size ?? 7
+    });
+    if (error) {
+      return errorResult(error);
+    }
+    return successResult(data);
+  }
+};
+
+// ../../libraries/mcp-tools/dist/tools/detectRegressions.js
+import { z as z6 } from "zod";
+var detectRegressionsTool = {
+  name: "detect_regressions",
+  description: "Detect behavioral regressions by comparing recent data against rolling 7-day baselines. By default analyzes top 50 pages by traffic. Use sort_by='low_traffic' to check low-traffic pages that might otherwise be missed. Use offset/limit to paginate through all pages. Returns pages where frustration, confusion, or rage click rate have deviated significantly.",
+  inputSchema: z6.object({
+    window_hours: z6.number().optional().default(24).describe("How many recent hours to compare against baseline (default 24)"),
+    limit: z6.number().optional().default(50).describe("Number of pages to check per request (default 50, max 100)"),
+    offset: z6.number().optional().default(0).describe("Skip this many pages for pagination (default 0)"),
+    sort_by: z6.enum(["traffic", "low_traffic"]).optional().default("traffic").describe("Sort order: 'traffic' (default) or 'low_traffic' to check overlooked pages")
+  }),
+  handler: async (args) => {
+    const { window_hours, limit, offset, sort_by } = args;
+    if (!isApiConfigured()) {
+      return apiNotConfiguredResult();
+    }
+    const { data, error } = await apiGet("/regressions", {
+      window_hours: window_hours ?? 24,
+      limit: limit ?? 50,
+      offset: offset ?? 0,
+      sort_by: sort_by ?? "traffic"
+    });
+    if (error) {
+      return errorResult(error);
+    }
+    return successResult(data);
+  }
+};
+
+// ../../libraries/mcp-tools/dist/tools/diagnostic.js
+import { z as z7 } from "zod";
+var runFullDiagnosticTool = {
+  name: "run_full_diagnostic",
+  description: "Get a quick site health overview with prioritized issues and problem pages. This is a lightweight entry point \u2014 it does NOT include regression detection. For a complete analysis, call detect_regressions separately after this. Returns: health score, top issues, pages needing attention, and investigation order.",
+  inputSchema: z7.object({
+    days: z7.number().optional().default(7).describe("Number of days to analyze (default: 7)")
+  }),
+  handler: async (args) => {
+    const { days } = args;
+    if (!isApiConfigured()) {
+      return apiNotConfiguredResult();
+    }
+    const { data, error } = await apiGet("/diagnostic/full", {
+      days: days ?? 7
+    });
+    if (error) {
+      return errorResult(error);
+    }
+    return successResult(data);
+  }
+};
+var investigateIssueTool = {
+  name: "investigate_issue",
+  description: "Deep-dive into a specific issue. Returns affected sessions, element friction data, related console errors, similar issues, and page context. Use after identifying an issue to understand root cause. NOTE: Free tier users get issue summary and page context only. Detailed investigation data (affected sessions, element friction, related errors) requires a paid plan (Starter+).",
+  inputSchema: z7.object({
+    issue_id: z7.string().describe("The ID of the issue to investigate"),
+    days: z7.number().optional().default(7).describe("Number of days to look back (default: 7)")
+  }),
+  handler: async (args) => {
+    const { issue_id, days } = args;
+    if (!isApiConfigured()) {
+      return apiNotConfiguredResult();
+    }
+    const { data, error } = await apiGet(`/issues/${issue_id}/investigate`, {
+      days: days ?? 7
+    });
+    if (error) {
+      return errorResult(error);
+    }
+    return successResult(data);
+  }
+};
+var validateIssueTool = {
+  name: "validate_issue",
+  description: "Check if an issue is still actively occurring. Returns staleness info and recommendation (investigate, dismiss_stale, or monitor). Use to filter out stale issues before proposing fixes.",
+  inputSchema: z7.object({
+    issue_id: z7.string().describe("The ID of the issue to validate"),
+    lookback_days: z7.number().optional().default(3).describe("Number of days to look back for recent occurrences (default: 3)")
+  }),
+  handler: async (args) => {
+    const { issue_id, lookback_days } = args;
+    if (!isApiConfigured()) {
+      return apiNotConfiguredResult();
+    }
+    const { data, error } = await apiPost(`/issues/${issue_id}/validate`, {
+      lookback_days: lookback_days ?? 3
+    });
+    if (error) {
+      return errorResult(error);
+    }
+    return successResult(data);
+  }
+};
+
+// ../../libraries/mcp-tools/dist/tools/discoverPersonas.js
+import { z as z8 } from "zod";
+var discoverPersonasTool = {
+  name: "discover_personas",
+  description: "Discover behavioral personas - groups of users who behave similarly (e.g. confident completers, frustrated battlers, lost explorers). Returns rich profiles with descriptions, risk factors, and recommended interventions. Uses K-means clustering on behavioral embeddings. Optionally scope to a specific page.",
+  inputSchema: z8.object({
+    page_path: z8.string().optional().describe("Scope persona discovery to a specific page"),
+    num_personas: z8.number().optional().default(4).describe("Number of personas to discover (default 4, max 8)")
+  }),
+  handler: async (args) => {
+    const { page_path, num_personas } = args;
+    if (!isApiConfigured()) {
+      return apiNotConfiguredResult();
+    }
+    const { data, error } = await apiGet("/personas", {
+      page_path,
+      num_personas: num_personas ?? 4
+    });
+    if (error) {
+      return errorResult(error);
+    }
+    return successResult(data);
+  }
+};
+
+// ../../libraries/mcp-tools/dist/tools/getActionableIssues.js
+import { z as z9 } from "zod";
+var getActionableIssuesTool = {
+  name: "get_actionable_issues",
+  description: "Get UX issues with element context. Returns detected issues (rage clicks, dead clicks, errors, etc.) along with the most affected elements on each page. Use this when you want to understand and fix specific UX problems.",
+  inputSchema: z9.object({
+    page_path: z9.string().optional().describe("Filter to a specific page path (e.g., /checkout)"),
+    severity: z9.enum(["critical", "high", "medium", "low", "info"]).optional().describe("Minimum severity level to include"),
+    limit: z9.number().optional().default(10).describe("Maximum number of issues to return (default: 10)")
+  }),
+  handler: async (args) => {
+    const { page_path, severity, limit } = args;
+    if (!isApiConfigured()) {
+      return apiNotConfiguredResult();
+    }
+    const { data, error } = await apiGet("/actionable-issues", {
+      page_path,
+      severity,
+      limit: limit ?? 10
+    });
+    if (error) {
+      return errorResult(error);
+    }
+    return successResult(data);
+  }
+};
+
+// ../../libraries/mcp-tools/dist/tools/getAnomalies.js
+import { z as z10 } from "zod";
+var getAnomaliesTool = {
+  name: "get_anomalies",
+  description: "Detect anomalous sessions and frustration spikes. Finds sessions that deviate from normal behavior patterns.",
+  inputSchema: z10.object({
+    threshold: z10.number().optional().default(0.35).describe("Anomaly threshold (0-1, default: 0.35)"),
+    days: z10.number().optional().default(7).describe("Days to analyze for frustration spikes (default: 7)"),
+    page_path: z10.string().optional().describe("Optional: filter to a specific page")
+  }),
+  handler: async (args) => {
+    const { threshold, days, page_path } = args;
+    if (!isApiConfigured()) {
+      return apiNotConfiguredResult();
+    }
+    const { data, error } = await apiGet("/anomalies", {
+      threshold: threshold ?? 0.35,
+      days: days ?? 7,
+      page_path
+    });
+    if (error) {
+      return errorResult(error);
+    }
+    return successResult(data);
+  }
+};
+
+// ../../libraries/mcp-tools/dist/tools/getConsoleErrors.js
+import { z as z11 } from "zod";
+var getConsoleErrorsTool = {
+  name: "get_console_errors",
+  description: "Query JavaScript console errors and warnings from user sessions. Use this when you suspect page unresponsiveness, broken buttons, or rendering issues. Returns the most common errors grouped by message, with session impact counts. High rage clicks on root/body elements often correlate with JS errors.",
+  inputSchema: z11.object({
+    page_path: z11.string().optional().describe("Filter errors to a specific page path"),
+    session_id: z11.string().optional().describe("Filter errors to a specific session"),
+    severity: z11.enum(["error", "warn", "all"]).optional().default("error").describe('Filter by severity: "error" (default), "warn", or "all"'),
+    limit: z11.number().optional().default(200).describe("Max log documents to scan (default 200)")
+  }),
+  handler: async (args) => {
+    const { page_path, session_id, severity, limit } = args;
+    if (!isApiConfigured()) {
+      return apiNotConfiguredResult();
+    }
+    const { data, error } = await apiGet("/console-errors", {
+      page_path,
+      session_id,
+      severity: severity ?? "error",
+      limit: limit ?? 200
+    });
+    if (error) {
+      return errorResult(error);
+    }
+    return successResult(data);
+  }
+};
+
+// ../../libraries/mcp-tools/dist/tools/getDeadClicks.js
+import { z as z12 } from "zod";
+var getDeadClicksTool = {
+  name: "get_dead_clicks",
+  description: "Find buttons and links that users click but nothing happens (dead clicks). These are interactive elements where the click produced no visible DOM change. Use this to identify BROKEN or UNRESPONSIVE UI elements that frustrate users.",
+  inputSchema: z12.object({
+    page_path: z12.string().describe("Page path to check for dead clicks (required)")
+  }),
+  handler: async (args) => {
+    const { page_path } = args;
+    if (!isApiConfigured()) {
+      return apiNotConfiguredResult();
+    }
+    const { data, error } = await apiGet("/dead-clicks", {
+      page_path
+    });
+    if (error) {
+      return errorResult(error);
+    }
+    return successResult(data);
+  }
+};
+
+// ../../libraries/mcp-tools/dist/tools/getDomains.js
+import { z as z13 } from "zod";
+var getDomainsTool = {
+  name: "get_domains",
+  description: "Get the list of domains configured for the organization. Domains represent different websites or applications being tracked.",
+  inputSchema: z13.object({}),
+  handler: async () => {
+    if (!isApiConfigured()) {
+      return apiNotConfiguredResult();
+    }
+    const { data, error } = await apiGet("/domains");
+    if (error) {
+      return errorResult(error);
+    }
+    return successResult(data);
+  }
+};
+
+// ../../libraries/mcp-tools/dist/tools/getElementFriction.js
+import { z as z14 } from "zod";
+var getElementFrictionTool = {
+  name: "get_element_friction",
+  description: "Get per-element friction data for a page. Shows which elements cause user frustration, with click counts and dominant frustration signals.",
+  inputSchema: z14.object({
+    page_path: z14.string().describe("Page path to analyze (e.g., /checkout)"),
+    selector_filter: z14.string().optional().describe("Optional: filter elements by selector substring")
+  }),
+  handler: async (args) => {
+    const { page_path, selector_filter } = args;
+    if (!isApiConfigured()) {
+      return apiNotConfiguredResult();
+    }
+    const { data, error } = await apiGet("/elements", {
+      page_path,
+      selector_filter
+    });
+    if (error) {
+      return errorResult(error);
+    }
+    return successResult(data);
+  }
+};
+
+// ../../libraries/mcp-tools/dist/tools/getFlowFriction.js
+import { z as z15 } from "zod";
+var getFlowFrictionTool = {
+  name: "get_flow_friction",
+  description: "Discover user flows with behavioral metrics. Returns navigation transitions with frustration, confusion, and health scores for each page in the flow. Also flags backtrack hotspots (pages users return to) and dropoff pages. Use this to find which flows need optimization.",
+  inputSchema: z15.object({
+    page_path: z15.string().optional().describe("Focus on flows involving this page (e.g., /checkout)"),
+    days: z15.number().optional().default(7).describe("Number of days to analyze (default: 7)"),
+    limit: z15.number().optional().default(10).describe("Maximum number of flows to return (default: 10)")
+  }),
+  handler: async (args) => {
+    const { page_path, days, limit } = args;
+    if (!isApiConfigured()) {
+      return apiNotConfiguredResult();
+    }
+    const { data, error } = await apiGet("/flow-friction", {
+      page_path,
+      days: days ?? 7,
+      limit: limit ?? 10
+    });
+    if (error) {
+      return errorResult(error);
+    }
+    return successResult(data);
+  }
+};
+
+// ../../libraries/mcp-tools/dist/tools/getFormFriction.js
+import { z as z16 } from "zod";
+var getFormFrictionTool = {
+  name: "get_form_friction",
+  description: "Analyze which form fields cause friction on a page. Returns per-field metrics including dwell time, correction rate, and abandonment rate. Use this to identify problematic form fields in checkout, signup, or other forms.",
+  inputSchema: z16.object({
+    page_path: z16.string().describe("Page path containing the form to analyze (required)")
+  }),
+  handler: async (args) => {
+    const { page_path } = args;
+    if (!isApiConfigured()) {
+      return apiNotConfiguredResult();
+    }
+    const { data, error } = await apiGet("/forms/friction", {
+      page_path
+    });
+    if (error) {
+      return errorResult(error);
+    }
+    return successResult(data);
+  }
+};
+
+// ../../libraries/mcp-tools/dist/tools/getIssues.js
+import { z as z17 } from "zod";
+var VALID_CATEGORIES = [
+  "code_error",
+  "dead_click",
+  "rage_click",
+  "ux_friction",
+  "performance",
+  "form_issue",
+  "behavioral_anomaly",
+  "structural_issue"
+];
+var VALID_SEVERITIES = ["critical", "high", "medium", "low", "info"];
+var VALID_STATUSES = [
+  "pending",
+  "active",
+  "escalated",
+  "resolved",
+  "dismissed",
+  "expired"
+];
+var getIssuesTool = {
+  name: "get_issues",
+  description: "Get detected UX issues. Issues are automatically detected from session recordings and include rage clicks, dead clicks, form issues, and behavioral anomalies.",
+  inputSchema: z17.object({
+    page_path: z17.string().optional().describe("Filter issues to a specific page path"),
+    category: z17.enum(VALID_CATEGORIES).optional().describe("Filter by issue category"),
+    severity: z17.enum(VALID_SEVERITIES).optional().describe("Filter by severity level"),
+    status: z17.enum(VALID_STATUSES).optional().default("active").describe("Filter by status (default: active)"),
+    limit: z17.number().optional().default(20).describe("Maximum number of issues to return (default: 20)")
+  }),
+  handler: async (args) => {
+    const { page_path, category, severity, status, limit } = args;
+    if (!isApiConfigured()) {
+      return apiNotConfiguredResult();
+    }
+    const { data, error } = await apiGet("/issues", {
+      page_path,
+      category,
+      severity,
+      status: status ?? "active",
+      limit: limit ?? 20
+    });
+    if (error) {
+      return errorResult(error);
+    }
+    return successResult(data);
+  }
+};
+
+// ../../libraries/mcp-tools/dist/tools/getJourneyPatterns.js
+import { z as z18 } from "zod";
+var getJourneyPatternsTool = {
+  name: "get_journey_patterns",
+  description: "Discover navigation patterns across sessions. Returns top page transitions, backtrack hotspots (pages users return to), and dropoff pages (where sessions end). Use this to understand organic user navigation.",
+  inputSchema: z18.object({
+    page_path: z18.string().optional().describe("Filter to transitions involving this page (e.g., /pricing)"),
+    days: z18.number().optional().default(7).describe("Number of days to analyze (default: 7)")
+  }),
+  handler: async (args) => {
+    const { page_path, days } = args;
+    if (!isApiConfigured()) {
+      return apiNotConfiguredResult();
+    }
+    const { data, error } = await apiGet("/flows/patterns", {
+      page_path,
+      days: days ?? 7
+    });
+    if (error) {
+      return errorResult(error);
+    }
+    return successResult(data);
+  }
+};
+
+// ../../libraries/mcp-tools/dist/tools/getPageMetrics.js
+import { z as z19 } from "zod";
+var getPageMetricsTool = {
+  name: "get_page_metrics",
+  description: "Get aggregated behavioral metrics for a page. Returns frustration, confusion, confidence, energy scores, and health score. If page_path is omitted, returns metrics for all pages.",
+  inputSchema: z19.object({
+    page_path: z19.string().optional().describe("Page path to get metrics for (e.g., /checkout). Omit to get all pages."),
+    days: z19.number().optional().default(7).describe("Number of days to look back (default: 7)")
+  }),
+  handler: async (args) => {
+    const { page_path, days } = args;
+    if (!isApiConfigured()) {
+      return apiNotConfiguredResult();
+    }
+    const { data, error } = await apiGet("/pages", {
+      page_path,
+      days
+    });
+    if (error) {
+      return errorResult(error);
+    }
+    return successResult(data);
+  }
+};
+
+// ../../libraries/mcp-tools/dist/tools/getPageTrends.js
+import { z as z20 } from "zod";
+var getPageTrendsTool = {
+  name: "get_page_trends",
+  description: "Get daily behavioral trends for a page. Shows how frustration, confusion, and confidence change over time.",
+  inputSchema: z20.object({
+    page_path: z20.string().describe("Page path to analyze (e.g., /checkout)"),
+    days: z20.number().optional().default(14).describe("Number of days to look back (default: 14)")
+  }),
+  handler: async (args) => {
+    const { page_path, days } = args;
+    if (!isApiConfigured()) {
+      return apiNotConfiguredResult();
+    }
+    const { data, error } = await apiGet("/trends", {
+      page_path,
+      days: days ?? 14
+    });
+    if (error) {
+      return errorResult(error);
+    }
+    return successResult(data);
+  }
+};
+
+// ../../libraries/mcp-tools/dist/tools/getSessionDetails.js
+import { z as z21 } from "zod";
+var getSessionDetailsTool = {
+  name: "get_session_details",
+  description: "Get behavioral timeline for one or more sessions. Shows how frustration, confusion, and confidence evolved over time. Accepts a single session_id or an array of session_ids (max 20).",
+  inputSchema: z21.object({
+    session_id: z21.string().optional().describe("Single session ID to get details for"),
+    session_ids: z21.array(z21.string()).max(20).optional().describe("Array of session IDs to get details for (max 20)")
+  }),
+  handler: async (args) => {
+    const { session_id, session_ids } = args;
+    if (!isApiConfigured()) {
+      return apiNotConfiguredResult();
+    }
+    if (!session_id && (!session_ids || session_ids.length === 0)) {
+      return errorResult("Either session_id or session_ids must be provided");
+    }
+    if (session_id && !session_ids) {
+      const { data: data2, error: error2 } = await apiGet(`/sessions/${session_id}`);
+      if (error2) {
+        return errorResult(error2);
+      }
+      return successResult(data2);
+    }
+    const ids = session_ids ?? [session_id];
+    const { data, error } = await apiPost("/sessions/details", {
+      session_ids: ids
+    });
+    if (error) {
+      return errorResult(error);
+    }
+    return successResult(data);
+  }
+};
+
+// ../../libraries/mcp-tools/dist/tools/getSessionPages.js
+import { z as z22 } from "zod";
+var getSessionPagesTool = {
+  name: "get_session_pages",
+  description: "Get the pages visited within one or more sessions. Returns navigation history with timestamps, source pages, and dwell times. Use this to understand the user's journey through the site during a session. Accepts a single session_id or an array of session_ids (max 20).",
+  inputSchema: z22.object({
+    session_id: z22.string().optional().describe("Single session ID to get pages for"),
+    session_ids: z22.array(z22.string()).max(20).optional().describe("Array of session IDs to get pages for (max 20)")
+  }),
+  handler: async (args) => {
+    const { session_id, session_ids } = args;
+    if (!isApiConfigured()) {
+      return apiNotConfiguredResult();
+    }
+    if (!session_id && (!session_ids || session_ids.length === 0)) {
+      return errorResult("Either session_id or session_ids must be provided");
+    }
+    if (session_id && !session_ids) {
+      const { data: data2, error: error2 } = await apiGet(`/sessions/${session_id}/pages`);
+      if (error2) {
+        return errorResult(error2);
+      }
+      return successResult(data2);
+    }
+    const ids = session_ids ?? [session_id];
+    const { data, error } = await apiPost("/sessions/pages", {
+      session_ids: ids
+    });
+    if (error) {
+      return errorResult(error);
+    }
+    return successResult(data);
+  }
+};
+
+// ../../libraries/mcp-tools/dist/tools/getUxHealthReport.js
+import { z as z23 } from "zod";
+var getUxHealthReportTool = {
+  name: "get_ux_health_report",
+  description: "Get a comprehensive UX health report combining page metrics, issues, and anomalies. Returns overall health score, per-page breakdown, active issues, and frustration spikes. Use this as a starting point to understand overall UX state before diving deeper.",
+  inputSchema: z23.object({
+    page_path: z23.string().optional().describe("Focus on a specific page (omit for site-wide report)"),
+    days: z23.number().optional().default(7).describe("Number of days to analyze (default: 7)")
+  }),
+  handler: async (args) => {
+    const { page_path, days } = args;
+    if (!isApiConfigured()) {
+      return apiNotConfiguredResult();
+    }
+    const { data, error } = await apiGet("/health-report", {
+      page_path,
+      days: days ?? 7
+    });
+    if (error) {
+      return errorResult(error);
+    }
+    return successResult(data);
+  }
+};
+
+// ../../libraries/mcp-tools/dist/tools/upgradeOptions.js
+import { z as z24 } from "zod";
+function formatUpgradeOptions(data) {
+  const lines = [];
+  lines.push("# UPGRADE OPTIONS\n");
+  lines.push(`**Current Plan:** ${data.currentPlan.name} (${data.currentPlan.tag})
+`);
+  if (data.availableUpgrades.length === 0) {
+    lines.push("You're on the highest tier! No upgrades available.");
+    return lines.join("\n");
+  }
+  lines.push("## Available Upgrades\n");
+  for (const upgrade of data.availableUpgrades) {
+    lines.push(`### ${upgrade.name}
+`);
+    lines.push("**Features:**");
+    for (const feature of upgrade.features) {
+      lines.push(`- ${feature}`);
+    }
+    lines.push("");
+    lines.push("**Benefits:**");
+    for (const benefit of upgrade.benefits) {
+      lines.push(`- ${benefit}`);
+    }
+    lines.push("");
+  }
+  lines.push("---");
+  lines.push(`**Upgrade now:** ${data.upgradeUrl}`);
+  return lines.join("\n");
+}
+var getUpgradeOptionsTool = {
+  name: "get_upgrade_options",
+  description: "Get available upgrade options for the current plan. Use this when a user hits a feature limit or when you need to explain what's available on higher tiers. Returns the current plan, available upgrades with their features and benefits, and a direct link to the billing page. Use this to help users understand the value of upgrading when they encounter gated features.",
+  inputSchema: z24.object({}),
+  handler: async () => {
+    if (!isApiConfigured()) {
+      return apiNotConfiguredResult();
+    }
+    const { data, error } = await apiGet("/upgrade-options");
+    if (error) {
+      return errorResult(error);
+    }
+    const output = formatUpgradeOptions(data);
+    return { content: [{ type: "text", text: output }] };
+  }
+};
+
+// ../../libraries/mcp-tools/dist/tools/improvementRun.js
+import { z as z25 } from "zod";
+var startImprovementRunTool = {
+  name: "start_improvement_run",
+  description: "Register the start of a self-improvement workflow run. Call this at the beginning of an improvement session to track the run and its outcomes. Returns a run ID to use for subsequent updates.",
+  inputSchema: z25.object({
+    trigger_type: z25.enum(["github_actions", "cron", "manual", "api"]).describe("What triggered this improvement run"),
+    trigger_metadata: z25.record(z25.unknown()).optional().describe("Additional metadata about the trigger (e.g., GitHub run ID, branch, actor)"),
+    phases: z25.array(z25.object({
+      name: z25.string(),
+      status: z25.enum(["pending", "running", "completed", "skipped", "failed"]).default("pending")
+    })).optional().describe("Initial phases to track (e.g., diagnose, investigate, fix)")
+  }),
+  handler: async (args) => {
+    const { trigger_type, trigger_metadata, phases } = args;
+    if (!isApiConfigured()) {
+      return apiNotConfiguredResult();
+    }
+    const { data, error } = await apiPost("/improvement-runs", {
+      trigger_type,
+      trigger_metadata,
+      phases
+    });
+    if (error) {
+      return errorResult(error);
+    }
+    return successResult(data);
+  }
+};
+var updateImprovementRunTool = {
+  name: "update_improvement_run",
+  description: "Update an improvement run's status, phases, summary, or diagnostic data. Use to track progress through the workflow phases and record final outcomes.",
+  inputSchema: z25.object({
+    run_id: z25.string().describe("The ID of the improvement run to update"),
+    status: z25.enum(["running", "completed", "failed", "cancelled"]).optional().describe("New status for the run"),
+    title: z25.string().optional().describe("A concise title summarizing what was fixed in this run (e.g., 'Fixed checkout button, improved mobile nav'). Set when completing the run."),
+    phases: z25.array(z25.object({
+      name: z25.string(),
+      status: z25.enum([
+        "pending",
+        "running",
+        "completed",
+        "skipped",
+        "failed"
+      ]),
+      startedAt: z25.string().nullable().optional(),
+      completedAt: z25.string().nullable().optional(),
+      output: z25.record(z25.unknown()).optional()
+    })).optional().describe("Updated phases array"),
+    summary: z25.object({
+      issuesFound: z25.number().optional(),
+      issuesFixed: z25.number().optional(),
+      issuesDeferred: z25.number().optional(),
+      issuesDismissed: z25.number().optional(),
+      prsCreated: z25.number().optional()
+    }).optional().describe("Updated summary counts"),
+    diagnostic: z25.object({
+      healthScore: z25.number().describe("Site health score (0-100)"),
+      totalSessions: z25.number().describe("Number of sessions analyzed"),
+      pagesAnalyzed: z25.number().describe("Number of pages with data"),
+      summary: z25.string().nullable().optional().describe("1-2 sentence summary of the site's current state and key findings")
+    }).optional().describe("Diagnostic data from run_full_diagnostic. Set after diagnosis phase completes."),
+    completed_at: z25.string().optional().describe("ISO timestamp when the run completed"),
+    duration_ms: z25.number().optional().describe("Total duration of the run in milliseconds")
+  }),
+  handler: async (args) => {
+    const { run_id, status, title, phases, summary, diagnostic, completed_at, duration_ms } = args;
+    if (!isApiConfigured()) {
+      return apiNotConfiguredResult();
+    }
+    const { data, error } = await apiPatch(`/improvement-runs/${run_id}`, {
+      status,
+      title,
+      phases,
+      summary,
+      diagnostic,
+      completed_at,
+      duration_ms
+    });
+    if (error) {
+      return errorResult(error);
+    }
+    return successResult(data);
+  }
+};
+var recordImprovementActionTool = {
+  name: "record_improvement_action",
+  description: "Record an action taken during an improvement run. Use to track what was done for each issue: code fixes, deferrals, dismissals, etc. IMPORTANT: When recording code_fix actions, the code_changes.diff field must contain ACTUAL SOURCE CODE in unified diff format, not a description of what changed. Include the literal code lines with proper +/- prefixes.",
+  inputSchema: z25.object({
+    run_id: z25.string().describe("The ID of the improvement run"),
+    issue_id: z25.string().optional().describe("The ID of the issue this action relates to (if any)"),
+    action_type: z25.enum([
+      "code_fix",
+      "needs_more_data",
+      "dismissed",
+      "marked_intended",
+      "knowledge_added"
+    ]).describe("Type of action taken"),
+    hypothesis: z25.string().describe("AI's reasoning for this action"),
+    expected_improvement: z25.string().describe("What improvement is expected from this action"),
+    code_changes: z25.array(z25.object({
+      file: z25.string().describe("Path to the changed file"),
+      diff: z25.string().describe("Unified diff format code changes"),
+      startLine: z25.number().describe("Line number where the diff begins"),
+      linesAdded: z25.number().default(0).describe("Count of lines added"),
+      linesRemoved: z25.number().default(0).describe("Count of lines removed")
+    })).optional().describe("Array of code changes with actual source code diffs"),
+    pr_url: z25.string().optional().describe("GitHub PR URL if a PR was created"),
+    pr_number: z25.number().optional().describe("GitHub PR number"),
+    remediation_id: z25.string().optional().describe("ID of the associated remediation record (if any)"),
+    deferral_reason: z25.string().optional().describe("Explanation for why the issue was deferred (for needs_more_data actions)"),
+    dismissal_reason: z25.string().optional().describe("Explanation for why the issue was dismissed (for dismissed/marked_intended actions)"),
+    page_path: z25.string().optional().describe("Page path affected by the fix"),
+    element_selector: z25.string().optional().describe("CSS selector of the affected element"),
+    diagnosis: z25.string().optional().describe("Root cause analysis"),
+    proposed_fix: z25.string().optional().describe("Fix description"),
+    confidence: z25.number().min(0).max(1).optional().describe("Fix confidence 0-1")
+  }),
+  handler: async (args) => {
+    const { run_id, issue_id, action_type, hypothesis, expected_improvement, code_changes, pr_url, pr_number, remediation_id, deferral_reason, dismissal_reason, page_path, element_selector, diagnosis, proposed_fix, confidence } = args;
+    if (!isApiConfigured()) {
+      return apiNotConfiguredResult();
+    }
+    const { data, error } = await apiPost(`/improvement-runs/${run_id}/actions`, {
+      issue_id,
+      action_type,
+      hypothesis,
+      expected_improvement,
+      code_changes,
+      pr_url,
+      pr_number,
+      remediation_id,
+      deferral_reason,
+      dismissal_reason,
+      page_path,
+      element_selector,
+      diagnosis,
+      proposed_fix,
+      confidence
+    });
+    if (error) {
+      return errorResult(error);
+    }
+    return successResult(data);
+  }
+};
+var updateImprovementActionTool = {
+  name: "update_improvement_action",
+  description: "Update an existing improvement run action with PR information. Use this after a PR has been created to link it to the action.",
+  inputSchema: z25.object({
+    run_id: z25.string().describe("The ID of the improvement run"),
+    action_id: z25.string().describe("The ID of the action to update"),
+    pr_url: z25.string().optional().describe("GitHub PR URL to link to this action"),
+    pr_number: z25.number().optional().describe("GitHub PR number to link to this action")
+  }),
+  handler: async (args) => {
+    const { run_id, action_id, pr_url, pr_number } = args;
+    if (!isApiConfigured()) {
+      return apiNotConfiguredResult();
+    }
+    const { data, error } = await apiPatch(`/improvement-runs/${run_id}/actions/${action_id}`, {
+      pr_url,
+      pr_number
+    });
+    if (error) {
+      return errorResult(error);
+    }
+    return successResult(data);
+  }
+};
+var getImprovementRunTool = {
+  name: "get_improvement_run",
+  description: "Get details of a specific improvement run including all actions taken. Use to review what happened during a run.",
+  inputSchema: z25.object({
+    run_id: z25.string().describe("The ID of the improvement run to retrieve")
+  }),
+  handler: async (args) => {
+    const { run_id } = args;
+    if (!isApiConfigured()) {
+      return apiNotConfiguredResult();
+    }
+    const { data, error } = await apiGet(`/improvement-runs/${run_id}`);
+    if (error) {
+      return errorResult(error);
+    }
+    return successResult(data);
+  }
+};
+var listImprovementRunsTool = {
+  name: "list_improvement_runs",
+  description: "List recent improvement runs with optional filters. Use to review past runs and their outcomes.",
+  inputSchema: z25.object({
+    status: z25.enum(["running", "completed", "failed", "cancelled"]).optional().describe("Filter by run status"),
+    trigger_type: z25.enum(["github_actions", "cron", "manual", "api"]).optional().describe("Filter by trigger type"),
+    limit: z25.number().optional().default(20).describe("Maximum number of results (default: 20)"),
+    offset: z25.number().optional().default(0).describe("Offset for pagination")
+  }),
+  handler: async (args) => {
+    const { status, trigger_type, limit, offset } = args;
+    if (!isApiConfigured()) {
+      return apiNotConfiguredResult();
+    }
+    const { data, error } = await apiGet("/improvement-runs", {
+      status,
+      trigger_type,
+      limit: limit ?? 20,
+      offset: offset ?? 0
+    });
+    if (error) {
+      return errorResult(error);
+    }
+    return successResult(data);
+  }
+};
+
+// ../../libraries/mcp-tools/dist/tools/knowledge.js
+import { z as z26 } from "zod";
+var KNOWLEDGE_CATEGORIES = [
+  "false_positive",
+  "intended_behavior",
+  "fix_pattern",
+  "context"
+];
+var ISSUE_CATEGORIES = [
+  "code_error",
+  "dead_click",
+  "rage_click",
+  "ux_friction",
+  "performance",
+  "form_issue",
+  "behavioral_anomaly",
+  "structural_issue"
+];
+var getSiteKnowledgeTool = {
+  name: "get_site_knowledge",
+  description: "Retrieve site-specific learnings including known false positives, intended behaviors, and successful fix patterns. Use at the start of a self-improvement workflow to avoid re-flagging known issues.",
+  inputSchema: z26.object({
+    category: z26.enum(KNOWLEDGE_CATEGORIES).optional().describe("Filter by knowledge category"),
+    page_path: z26.string().optional().describe("Filter by page path"),
+    issue_category: z26.enum(ISSUE_CATEGORIES).optional().describe("Filter by issue category"),
+    limit: z26.number().optional().default(50).describe("Maximum number of entries to return (default: 50)")
+  }),
+  handler: async (args) => {
+    const { category, page_path, issue_category, limit } = args;
+    if (!isApiConfigured()) {
+      return apiNotConfiguredResult();
+    }
+    const { data, error } = await apiGet("/knowledge", {
+      category,
+      page_path,
+      issue_category,
+      limit: limit ?? 50
+    });
+    if (error) {
+      return errorResult(error);
+    }
+    return successResult(data);
+  }
+};
+var addSiteKnowledgeTool = {
+  name: "add_site_knowledge",
+  description: "Store a site-specific learning. Use to record false positives, intended behaviors, successful fix patterns, or important context about the site.",
+  inputSchema: z26.object({
+    category: z26.enum(KNOWLEDGE_CATEGORIES).describe("Category of knowledge: false_positive, intended_behavior, fix_pattern, or context"),
+    subject: z26.string().describe("Unique identifier/title for this knowledge entry"),
+    content: z26.string().describe("Detailed description of the learning"),
+    page_path: z26.string().optional().describe("Associated page path (if applicable)"),
+    element_selector: z26.string().optional().describe("Associated element selector (if applicable)"),
+    issue_category: z26.enum(ISSUE_CATEGORIES).optional().describe("Associated issue category (if applicable)")
+  }),
+  handler: async (args) => {
+    const { category, subject, content, page_path, element_selector, issue_category } = args;
+    if (!isApiConfigured()) {
+      return apiNotConfiguredResult();
+    }
+    const { data, error } = await apiPost("/knowledge", {
+      category,
+      subject,
+      content,
+      page_path,
+      element_selector,
+      issue_category,
+      source: "agent"
+    });
+    if (error) {
+      return errorResult(error);
+    }
+    return successResult(data);
+  }
+};
+var deleteSiteKnowledgeTool = {
+  name: "delete_site_knowledge",
+  description: "Delete a site knowledge entry. Use when a learning is no longer valid or was created in error.",
+  inputSchema: z26.object({
+    knowledge_id: z26.string().describe("The ID of the knowledge entry to delete")
+  }),
+  handler: async (args) => {
+    const { knowledge_id } = args;
+    if (!isApiConfigured()) {
+      return apiNotConfiguredResult();
+    }
+    const { data, error } = await apiDelete(`/knowledge/${knowledge_id}`);
+    if (error) {
+      return errorResult(error);
+    }
+    return successResult(data);
+  }
+};
+var getSimilarFixesTool = {
+  name: "get_similar_fixes",
+  description: "Find past fixes for similar issues. Returns successful and failed remediation attempts for issues with the same category, page, or element. Use before proposing a fix to learn from past attempts.",
+  inputSchema: z26.object({
+    issue_id: z26.string().describe("The ID of the issue to find similar fixes for"),
+    limit: z26.number().optional().default(5).describe("Maximum number of similar fixes to return (default: 5)")
+  }),
+  handler: async (args) => {
+    const { issue_id, limit } = args;
+    if (!isApiConfigured()) {
+      return apiNotConfiguredResult();
+    }
+    const { data, error } = await apiGet("/knowledge/similar-fixes", {
+      issue_id,
+      limit: limit ?? 5
+    });
+    if (error) {
+      return errorResult(error);
+    }
+    return successResult(data);
+  }
+};
+
+// ../../libraries/mcp-tools/dist/tools/listPages.js
+import { z as z27 } from "zod";
+var listPagesTool = {
+  name: "list_pages",
+  description: "List all tracked pages with basic metrics. Returns page paths sorted by session count with frustration and health grade. Use this to discover what pages are being tracked before diving into specific pages.",
+  inputSchema: z27.object({
+    days: z27.number().optional().default(7).describe("Number of days to look back (default 7)"),
+    limit: z27.number().optional().default(50).describe("Maximum number of pages to return (default 50)")
+  }),
+  handler: async (args) => {
+    const { days, limit } = args;
+    if (!isApiConfigured()) {
+      return apiNotConfiguredResult();
+    }
+    const { data, error } = await apiGet("/pages/list", {
+      days: days ?? 7,
+      limit: limit ?? 50
+    });
+    if (error) {
+      return errorResult(error);
+    }
+    return successResult(data);
+  }
+};
+
+// ../../libraries/mcp-tools/dist/tools/listSessions.js
+import { z as z28 } from "zod";
+var listSessionsTool = {
+  name: "list_sessions",
+  description: "List and filter recorded sessions. Returns session metadata including status, duration, device, browser, and domains. Use to find sessions for a domain, check for active sessions, or browse by device type.",
+  inputSchema: z28.object({
+    domain: z28.string().optional().describe("Filter by domain name (partial match supported)"),
+    status: z28.enum(["active", "terminated", "all"]).optional().default("all").describe("Filter by session status"),
+    device: z28.enum(["desktop", "mobile", "tablet"]).optional().describe("Filter by device type"),
+    days: z28.number().optional().default(7).describe("Number of days to look back (default: 7)"),
+    limit: z28.number().optional().default(20).describe("Maximum sessions to return (default: 20, max: 200)")
+  }),
+  handler: async (args) => {
+    const { domain, status, device, days, limit } = args;
+    if (!isApiConfigured()) {
+      return apiNotConfiguredResult();
+    }
+    const { data, error } = await apiGet("/sessions", {
+      domain,
+      status: status === "all" ? void 0 : status,
+      device,
+      days: days ?? 7,
+      limit: limit ?? 20
+    });
+    if (error) {
+      return errorResult(error);
+    }
+    return successResult(data);
+  }
+};
+
+// ../../libraries/mcp-tools/dist/tools/predictOutcomes.js
+import { z as z29 } from "zod";
+var predictOutcomesTool = {
+  name: "predict_outcomes",
+  description: "Predict session outcomes based on early behavioral signals. Provide either a session_id to analyze an existing session, or behavioral_features to predict outcomes for hypothetical scenarios. Returns predicted outcome (COMPLETED, STRUGGLED, BLOCKED, DISENGAGED) with confidence.",
+  inputSchema: z29.object({
+    session_id: z29.string().optional().describe("Session ID to analyze and predict outcome for"),
+    behavioral_features: z29.object({
+      frustration: z29.number().describe("Frustration score (0-1)"),
+      confusion: z29.number().describe("Confusion score (0-1)"),
+      confidence: z29.number().describe("Confidence score (0-1)")
+    }).optional().describe("Behavioral features to use for prediction")
+  }),
+  handler: async (args) => {
+    const { session_id, behavioral_features } = args;
+    if (!isApiConfigured()) {
+      return apiNotConfiguredResult();
+    }
+    if (!session_id && !behavioral_features) {
+      return errorResult("Either session_id or behavioral_features is required");
+    }
+    const { data, error } = await apiPost("/predict", {
+      session_id,
+      behavioral_features
+    });
+    if (error) {
+      return errorResult(error);
+    }
+    return successResult(data);
+  }
+};
+
+// ../../libraries/mcp-tools/dist/tools/remediation.js
+import { z as z30 } from "zod";
+var proposeFixTool = {
+  name: "propose_fix",
+  description: "Propose a fix for an issue. Creates a remediation record with baseline metrics for later evaluation. Include detailed diagnosis and code suggestions when possible.",
+  inputSchema: z30.object({
+    issue_id: z30.string().describe("The ID of the issue to fix"),
+    diagnosis: z30.string().describe("Detailed analysis of the root cause of the issue"),
+    proposed_fix: z30.string().describe("Description of the proposed fix and how it addresses the root cause"),
+    code_snippet: z30.string().optional().describe("Suggested code changes (if applicable)"),
+    affected_files: z30.array(z30.string()).optional().describe("List of files that need to be modified"),
+    confidence: z30.number().min(0).max(1).describe("Confidence level in the fix (0-1). Use <0.7 when uncertain.")
+  }),
+  handler: async (args) => {
+    const { issue_id, diagnosis, proposed_fix, code_snippet, affected_files, confidence } = args;
+    if (!isApiConfigured()) {
+      return apiNotConfiguredResult();
+    }
+    const { data, error } = await apiPost("/remediations", {
+      issue_id,
+      diagnosis,
+      proposed_fix,
+      code_snippet,
+      affected_files,
+      confidence
+    });
+    if (error) {
+      return errorResult(error);
+    }
+    return successResult(data);
+  }
+};
+var listPendingFixesTool = {
+  name: "list_pending_fixes",
+  description: "List all proposed fixes awaiting deployment. Use to show the user what fixes are ready to be deployed.",
+  inputSchema: z30.object({}),
+  handler: async () => {
+    if (!isApiConfigured()) {
+      return apiNotConfiguredResult();
+    }
+    const { data, error } = await apiGet("/remediations/pending");
+    if (error) {
+      return errorResult(error);
+    }
+    return successResult(data);
+  }
+};
+var listRemediationsTool = {
+  name: "list_remediations",
+  description: "List remediation records with optional filters. Use to review past and current fix attempts.",
+  inputSchema: z30.object({
+    status: z30.enum([
+      "proposed",
+      "waiting",
+      "dismissed",
+      "deployed",
+      "evaluating",
+      "succeeded",
+      "failed",
+      "reverted"
+    ]).optional().describe("Filter by remediation status"),
+    issue_id: z30.string().optional().describe("Filter by issue ID"),
+    page_path: z30.string().optional().describe("Filter by page path"),
+    limit: z30.number().optional().default(20).describe("Maximum number of results (default: 20)")
+  }),
+  handler: async (args) => {
+    const { status, issue_id, page_path, limit } = args;
+    if (!isApiConfigured()) {
+      return apiNotConfiguredResult();
+    }
+    const { data, error } = await apiGet("/remediations", {
+      status,
+      issue_id,
+      page_path,
+      limit: limit ?? 20
+    });
+    if (error) {
+      return errorResult(error);
+    }
+    return successResult(data);
+  }
+};
+var confirmDeploymentTool = {
+  name: "confirm_deployment",
+  description: "Confirm that a proposed fix has been deployed to production. This starts the evaluation timer. Call this when the user confirms they have deployed the fix.",
+  inputSchema: z30.object({
+    remediation_id: z30.string().describe("The ID of the remediation to mark as deployed")
+  }),
+  handler: async (args) => {
+    const { remediation_id } = args;
+    if (!isApiConfigured()) {
+      return apiNotConfiguredResult();
+    }
+    const { data, error } = await apiPatch(`/remediations/${remediation_id}/deploy`, {});
+    if (error) {
+      return errorResult(error);
+    }
+    return successResult(data);
+  }
+};
+var evaluateFixTool = {
+  name: "evaluate_fix",
+  description: "Evaluate if a deployed fix improved metrics. Compares post-deployment metrics to baseline. Returns success/partial/failed outcome with detailed verdict. Wait at least 24 hours after deployment for reliable results.",
+  inputSchema: z30.object({
+    remediation_id: z30.string().describe("The ID of the remediation to evaluate"),
+    min_hours: z30.number().optional().default(24).describe("Minimum hours since deployment required (default: 24)")
+  }),
+  handler: async (args) => {
+    const { remediation_id, min_hours } = args;
+    if (!isApiConfigured()) {
+      return apiNotConfiguredResult();
+    }
+    const { data, error } = await apiPost(`/remediations/${remediation_id}/evaluate`, { min_hours: min_hours ?? 24 });
+    if (error) {
+      return errorResult(error);
+    }
+    return successResult(data);
+  }
+};
+var getFixHistoryTool = {
+  name: "get_fix_history",
+  description: "Get the full remediation history for an issue. Shows all fix attempts, their outcomes, and current status. Use before proposing a new fix to learn from past attempts.",
+  inputSchema: z30.object({
+    issue_id: z30.string().describe("The ID of the issue to get fix history for")
+  }),
+  handler: async (args) => {
+    const { issue_id } = args;
+    if (!isApiConfigured()) {
+      return apiNotConfiguredResult();
+    }
+    const { data, error } = await apiGet(`/remediations/history/${issue_id}`);
+    if (error) {
+      return errorResult(error);
+    }
+    return successResult(data);
+  }
+};
+var updateRemediationStatusTool = {
+  name: "update_remediation_status",
+  description: "Update the status of a remediation based on PR events. Use to mark a fix as 'waiting' (PR created), 'deployed' (PR merged), or 'dismissed' (PR closed without merge).",
+  inputSchema: z30.object({
+    remediation_id: z30.string().describe("The ID of the remediation to update"),
+    status: z30.enum(["waiting", "deployed", "dismissed"]).describe("New status: 'waiting' = PR open, 'deployed' = PR merged, 'dismissed' = PR closed without merge"),
+    pr_url: z30.string().optional().describe("URL of the pull request"),
+    pr_number: z30.number().optional().describe("PR number"),
+    pr_merged_at: z30.string().optional().describe("ISO timestamp when PR was merged"),
+    pr_closed_at: z30.string().optional().describe("ISO timestamp when PR was closed")
+  }),
+  handler: async (args) => {
+    const { remediation_id, status, pr_url, pr_number, pr_merged_at, pr_closed_at } = args;
+    if (!isApiConfigured()) {
+      return apiNotConfiguredResult();
+    }
+    const { data, error } = await apiPatch(`/remediations/${remediation_id}/status`, {
+      status,
+      pr_url,
+      pr_number,
+      pr_merged_at,
+      pr_closed_at
+    });
+    if (error) {
+      return errorResult(error);
+    }
+    return successResult(data);
+  }
+};
+var listRemediationsByStatusTool = {
+  name: "list_remediations_by_status",
+  description: "List remediations filtered by one or more statuses. Use to find all 'waiting' PRs or 'deployed' fixes ready for evaluation.",
+  inputSchema: z30.object({
+    statuses: z30.array(z30.enum([
+      "proposed",
+      "waiting",
+      "dismissed",
+      "deployed",
+      "evaluating",
+      "succeeded",
+      "failed",
+      "reverted"
+    ])).describe("List of statuses to filter by")
+  }),
+  handler: async (args) => {
+    const { statuses } = args;
+    if (!isApiConfigured()) {
+      return apiNotConfiguredResult();
+    }
+    const { data, error } = await apiGet(`/remediations/by-status`, {
+      statuses: statuses.join(",")
+    });
+    if (error) {
+      return errorResult(error);
+    }
+    return successResult(data);
+  }
+};
+var getRemediationByPrTool = {
+  name: "get_remediation_by_pr",
+  description: "Get a remediation by its PR number. Use to look up fix details when processing PR events.",
+  inputSchema: z30.object({
+    pr_number: z30.number().describe("The PR number to look up")
+  }),
+  handler: async (args) => {
+    const { pr_number } = args;
+    if (!isApiConfigured()) {
+      return apiNotConfiguredResult();
+    }
+    const { data, error } = await apiGet(`/remediations/by-pr/${pr_number}`);
+    if (error) {
+      return errorResult(error);
+    }
+    return successResult(data);
+  }
+};
+
+// ../../libraries/mcp-tools/dist/tools/scanSite.js
+import { z as z31 } from "zod";
+var scanSiteTool = {
+  name: "scan_site",
+  description: "One-shot site health scan. Lists all pages and computes aggregate metrics for the top-N pages (default 10) sorted by session count. Returns a ranked table with frustration and health grade per page. Use this as the FIRST tool when the user asks a broad question without naming a specific page.",
+  inputSchema: z31.object({
+    top_n: z31.number().optional().default(10).describe("Number of top pages to analyze (default 10)"),
+    offset: z31.number().optional().default(0).describe("Skip first N pages for pagination (default 0)")
+  }),
+  handler: async (args) => {
+    const { top_n, offset } = args;
+    if (!isApiConfigured()) {
+      return apiNotConfiguredResult();
+    }
+    const { data, error } = await apiGet("/site/overview", {
+      top_n: top_n ?? 10,
+      offset: offset ?? 0
+    });
+    if (error) {
+      return errorResult(error);
+    }
+    return successResult(data);
+  }
+};
+
+// ../../libraries/mcp-tools/dist/tools/searchSessions.js
+import { z as z32 } from "zod";
+var searchSessionsTool = {
+  name: "search_sessions",
+  description: 'Search sessions by natural language query. Examples: "frustrated users on checkout", "rage clicks on pricing page", "confused users who abandoned cart".',
+  inputSchema: z32.object({
+    query: z32.string().describe("Natural language search query describing the sessions you want to find"),
+    page_path: z32.string().optional().describe("Optional: filter to a specific page path"),
+    limit: z32.number().optional().default(10).describe("Maximum number of sessions to return (default: 10)")
+  }),
+  handler: async (args) => {
+    const { query, page_path, limit } = args;
+    if (!isApiConfigured()) {
+      return apiNotConfiguredResult();
+    }
+    const { data, error } = await apiPost("/sessions/search", {
+      query,
+      page_path,
+      limit: limit ?? 10
+    });
+    if (error) {
+      return errorResult(error);
+    }
+    return successResult(data);
+  }
+};
+
+// ../../libraries/mcp-tools/dist/tools/triage.js
+import { z as z33 } from "zod";
+var DISMISS_REASONS = [
+  "stale",
+  "intended",
+  "duplicate",
+  "false_positive"
+];
+var dismissIssueTool = {
+  name: "dismiss_issue",
+  description: "Dismiss an issue as a false positive. Creates site knowledge to prevent re-flagging. Use when an issue is stale, intended behavior, a duplicate, or a false positive. Always confirm with user before dismissing.",
+  inputSchema: z33.object({
+    issue_id: z33.string().describe("The ID of the issue to dismiss"),
+    reason: z33.enum(DISMISS_REASONS).describe("Reason for dismissal: stale, intended, duplicate, or false_positive"),
+    explanation: z33.string().describe("Detailed explanation of why this issue is being dismissed"),
+    create_knowledge: z33.boolean().optional().default(true).describe("Whether to create site knowledge entry (default: true)")
+  }),
+  handler: async (args) => {
+    const { issue_id, reason, explanation, create_knowledge } = args;
+    if (!isApiConfigured()) {
+      return apiNotConfiguredResult();
+    }
+    const { data, error } = await apiPost(`/issues/${issue_id}/dismiss`, {
+      reason,
+      explanation,
+      create_knowledge: create_knowledge ?? true
+    });
+    if (error) {
+      return errorResult(error);
+    }
+    return successResult(data);
+  }
+};
+var markIntendedBehaviorTool = {
+  name: "mark_intended_behavior",
+  description: "Mark an issue as intended behavior. This is a shortcut for dismissing with reason 'intended' and always creates site knowledge. Use when the detected behavior is by design (e.g., disabled button clicks are expected).",
+  inputSchema: z33.object({
+    issue_id: z33.string().describe("The ID of the issue to mark as intended"),
+    explanation: z33.string().describe("Explanation of why this behavior is intended")
+  }),
+  handler: async (args) => {
+    const { issue_id, explanation } = args;
+    if (!isApiConfigured()) {
+      return apiNotConfiguredResult();
+    }
+    const { data, error } = await apiPost(`/issues/${issue_id}/mark-intended`, {
+      explanation
+    });
+    if (error) {
+      return errorResult(error);
+    }
+    return successResult(data);
+  }
+};
+var getIssueHistoryTool = {
+  name: "get_issue_history",
+  description: "Get the full history of an issue including status changes, remediation attempts, and outcomes. Use to understand past fix attempts before proposing new ones.",
+  inputSchema: z33.object({
+    issue_id: z33.string().describe("The ID of the issue to get history for")
+  }),
+  handler: async (args) => {
+    const { issue_id } = args;
+    if (!isApiConfigured()) {
+      return apiNotConfiguredResult();
+    }
+    const { data, error } = await apiGet(`/issues/${issue_id}/history`);
+    if (error) {
+      return errorResult(error);
+    }
+    return successResult(data);
+  }
+};
+
+// ../../libraries/mcp-tools/dist/tools/triageSessions.js
+import { z as z34 } from "zod";
+function formatDuration(seconds) {
+  if (!seconds)
+    return "unknown";
+  if (seconds < 60)
+    return `${seconds}s`;
+  if (seconds < 3600)
+    return `${Math.floor(seconds / 60)}m ${seconds % 60}s`;
+  const hours = Math.floor(seconds / 3600);
+  const mins = Math.floor(seconds % 3600 / 60);
+  return `${hours}h ${mins}m`;
+}
+function getActionReason(session) {
+  const reasons = [];
+  if (session.user_comments.length > 0) {
+    reasons.push(`USER FEEDBACK: ${session.user_comments.length} comment(s) - "${session.user_comments[0].text.slice(0, 100)}${session.user_comments[0].text.length > 100 ? "..." : ""}"`);
+  }
+  if (session.behavioral_signals.frustration >= 0.5) {
+    reasons.push(`HIGH FRUSTRATION: ${(session.behavioral_signals.frustration * 100).toFixed(0)}%`);
+  } else if (session.behavioral_signals.frustration >= 0.3) {
+    reasons.push(`MODERATE FRUSTRATION: ${(session.behavioral_signals.frustration * 100).toFixed(0)}%`);
+  }
+  if (session.behavioral_signals.has_rage_clicks) {
+    reasons.push("RAGE CLICKS detected");
+  }
+  if (session.console_errors.length > 0) {
+    const errorCount = session.console_errors.reduce((sum, e) => sum + e.count, 0);
+    reasons.push(`JS ERRORS: ${errorCount} error(s) - "${session.console_errors[0].message.slice(0, 80)}..."`);
+  }
+  if (!session.behavioral_signals.has_behavioral_data) {
+    reasons.push("NOTE: No behavioral analysis data available for this session");
+  }
+  if (reasons.length === 0) {
+    reasons.push("Low severity - no major issues detected");
+  }
+  return reasons.join("\n  - ");
+}
+function formatTriageOutput(data) {
+  const lines = [];
+  lines.push("# SESSION TRIAGE RESULTS\n");
+  lines.push(`Total sessions analyzed: ${data.summary.total_sessions}`);
+  lines.push(`Sessions with issues: ${data.summary.flagged_sessions}`);
+  lines.push(`Sessions with user comments: ${data.summary.sessions_with_comments}`);
+  if (data.sessions.length === 0) {
+    lines.push("\nNo sessions require attention.");
+    return lines.join("\n");
+  }
+  const critical = data.sessions.filter((s) => s.severity === "critical");
+  const high = data.sessions.filter((s) => s.severity === "high");
+  const medium = data.sessions.filter((s) => s.severity === "medium");
+  const low = data.sessions.filter((s) => s.severity === "low");
+  lines.push("\n## PRIORITY SUMMARY");
+  lines.push(`- CRITICAL: ${critical.length} session(s) - investigate immediately`);
+  lines.push(`- HIGH: ${high.length} session(s) - investigate soon`);
+  lines.push(`- MEDIUM: ${medium.length} session(s) - review when possible`);
+  lines.push(`- LOW: ${low.length} session(s) - likely okay`);
+  lines.push("\n## RECOMMENDED ACTIONS\n");
+  if (critical.length > 0) {
+    lines.push("### CRITICAL - Investigate Immediately\n");
+    for (const s of critical) {
+      lines.push(`**Session ${s.session_id.slice(-8)}** (${formatDuration(s.duration_seconds)}, ${s.device})`);
+      lines.push(`  Replay: ${s.replay_url}`);
+      lines.push(`  Score: ${(s.triage_score * 100).toFixed(0)}%`);
+      lines.push(`  Why: ${getActionReason(s)}`);
+      if (s.pages_visited.length > 0) {
+        lines.push(`  Pages: ${s.pages_visited.slice(0, 3).join(", ")}${s.pages_visited.length > 3 ? ` (+${s.pages_visited.length - 3} more)` : ""}`);
+      }
+      lines.push("");
+    }
+  }
+  if (high.length > 0) {
+    lines.push("### HIGH - Investigate Soon\n");
+    for (const s of high) {
+      lines.push(`**Session ${s.session_id.slice(-8)}** (${formatDuration(s.duration_seconds)}, ${s.device})`);
+      lines.push(`  Replay: ${s.replay_url}`);
+      lines.push(`  Score: ${(s.triage_score * 100).toFixed(0)}%`);
+      lines.push(`  Why: ${getActionReason(s)}`);
+      if (s.pages_visited.length > 0) {
+        lines.push(`  Pages: ${s.pages_visited.slice(0, 3).join(", ")}${s.pages_visited.length > 3 ? ` (+${s.pages_visited.length - 3} more)` : ""}`);
+      }
+      lines.push("");
+    }
+  }
+  if (medium.length > 0) {
+    lines.push("### MEDIUM - Review When Possible\n");
+    for (const s of medium) {
+      lines.push(`- Session ${s.session_id.slice(-8)} (${formatDuration(s.duration_seconds)}): ${getActionReason(s).split("\n")[0]}`);
+      lines.push(`  ${s.replay_url}`);
+    }
+    lines.push("");
+  }
+  if (low.length > 0) {
+    lines.push("### LOW - Likely Okay\n");
+    lines.push(`${low.length} session(s) with minor or no issues detected.`);
+    if (low.length <= 3) {
+      for (const s of low) {
+        lines.push(`- Session ${s.session_id.slice(-8)}: ${s.replay_url}`);
+      }
+    }
+    lines.push("");
+  }
+  lines.push("\n## RAW DATA (for detailed analysis)\n");
+  lines.push("```json");
+  lines.push(JSON.stringify({
+    summary: data.summary,
+    sessions: data.sessions.map((s) => ({
+      id: s.session_id,
+      severity: s.severity,
+      score: s.triage_score,
+      url: s.replay_url,
+      comments: s.user_comments.length,
+      frustration: s.behavioral_signals.frustration,
+      rage_clicks: s.behavioral_signals.has_rage_clicks,
+      errors: s.console_errors.length,
+      has_data: s.behavioral_signals.has_behavioral_data
+    }))
+  }, null, 2));
+  lines.push("```");
+  return lines.join("\n");
+}
+var triageSessionsTool = {
+  name: "triage_sessions",
+  description: "Automatically triage sessions to find compromised user experiences. Analyzes user comments, frustration signals, rage clicks, and console errors. Returns flagged sessions with evidence and replay links. Use this to identify sessions that need attention without manually reviewing every recording. Can triage specific sessions by ID(s) or scan for problematic sessions. NOTE: Session replay URLs require a paid plan (Starter+). Free tier users can see session summaries and triage scores but not watch replays.",
+  inputSchema: z34.object({
+    session_ids: z34.array(z34.string()).optional().describe("Triage specific sessions by ID. If provided, other filters are ignored."),
+    days: z34.number().optional().default(7).describe("Lookback period in days (default: 7). Ignored if session_ids is provided."),
+    page_path: z34.string().optional().describe("Filter to sessions that visited a specific page"),
+    min_severity: z34.enum(["critical", "high", "medium", "low"]).optional().describe("Minimum severity to include in results"),
+    limit: z34.number().optional().default(20).describe("Maximum sessions to return (default: 20, max: 100)")
+  }),
+  handler: async (args) => {
+    const { session_ids, days, page_path, min_severity, limit } = args;
+    if (!isApiConfigured()) {
+      return apiNotConfiguredResult();
+    }
+    const { data, error } = await apiGet("/sessions/triage", {
+      session_ids: session_ids?.join(","),
+      days: session_ids?.length ? void 0 : days ?? 7,
+      page_path: session_ids?.length ? void 0 : page_path,
+      min_severity,
+      limit: session_ids?.length ? session_ids.length : limit ?? 20
+    });
+    if (error) {
+      return errorResult(error);
+    }
+    const formattedOutput = formatTriageOutput(data);
+    return { content: [{ type: "text", text: formattedOutput }] };
+  }
+};
+
+// ../../libraries/mcp-tools/dist/tools/proposal.js
+import { z as z35 } from "zod";
+var ISSUE_CATEGORIES2 = [
+  "code_error",
+  "dead_click",
+  "rage_click",
+  "ux_friction",
+  "performance",
+  "form_issue",
+  "behavioral_anomaly",
+  "structural_issue"
+];
+var ISSUE_SEVERITIES = ["critical", "high", "medium", "low", "info"];
+var PROPOSAL_STATUSES = [
+  "pending",
+  "resolved",
+  "dismissed",
+  "evaluating",
+  "succeeded",
+  "failed"
+];
+var createProposalTool = {
+  name: "create_proposal",
+  description: "Create a fix proposal for audit mode. Proposals are suggestions that developers review and implement manually. Use this in audit mode instead of propose_fix when you cannot make code changes directly.",
+  inputSchema: z35.object({
+    issue_id: z35.string().optional().describe("The ID of the related issue (if any)"),
+    improvement_run_id: z35.string().optional().describe("The ID of the improvement run creating this proposal"),
+    title: z35.string().describe("Short title describing the proposed fix"),
+    diagnosis: z35.string().describe("Detailed analysis of the root cause of the issue"),
+    proposed_fix: z35.string().describe("Description of the proposed fix and how it addresses the root cause"),
+    affected_files: z35.array(z35.string()).optional().describe("List of files that likely need to be modified"),
+    confidence: z35.number().min(0).max(1).describe("Confidence level in the fix (0-1). Use <0.7 when uncertain."),
+    page_path: z35.string().describe("The page path where the issue occurs"),
+    element_selector: z35.string().optional().describe("CSS selector of the affected element (if applicable)"),
+    category: z35.enum(ISSUE_CATEGORIES2).describe("Category of the issue being addressed"),
+    severity: z35.enum(ISSUE_SEVERITIES).describe("Severity of the issue being addressed")
+  }),
+  handler: async (args) => {
+    const { issue_id, improvement_run_id, title, diagnosis, proposed_fix, affected_files, confidence, page_path, element_selector, category, severity } = args;
+    if (!isApiConfigured()) {
+      return apiNotConfiguredResult();
+    }
+    const { data, error } = await apiPost("/proposals", {
+      issue_id,
+      improvement_run_id,
+      title,
+      diagnosis,
+      proposed_fix,
+      affected_files,
+      confidence,
+      page_path,
+      element_selector,
+      category,
+      severity
+    });
+    if (error) {
+      return errorResult(error);
+    }
+    return successResult(data);
+  }
+};
+var listProposalsTool = {
+  name: "list_proposals",
+  description: "List proposals with optional filters. Use to review pending proposals, check resolved proposals, or filter by page/category/severity.",
+  inputSchema: z35.object({
+    status: z35.enum(PROPOSAL_STATUSES).optional().describe("Filter by single status"),
+    statuses: z35.array(z35.enum(PROPOSAL_STATUSES)).optional().describe("Filter by multiple statuses"),
+    issue_id: z35.string().optional().describe("Filter by related issue ID"),
+    page_path: z35.string().optional().describe("Filter by page path"),
+    category: z35.enum(ISSUE_CATEGORIES2).optional().describe("Filter by category"),
+    severity: z35.enum(ISSUE_SEVERITIES).optional().describe("Filter by severity"),
+    limit: z35.number().optional().default(20).describe("Maximum number of results (default: 20)")
+  }),
+  handler: async (args) => {
+    const { status, statuses, issue_id, page_path, category, severity, limit } = args;
+    if (!isApiConfigured()) {
+      return apiNotConfiguredResult();
+    }
+    const params = {
+      limit: limit ?? 20
+    };
+    if (status)
+      params.status = status;
+    if (statuses && statuses.length > 0)
+      params.statuses = statuses.join(",");
+    if (issue_id)
+      params.issue_id = issue_id;
+    if (page_path)
+      params.page_path = page_path;
+    if (category)
+      params.category = category;
+    if (severity)
+      params.severity = severity;
+    const { data, error } = await apiGet("/proposals", params);
+    if (error) {
+      return errorResult(error);
+    }
+    return successResult(data);
+  }
+};
+var getProposalTool = {
+  name: "get_proposal",
+  description: "Get details of a specific proposal by ID. Use to review the full diagnosis and proposed fix before implementing.",
+  inputSchema: z35.object({
+    proposal_id: z35.string().describe("The ID of the proposal to retrieve")
+  }),
+  handler: async (args) => {
+    const { proposal_id } = args;
+    if (!isApiConfigured()) {
+      return apiNotConfiguredResult();
+    }
+    const { data, error } = await apiGet(`/proposals/${proposal_id}`);
+    if (error) {
+      return errorResult(error);
+    }
+    return successResult(data);
+  }
+};
+var resolveProposalTool = {
+  name: "resolve_proposal",
+  description: "Mark a proposal as resolved after implementing the fix. This captures baseline metrics for later evaluation. Call this after you have implemented the proposed fix in code.",
+  inputSchema: z35.object({
+    proposal_id: z35.string().describe("The ID of the proposal to mark as resolved"),
+    member_id: z35.string().optional().describe("The ID of the member who resolved it (optional)")
+  }),
+  handler: async (args) => {
+    const { proposal_id, member_id } = args;
+    if (!isApiConfigured()) {
+      return apiNotConfiguredResult();
+    }
+    const { data, error } = await apiPost(`/proposals/${proposal_id}/resolve`, { member_id });
+    if (error) {
+      return errorResult(error);
+    }
+    return successResult(data);
+  }
+};
+var dismissProposalTool = {
+  name: "dismiss_proposal",
+  description: "Dismiss a proposal that won't be implemented. Use when the proposal is not applicable, the issue is intended behavior, or a different approach is preferred.",
+  inputSchema: z35.object({
+    proposal_id: z35.string().describe("The ID of the proposal to dismiss"),
+    reason: z35.string().describe("Explanation of why the proposal is being dismissed"),
+    member_id: z35.string().optional().describe("The ID of the member who dismissed it (optional)")
+  }),
+  handler: async (args) => {
+    const { proposal_id, reason, member_id } = args;
+    if (!isApiConfigured()) {
+      return apiNotConfiguredResult();
+    }
+    const { data, error } = await apiPost(`/proposals/${proposal_id}/dismiss`, { reason, member_id });
+    if (error) {
+      return errorResult(error);
+    }
+    return successResult(data);
+  }
+};
+var evaluateProposalTool = {
+  name: "evaluate_proposal",
+  description: "Evaluate if a resolved proposal improved metrics. Compares post-resolution metrics to baseline. Returns success/partial/failed outcome with detailed verdict. Wait at least 24 hours after resolution for reliable results.",
+  inputSchema: z35.object({
+    proposal_id: z35.string().describe("The ID of the proposal to evaluate"),
+    min_hours: z35.number().optional().default(24).describe("Minimum hours since resolution required (default: 24)")
+  }),
+  handler: async (args) => {
+    const { proposal_id, min_hours } = args;
+    if (!isApiConfigured()) {
+      return apiNotConfiguredResult();
+    }
+    const minHoursParam = min_hours ?? 24;
+    const { data, error } = await apiPost(`/proposals/${proposal_id}/evaluate?min_hours=${minHoursParam}`, {});
+    if (error) {
+      return errorResult(error);
+    }
+    return successResult(data);
+  }
+};
+var listPendingProposalsTool = {
+  name: "list_pending_proposals",
+  description: "List all pending proposals awaiting review. Use to see what fix suggestions are available for implementation.",
+  inputSchema: z35.object({}),
+  handler: async () => {
+    if (!isApiConfigured()) {
+      return apiNotConfiguredResult();
+    }
+    const { data, error } = await apiGet("/proposals/pending");
+    if (error) {
+      return errorResult(error);
+    }
+    return successResult(data);
+  }
+};
+var listProposalsForEvaluationTool = {
+  name: "list_proposals_for_evaluation",
+  description: "List resolved proposals that are ready for evaluation (24+ hours since resolution). Use during audit runs to check outcomes of previously resolved proposals.",
+  inputSchema: z35.object({
+    min_hours: z35.number().optional().default(24).describe("Minimum hours since resolution (default: 24)")
+  }),
+  handler: async (args) => {
+    const { min_hours } = args;
+    if (!isApiConfigured()) {
+      return apiNotConfiguredResult();
+    }
+    const { data, error } = await apiGet("/proposals/ready-for-evaluation", { min_hours: min_hours ?? 24 });
+    if (error) {
+      return errorResult(error);
+    }
+    return successResult(data);
+  }
+};
+
+// ../../libraries/mcp-tools/dist/tools/git.js
+import { z as z36 } from "zod";
+var gitContext = null;
+function getGitContext() {
+  if (!gitContext) {
+    throw new Error("Git context not configured. Connect GitHub or GitLab first.");
+  }
+  return gitContext;
+}
+async function githubRequest(endpoint, options = {}) {
+  const ctx = getGitContext();
+  const url = `https://api.github.com${endpoint}`;
+  return fetch(url, {
+    ...options,
+    headers: {
+      Authorization: `Bearer ${ctx.token}`,
+      Accept: "application/vnd.github.v3+json",
+      "X-GitHub-Api-Version": "2022-11-28",
+      "Content-Type": "application/json",
+      ...options.headers
+    }
+  });
+}
+async function gitlabRequest(endpoint, options = {}) {
+  const ctx = getGitContext();
+  const baseUrl = ctx.baseUrl || "https://gitlab.com";
+  const url = `${baseUrl}/api/v4${endpoint}`;
+  return fetch(url, {
+    ...options,
+    headers: {
+      "PRIVATE-TOKEN": ctx.token,
+      "Content-Type": "application/json",
+      ...options.headers
+    }
+  });
+}
+var createBranchTool = {
+  name: "create_branch",
+  description: "Create a new branch from the default branch. Works with both GitHub and GitLab.",
+  inputSchema: z36.object({
+    branch_name: z36.string().describe("Name of the new branch to create"),
+    from_branch: z36.string().optional().default("main").describe("Base branch to create from (default: main)")
+  }),
+  handler: async (args) => {
+    try {
+      const ctx = getGitContext();
+      const branchName = args.branch_name;
+      const fromBranch = args.from_branch || "main";
+      if (ctx.provider === "github") {
+        const refRes = await githubRequest(`/repos/${ctx.repoFullName}/git/refs/heads/${fromBranch}`);
+        if (!refRes.ok) {
+          return errorResult(`Failed to get base branch: ${refRes.statusText}`);
+        }
+        const refData = await refRes.json();
+        const sha = refData.object.sha;
+        const createRes = await githubRequest(`/repos/${ctx.repoFullName}/git/refs`, {
+          method: "POST",
+          body: JSON.stringify({
+            ref: `refs/heads/${branchName}`,
+            sha
+          })
+        });
+        if (!createRes.ok) {
+          const err = await createRes.json();
+          return errorResult(err.message || "Failed to create branch");
+        }
+        return successResult({
+          success: true,
+          branch: branchName,
+          from: fromBranch,
+          provider: "github"
+        });
+      } else {
+        const encodedPath = encodeURIComponent(ctx.repoFullName);
+        const createRes = await gitlabRequest(`/projects/${encodedPath}/repository/branches`, {
+          method: "POST",
+          body: JSON.stringify({
+            branch: branchName,
+            ref: fromBranch
+          })
+        });
+        if (!createRes.ok) {
+          const err = await createRes.json();
+          return errorResult(err.message || "Failed to create branch");
+        }
+        return successResult({
+          success: true,
+          branch: branchName,
+          from: fromBranch,
+          provider: "gitlab"
+        });
+      }
+    } catch (error) {
+      return errorResult(error instanceof Error ? error.message : "Failed to create branch");
+    }
+  }
+};
+var getFileContentTool = {
+  name: "get_file_content",
+  description: "Get the content of a file from the repository. Works with both GitHub and GitLab.",
+  inputSchema: z36.object({
+    path: z36.string().describe("Path to the file in the repository"),
+    branch: z36.string().optional().describe("Branch to read from (default: main)")
+  }),
+  handler: async (args) => {
+    try {
+      const ctx = getGitContext();
+      const filePath = args.path;
+      const branch = args.branch || "main";
+      if (ctx.provider === "github") {
+        const res = await githubRequest(`/repos/${ctx.repoFullName}/contents/${filePath}?ref=${branch}`);
+        if (!res.ok) {
+          if (res.status === 404) {
+            return errorResult(`File not found: ${filePath}`);
+          }
+          return errorResult(`Failed to get file: ${res.statusText}`);
+        }
+        const data = await res.json();
+        const content = Buffer.from(data.content, "base64").toString("utf-8");
+        return successResult({
+          path: filePath,
+          content,
+          sha: data.sha,
+          provider: "github"
+        });
+      } else {
+        const encodedPath = encodeURIComponent(ctx.repoFullName);
+        const encodedFilePath = encodeURIComponent(filePath);
+        const res = await gitlabRequest(`/projects/${encodedPath}/repository/files/${encodedFilePath}?ref=${branch}`);
+        if (!res.ok) {
+          if (res.status === 404) {
+            return errorResult(`File not found: ${filePath}`);
+          }
+          return errorResult(`Failed to get file: ${res.statusText}`);
+        }
+        const data = await res.json();
+        const content = Buffer.from(data.content, "base64").toString("utf-8");
+        return successResult({
+          path: filePath,
+          content,
+          sha: data.content_sha256,
+          provider: "gitlab"
+        });
+      }
+    } catch (error) {
+      return errorResult(error instanceof Error ? error.message : "Failed to get file content");
+    }
+  }
+};
+var updateFileTool = {
+  name: "update_file",
+  description: "Update or create a file in the repository. Works with both GitHub and GitLab.",
+  inputSchema: z36.object({
+    path: z36.string().describe("Path to the file in the repository"),
+    content: z36.string().describe("New content for the file"),
+    message: z36.string().describe("Commit message"),
+    branch: z36.string().describe("Branch to commit to"),
+    sha: z36.string().optional().describe("SHA of the file being replaced (required for updates)")
+  }),
+  handler: async (args) => {
+    try {
+      const ctx = getGitContext();
+      const filePath = args.path;
+      const content = args.content;
+      const message = args.message;
+      const branch = args.branch;
+      const sha = args.sha;
+      if (ctx.provider === "github") {
+        const body = {
+          message,
+          content: Buffer.from(content).toString("base64"),
+          branch
+        };
+        if (sha) {
+          body.sha = sha;
+        }
+        const res = await githubRequest(`/repos/${ctx.repoFullName}/contents/${filePath}`, {
+          method: "PUT",
+          body: JSON.stringify(body)
+        });
+        if (!res.ok) {
+          const err = await res.json();
+          return errorResult(err.message || "Failed to update file");
+        }
+        const data = await res.json();
+        return successResult({
+          success: true,
+          path: filePath,
+          sha: data.content.sha,
+          commit: data.commit.sha,
+          provider: "github"
+        });
+      } else {
+        const encodedPath = encodeURIComponent(ctx.repoFullName);
+        const encodedFilePath = encodeURIComponent(filePath);
+        const method = sha ? "PUT" : "POST";
+        const res = await gitlabRequest(`/projects/${encodedPath}/repository/files/${encodedFilePath}`, {
+          method,
+          body: JSON.stringify({
+            branch,
+            content,
+            commit_message: message,
+            encoding: "text"
+          })
+        });
+        if (!res.ok) {
+          const err = await res.json();
+          return errorResult(err.message || "Failed to update file");
+        }
+        const data = await res.json();
+        return successResult({
+          success: true,
+          path: filePath,
+          sha: data.content_sha256,
+          provider: "gitlab"
+        });
+      }
+    } catch (error) {
+      return errorResult(error instanceof Error ? error.message : "Failed to update file");
+    }
+  }
+};
+var createMergeRequestTool = {
+  name: "create_merge_request",
+  description: "Create a merge request (GitHub: Pull Request, GitLab: Merge Request). Works with both providers.",
+  inputSchema: z36.object({
+    title: z36.string().describe("Title of the merge request"),
+    description: z36.string().describe("Description/body of the merge request"),
+    source_branch: z36.string().describe("Branch containing the changes"),
+    target_branch: z36.string().optional().default("main").describe("Branch to merge into (default: main)")
+  }),
+  handler: async (args) => {
+    try {
+      const ctx = getGitContext();
+      const title = args.title;
+      const description = args.description;
+      const sourceBranch = args.source_branch;
+      const targetBranch = args.target_branch || "main";
+      if (ctx.provider === "github") {
+        const res = await githubRequest(`/repos/${ctx.repoFullName}/pulls`, {
+          method: "POST",
+          body: JSON.stringify({
+            title,
+            body: description,
+            head: sourceBranch,
+            base: targetBranch
+          })
+        });
+        if (!res.ok) {
+          const err = await res.json();
+          return errorResult(err.message || "Failed to create pull request");
+        }
+        const data = await res.json();
+        return successResult({
+          success: true,
+          mr_number: data.number,
+          url: data.html_url,
+          state: data.state,
+          provider: "github",
+          type: "pull_request"
+        });
+      } else {
+        const encodedPath = encodeURIComponent(ctx.repoFullName);
+        const res = await gitlabRequest(`/projects/${encodedPath}/merge_requests`, {
+          method: "POST",
+          body: JSON.stringify({
+            title,
+            description,
+            source_branch: sourceBranch,
+            target_branch: targetBranch
+          })
+        });
+        if (!res.ok) {
+          const err = await res.json();
+          return errorResult(err.message || "Failed to create merge request");
+        }
+        const data = await res.json();
+        return successResult({
+          success: true,
+          mr_number: data.iid,
+          url: data.web_url,
+          state: data.state,
+          provider: "gitlab",
+          type: "merge_request"
+        });
+      }
+    } catch (error) {
+      return errorResult(error instanceof Error ? error.message : "Failed to create merge request");
+    }
+  }
+};
+var checkMrStatusTool = {
+  name: "check_mr_status",
+  description: "Check the status of a merge request. Works with both GitHub and GitLab.",
+  inputSchema: z36.object({
+    mr_number: z36.number().describe("The merge request number")
+  }),
+  handler: async (args) => {
+    try {
+      const ctx = getGitContext();
+      const mrNumber = args.mr_number;
+      if (ctx.provider === "github") {
+        const res = await githubRequest(`/repos/${ctx.repoFullName}/pulls/${mrNumber}`);
+        if (!res.ok) {
+          if (res.status === 404) {
+            return errorResult(`Pull request #${mrNumber} not found`);
+          }
+          return errorResult(`Failed to get pull request: ${res.statusText}`);
+        }
+        const data = await res.json();
+        let status;
+        if (data.merged) {
+          status = "merged";
+        } else if (data.state === "closed") {
+          status = "closed";
+        } else {
+          status = "open";
+        }
+        return successResult({
+          mr_number: data.number,
+          title: data.title,
+          status,
+          url: data.html_url,
+          source_branch: data.head.ref,
+          target_branch: data.base.ref,
+          created_at: data.created_at,
+          merged_at: data.merged_at,
+          closed_at: data.closed_at,
+          provider: "github"
+        });
+      } else {
+        const encodedPath = encodeURIComponent(ctx.repoFullName);
+        const res = await gitlabRequest(`/projects/${encodedPath}/merge_requests/${mrNumber}`);
+        if (!res.ok) {
+          if (res.status === 404) {
+            return errorResult(`Merge request !${mrNumber} not found`);
+          }
+          return errorResult(`Failed to get merge request: ${res.statusText}`);
+        }
+        const data = await res.json();
+        let status;
+        if (data.state === "merged") {
+          status = "merged";
+        } else if (data.state === "closed") {
+          status = "closed";
+        } else {
+          status = "open";
+        }
+        return successResult({
+          mr_number: data.iid,
+          title: data.title,
+          status,
+          url: data.web_url,
+          source_branch: data.source_branch,
+          target_branch: data.target_branch,
+          created_at: data.created_at,
+          merged_at: data.merged_at,
+          closed_at: data.closed_at,
+          provider: "gitlab"
+        });
+      }
+    } catch (error) {
+      return errorResult(error instanceof Error ? error.message : "Failed to check MR status");
+    }
+  }
+};
+var listOpenMrsTool = {
+  name: "list_open_mrs",
+  description: "List open merge requests for the repository. Works with both GitHub and GitLab.",
+  inputSchema: z36.object({
+    limit: z36.number().optional().default(10).describe("Maximum number of MRs to return (default: 10)")
+  }),
+  handler: async (args) => {
+    try {
+      const ctx = getGitContext();
+      const limit = args.limit || 10;
+      if (ctx.provider === "github") {
+        const res = await githubRequest(`/repos/${ctx.repoFullName}/pulls?state=open&per_page=${limit}`);
+        if (!res.ok) {
+          return errorResult(`Failed to list pull requests: ${res.statusText}`);
+        }
+        const data = await res.json();
+        const mrs = data.map((pr) => ({
+          mr_number: pr.number,
+          title: pr.title,
+          url: pr.html_url,
+          source_branch: pr.head.ref,
+          target_branch: pr.base.ref,
+          created_at: pr.created_at
+        }));
+        return successResult({
+          mrs,
+          count: mrs.length,
+          provider: "github"
+        });
+      } else {
+        const encodedPath = encodeURIComponent(ctx.repoFullName);
+        const res = await gitlabRequest(`/projects/${encodedPath}/merge_requests?state=opened&per_page=${limit}`);
+        if (!res.ok) {
+          return errorResult(`Failed to list merge requests: ${res.statusText}`);
+        }
+        const data = await res.json();
+        const mrs = data.map((mr) => ({
+          mr_number: mr.iid,
+          title: mr.title,
+          url: mr.web_url,
+          source_branch: mr.source_branch,
+          target_branch: mr.target_branch,
+          created_at: mr.created_at
+        }));
+        return successResult({
+          mrs,
+          count: mrs.length,
+          provider: "gitlab"
+        });
+      }
+    } catch (error) {
+      return errorResult(error instanceof Error ? error.message : "Failed to list open MRs");
+    }
+  }
+};
+var listRepositoryFilesTool = {
+  name: "list_repository_files",
+  description: "List files and directories in the repository. Use this to discover the file structure before reading or modifying files. Works with both GitHub and GitLab.",
+  inputSchema: z36.object({
+    path: z36.string().optional().default("").describe("Directory path to list (empty for root)"),
+    branch: z36.string().optional().describe("Branch to list from (default: main)"),
+    recursive: z36.boolean().optional().default(false).describe("If true, list all files recursively (may be slow for large repos)")
+  }),
+  handler: async (args) => {
+    try {
+      const ctx = getGitContext();
+      const dirPath = args.path || "";
+      const branch = args.branch || "main";
+      const recursive = args.recursive || false;
+      if (ctx.provider === "github") {
+        if (recursive) {
+          const res = await githubRequest(`/repos/${ctx.repoFullName}/git/trees/${branch}?recursive=1`);
+          if (!res.ok) {
+            return errorResult(`Failed to list repository: ${res.statusText}`);
+          }
+          const data = await res.json();
+          let items = data.tree;
+          if (dirPath) {
+            const prefix = dirPath.endsWith("/") ? dirPath : `${dirPath}/`;
+            items = items.filter((item) => item.path.startsWith(prefix));
+          }
+          const files = items.filter((item) => item.type === "blob").map((item) => ({
+            path: item.path,
+            type: "file",
+            size: item.size
+          }));
+          const dirs = items.filter((item) => item.type === "tree").map((item) => ({
+            path: item.path,
+            type: "directory"
+          }));
+          return successResult({
+            path: dirPath || "/",
+            files: files.slice(0, 200),
+            directories: dirs.slice(0, 100),
+            total_files: files.length,
+            total_directories: dirs.length,
+            truncated: data.truncated || files.length > 200,
+            provider: "github"
+          });
+        } else {
+          const endpoint = dirPath ? `/repos/${ctx.repoFullName}/contents/${dirPath}?ref=${branch}` : `/repos/${ctx.repoFullName}/contents?ref=${branch}`;
+          const res = await githubRequest(endpoint);
+          if (!res.ok) {
+            if (res.status === 404) {
+              return errorResult(`Directory not found: ${dirPath || "/"}`);
+            }
+            return errorResult(`Failed to list directory: ${res.statusText}`);
+          }
+          const data = await res.json();
+          const files = data.filter((item) => item.type === "file").map((item) => ({
+            name: item.name,
+            path: item.path,
+            type: "file",
+            size: item.size
+          }));
+          const directories = data.filter((item) => item.type === "dir").map((item) => ({
+            name: item.name,
+            path: item.path,
+            type: "directory"
+          }));
+          return successResult({
+            path: dirPath || "/",
+            files,
+            directories,
+            provider: "github"
+          });
+        }
+      } else {
+        const encodedPath = encodeURIComponent(ctx.repoFullName);
+        const pathParam = dirPath ? `&path=${encodeURIComponent(dirPath)}` : "";
+        const recursiveParam = recursive ? "&recursive=true" : "";
+        const res = await gitlabRequest(`/projects/${encodedPath}/repository/tree?ref=${branch}${pathParam}${recursiveParam}&per_page=100`);
+        if (!res.ok) {
+          if (res.status === 404) {
+            return errorResult(`Directory not found: ${dirPath || "/"}`);
+          }
+          return errorResult(`Failed to list directory: ${res.statusText}`);
+        }
+        const data = await res.json();
+        const files = data.filter((item) => item.type === "blob").map((item) => ({
+          name: item.name,
+          path: item.path,
+          type: "file"
+        }));
+        const directories = data.filter((item) => item.type === "tree").map((item) => ({
+          name: item.name,
+          path: item.path,
+          type: "directory"
+        }));
+        return successResult({
+          path: dirPath || "/",
+          files,
+          directories,
+          provider: "gitlab"
+        });
+      }
+    } catch (error) {
+      return errorResult(error instanceof Error ? error.message : "Failed to list repository files");
+    }
+  }
+};
+
+// ../../libraries/mcp-tools/dist/tools/index.js
+var allTools = [
+  // Analysis
+  analyzeFlowTool,
+  analyzeFunnelTool,
+  // Comparison
+  compareCohortsTool,
+  comparePeriodsTool,
+  // Detection
+  detectDriftTool,
+  detectRegressionsTool,
+  // Diagnostic
+  runFullDiagnosticTool,
+  investigateIssueTool,
+  validateIssueTool,
+  // Discovery
+  discoverPersonasTool,
+  // Get tools
+  getActionableIssuesTool,
+  getAnomaliesTool,
+  getConsoleErrorsTool,
+  getDeadClicksTool,
+  getDomainsTool,
+  getElementFrictionTool,
+  getFlowFrictionTool,
+  getFormFrictionTool,
+  getIssuesTool,
+  getJourneyPatternsTool,
+  getPageMetricsTool,
+  getPageTrendsTool,
+  getSessionDetailsTool,
+  getSessionPagesTool,
+  getUxHealthReportTool,
+  getUpgradeOptionsTool,
+  // Improvement run
+  startImprovementRunTool,
+  updateImprovementRunTool,
+  recordImprovementActionTool,
+  updateImprovementActionTool,
+  getImprovementRunTool,
+  listImprovementRunsTool,
+  // Knowledge
+  getSiteKnowledgeTool,
+  addSiteKnowledgeTool,
+  deleteSiteKnowledgeTool,
+  getSimilarFixesTool,
+  // List
+  listPagesTool,
+  listSessionsTool,
+  // Prediction
+  predictOutcomesTool,
+  // Remediation
+  proposeFixTool,
+  listPendingFixesTool,
+  listRemediationsTool,
+  confirmDeploymentTool,
+  evaluateFixTool,
+  getFixHistoryTool,
+  updateRemediationStatusTool,
+  listRemediationsByStatusTool,
+  getRemediationByPrTool,
+  // Scan
+  scanSiteTool,
+  // Search
+  searchSessionsTool,
+  // Triage
+  dismissIssueTool,
+  markIntendedBehaviorTool,
+  getIssueHistoryTool,
+  triageSessionsTool,
+  // Proposal (audit mode)
+  createProposalTool,
+  listProposalsTool,
+  getProposalTool,
+  resolveProposalTool,
+  dismissProposalTool,
+  evaluateProposalTool,
+  listPendingProposalsTool,
+  listProposalsForEvaluationTool,
+  // Git (provider-agnostic)
+  createBranchTool,
+  getFileContentTool,
+  updateFileTool,
+  createMergeRequestTool,
+  checkMrStatusTool,
+  listOpenMrsTool,
+  listRepositoryFilesTool
+];
+var EXPOSED_TOOL_NAMES = [
+  "get_domains",
+  "run_full_diagnostic",
+  "triage_sessions",
+  "get_upgrade_options",
+  "search_tools",
+  "call_tool",
+  "memory_save",
+  "memory_recall",
+  "memory_list",
+  "memory_delete",
+  "memory_clear"
+];
+var exposedTools = allTools.filter((t) => EXPOSED_TOOL_NAMES.includes(t.name));
+var hiddenTools = allTools.filter((t) => !EXPOSED_TOOL_NAMES.includes(t.name));
+
+// src/tools/catalog/searchTools.ts
+import { z as z37 } from "zod";
+import { readFileSync } from "fs";
+import { fileURLToPath } from "url";
+import { dirname, join } from "path";
+var __filename2 = fileURLToPath(import.meta.url);
+var __dirname2 = dirname(__filename2);
+var _catalog = null;
+function loadCatalog() {
+  if (_catalog) return _catalog;
+  try {
+    const catalogPath = join(__dirname2, "toolCatalog.json");
+    const raw = readFileSync(catalogPath, "utf-8");
+    _catalog = JSON.parse(raw);
+    return _catalog;
+  } catch {
+    console.warn(
+      "[searchTools] Failed to load toolCatalog.json, using empty catalog"
+    );
+    _catalog = [];
+    return _catalog;
+  }
+}
+function cosineSimilarity(a, b) {
+  if (a.length === 0 || b.length === 0 || a.length !== b.length) return 0;
+  let dot = 0;
+  for (let i = 0; i < a.length; i++) {
+    dot += a[i] * b[i];
+  }
+  return dot;
+}
+function searchByKeyword(query, limit) {
+  const catalog = loadCatalog();
+  const normalizedQuery = query.toLowerCase();
+  const queryWords = normalizedQuery.split(/[\s_-]+/).filter((w) => w.length >= 2);
+  const queryPhrases = [normalizedQuery];
+  const synonyms = {
+    error: ["console", "js", "javascript", "bug", "crash", "exception"],
+    page: ["pages", "route", "url", "path"],
+    user: ["users", "session", "visitor"],
+    click: ["clicks", "tap", "press", "rage"],
+    form: ["forms", "input", "field", "submit"],
+    flow: ["flows", "journey", "funnel", "navigation", "path"],
+    issue: ["issues", "problem", "bug", "friction"],
+    fix: ["fixes", "remediation", "repair", "resolve"],
+    compare: ["comparison", "diff", "versus", "cohort"],
+    health: ["score", "metrics", "ux"],
+    dead: ["unresponsive", "broken", "stuck"],
+    rage: ["angry", "frustrated", "frustration"]
+  };
+  const expandedWords = new Set(queryWords);
+  for (const word of queryWords) {
+    if (synonyms[word]) {
+      synonyms[word].forEach((syn) => expandedWords.add(syn));
+    }
+    for (const [key, values] of Object.entries(synonyms)) {
+      if (values.includes(word)) {
+        expandedWords.add(key);
+      }
+    }
+  }
+  return catalog.map((tool) => {
+    const toolName = tool.name.toLowerCase().replace(/_/g, " ");
+    const toolNameParts = tool.name.toLowerCase().split("_");
+    const text = `${toolName} ${tool.description} ${tool.category}`.toLowerCase();
+    let score = 0;
+    for (const phrase of queryPhrases) {
+      if (phrase.length > 3 && text.includes(phrase)) score += 5;
+    }
+    for (const word of expandedWords) {
+      if (toolNameParts.includes(word)) score += 4;
+      if (toolName.includes(word)) score += 3;
+      if (tool.category.toLowerCase() === word) score += 2;
+      if (text.includes(word)) score += 1;
+    }
+    return { tool, score };
+  }).filter((s) => s.score > 0).sort((a, b) => b.score - a.score).slice(0, limit).map((s) => s.tool);
+}
+async function searchBySemantic(query, limit, queryEmbedding) {
+  const catalog = loadCatalog();
+  return catalog.filter((t) => t.embedding && t.embedding.length > 0).map((tool) => ({
+    tool,
+    score: cosineSimilarity(queryEmbedding, tool.embedding)
+  })).sort((a, b) => b.score - a.score).slice(0, limit).map((s) => s.tool);
+}
+async function searchTools2(query, limit = 5, queryEmbedding) {
+  if (queryEmbedding && queryEmbedding.length > 0) {
+    return searchBySemantic(query, limit, queryEmbedding);
+  }
+  return searchByKeyword(query, limit);
+}
+function getToolByName3(name) {
+  return loadCatalog().find((t) => t.name === name);
+}
+var DEFAULT_TOOL_LIMIT = 5;
+var searchToolsSchema = z37.object({
+  query: z37.string().describe(
+    "Natural language description of what data or analysis capability you need. Describe what you want to learn or investigate."
+  ),
+  limit: z37.number().optional().describe("Maximum number of tools to return (default 5)")
+});
+function registerSearchTools(server) {
+  server.registerTool(
+    "search_tools",
+    {
+      description: "Discover analysis tools by describing what data or capability you need. You have access to 40+ specialized tools covering sessions, pages, behaviors, journeys, forms, errors, performance, cohorts, issues, and remediation. Keyword search matches your intent to relevant tools. Returns tool names, descriptions, categories, and parameters. Use call_tool to execute discovered tools.",
+      inputSchema: searchToolsSchema
+    },
+    async ({ query, limit }) => {
+      const searchLimit = limit ?? DEFAULT_TOOL_LIMIT;
+      const matches = await searchTools2(query, searchLimit);
+      if (matches.length === 0) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify({
+                tools: [],
+                message: "No matching tools found. Try rephrasing your query or use broader terms like 'page', 'session', 'issue', 'flow', or 'form'."
+              })
+            }
+          ]
+        };
+      }
+      const tools = matches.map((tool) => ({
+        name: tool.name,
+        description: tool.description.length > 250 ? tool.description.slice(0, 250) + "..." : tool.description,
+        category: tool.category,
+        parameters: Object.entries(tool.parameters).map(([name, prop]) => ({
+          name,
+          type: prop.type,
+          required: prop.required ?? false,
+          description: prop.description
+        }))
+      }));
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({
+              tools,
+              usage: "Use call_tool with the tool name and arguments to execute. Example: call_tool({ tool_name: 'get_page_metrics', arguments: { page_path: '/checkout' } })"
+            })
+          }
+        ]
+      };
+    }
+  );
+}
+
+// src/tools/catalog/callTool.ts
+import { z as z38 } from "zod";
+var toolRegistry = /* @__PURE__ */ new Map();
+function registerToolHandler(name, handler) {
+  toolRegistry.set(name, handler);
+}
+var callToolSchema = z38.object({
+  tool_name: z38.string().describe(
+    "The exact name of the tool to call (e.g., 'get_page_metrics', 'analyze_flow', 'compare_cohorts')"
+  ),
+  arguments: z38.record(z38.string(), z38.unknown()).describe(
+    "The arguments to pass to the tool as a JSON object. Check the tool description from search_tools for required parameters."
+  )
+});
+function registerCallTool(server) {
+  server.registerTool(
+    "call_tool",
+    {
+      description: "Execute any analysis tool by name. Use search_tools first to discover available tools, then call them through this proxy. Pass the exact tool name and arguments as a JSON object. Example: call_tool({ tool_name: 'get_page_metrics', arguments: { page_path: '/checkout' } })",
+      inputSchema: callToolSchema
+    },
+    async ({ tool_name, arguments: args }) => {
+      const handler = toolRegistry.get(tool_name);
+      if (!handler) {
+        const catalogEntry = getToolByName3(tool_name);
+        if (catalogEntry) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: JSON.stringify({
+                  error: `Tool "${tool_name}" exists in catalog but is not registered. This may be a server configuration issue.`,
+                  tool_info: {
+                    name: catalogEntry.name,
+                    description: catalogEntry.description,
+                    category: catalogEntry.category
+                  }
+                })
+              }
+            ],
+            isError: true
+          };
+        }
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify({
+                error: `Unknown tool: ${tool_name}`,
+                hint: "Use search_tools to discover available tools first."
+              })
+            }
+          ],
+          isError: true
+        };
+      }
+      try {
+        return await handler(args);
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify({
+                error: `Tool execution failed: ${message}`,
+                tool_name,
+                arguments: args
+              })
+            }
+          ],
+          isError: true
+        };
+      }
+    }
+  );
+}
+
+// src/tools/memory.ts
+import { z as z39 } from "zod";
+var memoryStore = /* @__PURE__ */ new Map();
+function registerMemoryTools(server) {
+  server.registerTool(
+    "memory_save",
+    {
+      description: "Save a value to working memory for later retrieval. Use this to store intermediate results from tool calls that you want to reference later.",
+      inputSchema: z39.object({
+        key: z39.string().describe("Unique key to store the value under"),
+        value: z39.string().describe("Value to store (will be stored as string)"),
+        annotation: z39.string().optional().describe("Optional note about what this data represents")
+      })
+    },
+    async ({
+      key,
+      value,
+      annotation
+    }) => {
+      memoryStore.set(key, {
+        key,
+        value,
+        timestamp: Date.now(),
+        annotation
+      });
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({ success: true, key, size: value.length })
+          }
+        ]
+      };
+    }
+  );
+  server.registerTool(
+    "memory_recall",
+    {
+      description: "Retrieve a value from working memory by key. Use this to access data you previously stored with memory_save.",
+      inputSchema: z39.object({
+        key: z39.string().describe("Key to retrieve")
+      })
+    },
+    async ({ key }) => {
+      const entry = memoryStore.get(key);
+      if (!entry) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify({
+                error: `Key "${key}" not found in memory`
+              })
+            }
+          ],
+          isError: true
+        };
+      }
+      return {
+        content: [
+          {
+            type: "text",
+            text: entry.value
+          }
+        ]
+      };
+    }
+  );
+  server.registerTool(
+    "memory_list",
+    {
+      description: "List all keys currently stored in working memory. Returns key names, sizes, timestamps, and annotations.",
+      inputSchema: z39.object({})
+    },
+    async () => {
+      const entries = [...memoryStore.values()].map((entry) => ({
+        key: entry.key,
+        size: entry.value.length,
+        timestamp: new Date(entry.timestamp).toISOString(),
+        annotation: entry.annotation
+      }));
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({ count: entries.length, entries })
+          }
+        ]
+      };
+    }
+  );
+  server.registerTool(
+    "memory_delete",
+    {
+      description: "Delete a value from working memory by key.",
+      inputSchema: z39.object({
+        key: z39.string().describe("Key to delete")
+      })
+    },
+    async ({ key }) => {
+      const existed = memoryStore.delete(key);
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({ success: true, deleted: existed })
+          }
+        ]
+      };
+    }
+  );
+  server.registerTool(
+    "memory_clear",
+    {
+      description: "Clear all values from working memory. Use with caution.",
+      inputSchema: z39.object({})
+    },
+    async () => {
+      const count = memoryStore.size;
+      memoryStore.clear();
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({ success: true, cleared: count })
+          }
+        ]
+      };
+    }
+  );
+}
+
+// src/index.ts
 function registerToolWithServer(server, tool) {
-    // Use type assertion to avoid "Type instantiation is excessively deep" error
-    // The MCP SDK's complex generic types cause TypeScript to struggle
-    server.tool(tool.name, tool.description, tool.inputSchema.shape, tool.handler);
+  server.tool(
+    tool.name,
+    tool.description,
+    tool.inputSchema.shape,
+    tool.handler
+  );
 }
-/**
- * Register all hidden tools with the call_tool registry.
- */
 function registerHiddenTools() {
-    for (const tool of hiddenTools) {
-        registerToolHandler(tool.name, tool.handler);
-    }
+  for (const tool of hiddenTools) {
+    registerToolHandler(tool.name, tool.handler);
+  }
 }
-// ─────────────────────────────────────────────────────────────────────────────
-// Server Instructions
-// ─────────────────────────────────────────────────────────────────────────────
-const SERVER_INSTRUCTIONS = `# Recapt Behavioral Intelligence
+var SERVER_INSTRUCTIONS = `# Recapt Behavioral Intelligence
 
 This server provides behavioral data from session recordings. Use these tools to understand user behavior, identify UX issues, and find friction points.
 
@@ -56,26 +3177,26 @@ This server provides behavioral data from session recordings. Use these tools to
 
 You have access to 40+ analysis tools. Most are hidden to reduce context size. Use this pattern:
 
-1. **search_tools(query)** — Describe what you need in natural language
-2. **call_tool(tool_name, arguments)** — Execute the discovered tool
+1. **search_tools(query)** \u2014 Describe what you need in natural language
+2. **call_tool(tool_name, arguments)** \u2014 Execute the discovered tool
 
 Example:
 \`\`\`
 search_tools({ query: "analyze user navigation between pages" })
-→ Returns: analyze_flow, analyze_funnel, get_journey_patterns...
+\u2192 Returns: analyze_flow, analyze_funnel, get_journey_patterns...
 
 call_tool({ tool_name: "analyze_flow", arguments: { start_page: "/pricing", end_page: "/checkout" } })
-→ Returns: flow analysis with paths, bottlenecks, friction scores
+\u2192 Returns: flow analysis with paths, bottlenecks, friction scores
 \`\`\`
 
 ## Always-Available Tools
 
 These tools are always visible (no search needed):
-- **get_domains** — List tracked domains (good starting point)
-- **run_full_diagnostic** — Quick site health overview (lightweight, fast)
-- **triage_sessions** — Find sessions needing attention
-- **get_upgrade_options** — Check available plan upgrades and features
-- **memory_*** — Store/retrieve intermediate results
+- **get_domains** \u2014 List tracked domains (good starting point)
+- **run_full_diagnostic** \u2014 Quick site health overview (lightweight, fast)
+- **triage_sessions** \u2014 Find sessions needing attention
+- **get_upgrade_options** \u2014 Check available plan upgrades and features
+- **memory_*** \u2014 Store/retrieve intermediate results
 
 ## Tier-Based Access
 
@@ -98,9 +3219,9 @@ Use \`get_upgrade_options\` to explain the benefits of upgrading.
 ## Comprehensive Site Analysis
 
 For a full site analysis, run these tools in sequence:
-1. **run_full_diagnostic** — Get health score, issues, problem pages
-2. **detect_regressions** — Check for recent behavioral regressions (separate call)
-3. **get_ux_health_report** — Detailed per-page breakdown if needed
+1. **run_full_diagnostic** \u2014 Get health score, issues, problem pages
+2. **detect_regressions** \u2014 Check for recent behavioral regressions (separate call)
+3. **get_ux_health_report** \u2014 Detailed per-page breakdown if needed
 
 This split approach is faster and more reliable than a single heavy query.
 
@@ -138,41 +3259,41 @@ npx @recapt/mcp skill list
 npx @recapt/mcp skill install self-improvement
 \`\`\`
 Skills provide step-by-step guidance for complex multi-tool workflows.`;
-// ─────────────────────────────────────────────────────────────────────────────
-// Main
-// ─────────────────────────────────────────────────────────────────────────────
 async function main() {
-    console.error("[MCP] Starting recapt behavioral intelligence server...");
-    if (!isApiConfigured()) {
-        console.error("[MCP] ERROR: RECAPT_SECRET_KEY environment variable is required");
-        process.exit(1);
-    }
-    console.error(`[MCP] API URL: ${getApiUrl()}`);
-    const server = new McpServer({
-        name: "recapt",
-        version: "1.0.0",
-    }, {
-        capabilities: { logging: {} },
-        instructions: SERVER_INSTRUCTIONS,
-    });
-    // Register hidden tool handlers first (for call_tool to use)
-    registerHiddenTools();
-    // Register search_tools and call_tool (MCP-specific implementations)
-    registerSearchTools(server);
-    registerCallTool(server);
-    // Register exposed tools from shared library
-    registerToolWithServer(server, getDomainsTool);
-    registerToolWithServer(server, runFullDiagnosticTool);
-    registerToolWithServer(server, triageSessionsTool);
-    registerToolWithServer(server, getUpgradeOptionsTool);
-    // Register memory tools (MCP-specific, stateful per session)
-    registerMemoryTools(server);
-    const transport = new StdioServerTransport();
-    await server.connect(transport);
-    console.error(`[MCP] Server running on stdio (11 exposed tools, ${hiddenTools.length} hidden)`);
-    console.error(`[MCP] Total tools available: ${allTools.length}`);
+  console.error("[MCP] Starting recapt behavioral intelligence server...");
+  if (!isApiConfigured()) {
+    console.error(
+      "[MCP] ERROR: RECAPT_SECRET_KEY environment variable is required"
+    );
+    process.exit(1);
+  }
+  console.error(`[MCP] API URL: ${getApiUrl()}`);
+  const server = new McpServer(
+    {
+      name: "recapt",
+      version: "1.0.0"
+    },
+    {
+      capabilities: { logging: {} },
+      instructions: SERVER_INSTRUCTIONS
+    }
+  );
+  registerHiddenTools();
+  registerSearchTools(server);
+  registerCallTool(server);
+  registerToolWithServer(server, getDomainsTool);
+  registerToolWithServer(server, runFullDiagnosticTool);
+  registerToolWithServer(server, triageSessionsTool);
+  registerToolWithServer(server, getUpgradeOptionsTool);
+  registerMemoryTools(server);
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  console.error(
+    `[MCP] Server running on stdio (11 exposed tools, ${hiddenTools.length} hidden)`
+  );
+  console.error(`[MCP] Total tools available: ${allTools.length}`);
 }
 main().catch((err) => {
-    console.error("[MCP] Fatal error:", err);
-    process.exit(1);
+  console.error("[MCP] Fatal error:", err);
+  process.exit(1);
 });