@recapt/mcp 0.0.45 → 0.0.47

package/dist/index.js

@@ -114,6 +114,711 @@ function apiDelete(path) {
   return request({ method: "DELETE", path });
 }
 
+// ../../libraries/mcp-tools/dist/tools/git.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/git.js
+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}`;
+  const authHeader = ctx.token.startsWith("glpat-") ? { "PRIVATE-TOKEN": ctx.token } : { Authorization: `Bearer ${ctx.token}` };
+  return fetch(url, {
+    ...options,
+    headers: {
+      ...authHeader,
+      "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: z.object({
+    branch_name: z.string().describe("Name of the new branch to create"),
+    from_branch: z.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: z.object({
+    path: z.string().describe("Path to the file in the repository"),
+    branch: z.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. SHA is auto-fetched for existing files.",
+  inputSchema: z.object({
+    path: z.string().describe("Path to the file in the repository"),
+    content: z.string().describe("New content for the file"),
+    message: z.string().describe("Commit message"),
+    branch: z.string().describe("Branch to commit to"),
+    sha: z.string().optional().describe("SHA of the file being replaced (auto-fetched if not provided)")
+  }),
+  handler: async (args) => {
+    try {
+      const ctx = getGitContext();
+      const filePath = args.path;
+      const content = args.content;
+      const message = args.message;
+      const branch = args.branch;
+      let sha = args.sha;
+      if (ctx.provider === "github") {
+        if (!sha) {
+          const checkRes = await githubRequest(`/repos/${ctx.repoFullName}/contents/${filePath}?ref=${branch}`);
+          if (checkRes.ok) {
+            const existingFile = await checkRes.json();
+            sha = existingFile.sha;
+          }
+        }
+        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);
+        let method = "POST";
+        if (!sha) {
+          const checkRes = await gitlabRequest(`/projects/${encodedPath}/repository/files/${encodedFilePath}?ref=${branch}`);
+          if (checkRes.ok) {
+            method = "PUT";
+          }
+        } else {
+          method = "PUT";
+        }
+        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: z.object({
+    title: z.string().describe("Title of the merge request"),
+    description: z.string().describe("Description/body of the merge request"),
+    source_branch: z.string().describe("Branch containing the changes"),
+    target_branch: z.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: z.object({
+    mr_number: z.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: z.object({
+    limit: z.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: z.object({
+    path: z.string().optional().default("").describe("Directory path to list (empty for root)"),
+    branch: z.string().optional().describe("Branch to list from (default: main)"),
+    recursive: z.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");
+    }
+  }
+};
+var getRepoTreeTool = {
+  name: "get_repo_tree",
+  description: "Get a condensed directory-only tree of the repository structure. Returns a nested object showing the folder hierarchy up to a configurable depth. Much faster than recursive list_repository_files for understanding project layout. Use this FIRST to orient yourself, then list_repository_files on specific directories.",
+  inputSchema: z.object({
+    max_depth: z.number().optional().default(4).describe("Maximum directory depth to return (default: 4)"),
+    branch: z.string().optional().describe("Branch to read from (default: main)")
+  }),
+  handler: async (args) => {
+    try {
+      const ctx = getGitContext();
+      const maxDepth = args.max_depth || 4;
+      const branch = args.branch || "main";
+      if (ctx.provider === "github") {
+        const res = await githubRequest(`/repos/${ctx.repoFullName}/git/trees/${branch}?recursive=1`);
+        if (!res.ok) {
+          return errorResult(`Failed to get repo tree: ${res.statusText}`);
+        }
+        const data = await res.json();
+        const dirs = data.tree.filter((item) => item.type === "tree").map((item) => item.path);
+        const tree = buildNestedTree(dirs, maxDepth);
+        const totalDirs = dirs.length;
+        return successResult({
+          tree,
+          total_directories: totalDirs,
+          depth: maxDepth,
+          provider: "github"
+        });
+      } else {
+        const encodedPath = encodeURIComponent(ctx.repoFullName);
+        const res = await gitlabRequest(`/projects/${encodedPath}/repository/tree?ref=${branch}&recursive=true&per_page=100`);
+        if (!res.ok) {
+          return errorResult(`Failed to get repo tree: ${res.statusText}`);
+        }
+        const data = await res.json();
+        const dirs = data.filter((item) => item.type === "tree").map((item) => item.path);
+        const tree = buildNestedTree(dirs, maxDepth);
+        const totalDirs = dirs.length;
+        return successResult({
+          tree,
+          total_directories: totalDirs,
+          depth: maxDepth,
+          provider: "gitlab"
+        });
+      }
+    } catch (error) {
+      return errorResult(error instanceof Error ? error.message : "Failed to get repo tree");
+    }
+  }
+};
+var searchCodeTool = {
+  name: "search_code",
+  description: "Search for code patterns, symbols, or imports across the repository. Use this to find existing conventions, verify import paths, or discover reusable utilities before writing code. Rate-limited (~10 req/min on GitHub) \u2014 use sparingly and with specific queries.",
+  inputSchema: z.object({
+    query: z.string().describe('Search terms (e.g., "import { Button }", "useMemo", "className={styles.")'),
+    path_filter: z.string().optional().describe('Restrict search to a directory (e.g., "client/src/components")'),
+    extension: z.string().optional().describe('Filter by file extension (e.g., "tsx", "ts", "css")')
+  }),
+  handler: async (args) => {
+    try {
+      const ctx = getGitContext();
+      const query = args.query;
+      const pathFilter = args.path_filter;
+      const extension = args.extension;
+      if (ctx.provider === "github") {
+        let q = `${query} repo:${ctx.repoFullName}`;
+        if (pathFilter)
+          q += ` path:${pathFilter}`;
+        if (extension)
+          q += ` extension:${extension}`;
+        const res = await githubRequest(`/search/code?q=${encodeURIComponent(q)}&per_page=10`, {
+          headers: {
+            Accept: "application/vnd.github.text-match+json"
+          }
+        });
+        if (!res.ok) {
+          const err = await res.json();
+          return errorResult(err.message || `Code search failed: ${res.status}`);
+        }
+        const data = await res.json();
+        const results = data.items.map((item) => ({
+          path: item.path,
+          score: item.score,
+          matched_lines: (item.text_matches ?? []).map((m) => m.fragment),
+          url: item.html_url
+        }));
+        return successResult({
+          total_count: data.total_count,
+          results,
+          provider: "github"
+        });
+      } else {
+        const encodedPath = encodeURIComponent(ctx.repoFullName);
+        const searchQuery = pathFilter ? `${query} filename:${pathFilter}` : query;
+        const res = await gitlabRequest(`/projects/${encodedPath}/search?scope=blobs&search=${encodeURIComponent(searchQuery)}&per_page=10`);
+        if (!res.ok) {
+          const err = await res.json();
+          return errorResult(err.message || `Code search failed: ${res.status}`);
+        }
+        const data = await res.json();
+        const results = data.map((item) => ({
+          path: item.path,
+          matched_lines: [item.data],
+          startline: item.startline
+        }));
+        return successResult({
+          total_count: results.length,
+          results,
+          provider: "gitlab"
+        });
+      }
+    } catch (error) {
+      return errorResult(error instanceof Error ? error.message : "Code search failed");
+    }
+  }
+};
+function buildNestedTree(dirs, maxDepth) {
+  const tree = {};
+  for (const dir of dirs) {
+    const parts = dir.split("/");
+    if (parts.length > maxDepth)
+      continue;
+    let current = tree;
+    for (const part of parts) {
+      const key = `${part}/`;
+      if (!current[key]) {
+        current[key] = {};
+      }
+      current = current[key];
+    }
+  }
+  return tree;
+}
+var gitTools = [
+  createBranchTool,
+  getFileContentTool,
+  updateFileTool,
+  createMergeRequestTool,
+  checkMrStatusTool,
+  listOpenMrsTool,
+  listRepositoryFilesTool,
+  getRepoTreeTool,
+  searchCodeTool
+];
+
 // ../../libraries/mcp-tools/dist/handlers.js
 function createApiHandler(method, endpoint, buildParams) {
   return async (args) => {
@@ -260,6 +965,10 @@ function registerAllToolHandlers() {
   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("update_remediation", createApiHandler("PATCH", (args) => `/remediations/${args.remediation_id}`, (args) => {
+    const { remediation_id, ...rest } = args;
+    return rest;
+  }));
   toolHandlers.set("get_site_knowledge", createApiHandler("GET", "/knowledge"));
   toolHandlers.set("add_site_knowledge", createApiHandler("POST", "/knowledge", (args) => ({
     ...args,
@@ -284,6 +993,11 @@ function registerAllToolHandlers() {
     };
   }));
   toolHandlers.set("get_upgrade_options", createApiHandler("GET", "/upgrade-options"));
+  for (const tool of gitTools) {
+    if (tool.handler) {
+      toolHandlers.set(tool.name, tool.handler);
+    }
+  }
 }
 registerAllToolHandlers();
 
@@ -474,32 +1188,14 @@ import { ZodFirstPartyTypeKind as ZodFirstPartyTypeKind2 } from "zod/v3";
 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
+import { z as z2 } from "zod";
 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)")
+  inputSchema: z2.object({
+    start_page: z2.string().optional().describe("Starting page path (e.g., /pricing). Partial match supported."),
+    end_page: z2.string().optional().describe("Ending page path (e.g., /checkout). Partial match supported."),
+    days: z2.number().optional().default(7).describe("Number of days to analyze (default: 7)")
   }),
   handler: async (args) => {
     const { start_page, end_page, days } = args;
@@ -522,13 +1218,13 @@ var analyzeFlowTool = {
 };
 
 // ../../libraries/mcp-tools/dist/tools/analyzeFunnel.js
-import { z as z2 } from "zod";
+import { z as z3 } 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)")
+  inputSchema: z3.object({
+    steps: z3.array(z3.string()).min(2).describe('Ordered page paths forming the funnel (e.g., ["/cart", "/checkout", "/payment"])'),
+    days: z3.number().optional().default(7).describe("Number of days to analyze (default: 7)")
   }),
   handler: async (args) => {
     const { steps, days } = args;
@@ -550,26 +1246,26 @@ var analyzeFunnelTool = {
 };
 
 // ../../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")
+import { z as z4 } from "zod";
+var cohortFilterSchema = z4.object({
+  device: z4.enum(["desktop", "tablet", "mobile"]).optional().describe("Filter by device type"),
+  outcome: z4.enum(["COMPLETED", "STRUGGLED", "BLOCKED", "DISENGAGED"]).optional().describe("Filter by session outcome"),
+  pattern: z4.string().optional().describe("Filter by behavioral pattern"),
+  page_path: z4.string().optional().describe("Filter by page path"),
+  has_friction: z4.boolean().optional().describe("Filter for sessions with friction"),
+  has_rage_clicks: z4.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({
+  inputSchema: z4.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)")
+    cohort_a_label: z4.string().optional().describe("Human label for cohort A"),
+    cohort_b_label: z4.string().optional().describe("Human label for cohort B"),
+    page_path: z4.string().optional().describe("Scope comparison to a specific page"),
+    date_from: z4.string().optional().describe("Start date (ISO format)"),
+    date_to: z4.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;
@@ -593,19 +1289,19 @@ var compareCohortsTool = {
 };
 
 // ../../libraries/mcp-tools/dist/tools/comparePeriods.js
-import { z as z4 } from "zod";
+import { z as z5 } 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)")
+  inputSchema: z5.object({
+    page_path: z5.string().describe("Page path to compare"),
+    period_a: z5.object({
+      from: z5.string().describe("Start date for period A (ISO format)"),
+      to: z5.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)")
+    period_b: z5.object({
+      from: z5.string().describe("Start date for period B (ISO format)"),
+      to: z5.string().describe("End date for period B (ISO format)")
     }).describe("Second time period")
   }),
   handler: async (args) => {
@@ -626,14 +1322,14 @@ var comparePeriodsTool = {
 };
 
 // ../../libraries/mcp-tools/dist/tools/detectDrift.js
-import { z as z5 } from "zod";
+import { z as z6 } 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)")
+  inputSchema: z6.object({
+    page_path: z6.string().optional().describe("Scope drift detection to a specific page"),
+    days: z6.number().optional().default(30).describe("Number of days to analyze (default 30)"),
+    window_size: z6.number().optional().default(7).describe("Size of each time window in days (default 7)")
   }),
   handler: async (args) => {
     const { page_path, days, window_size } = args;
@@ -653,15 +1349,15 @@ var detectDriftTool = {
 };
 
 // ../../libraries/mcp-tools/dist/tools/detectRegressions.js
-import { z as z6 } from "zod";
+import { z as z7 } 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")
+  inputSchema: z7.object({
+    window_hours: z7.number().optional().default(24).describe("How many recent hours to compare against baseline (default 24)"),
+    limit: z7.number().optional().default(50).describe("Number of pages to check per request (default 50, max 100)"),
+    offset: z7.number().optional().default(0).describe("Skip this many pages for pagination (default 0)"),
+    sort_by: z7.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;
@@ -682,12 +1378,12 @@ var detectRegressionsTool = {
 };
 
 // ../../libraries/mcp-tools/dist/tools/diagnostic.js
-import { z as z7 } from "zod";
+import { z as z8 } from "zod";
 var runFullDiagnosticTool = {
   name: "run_full_diagnostic",
   description: "Get a quick site health overview with 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, pages needing attention, and investigation order.",
-  inputSchema: z7.object({
-    days: z7.number().optional().default(7).describe("Number of days to analyze (default: 7)")
+  inputSchema: z8.object({
+    days: z8.number().optional().default(7).describe("Number of days to analyze (default: 7)")
   }),
   handler: async (args) => {
     const { days } = args;
@@ -705,13 +1401,13 @@ var runFullDiagnosticTool = {
 };
 
 // ../../libraries/mcp-tools/dist/tools/discoverPersonas.js
-import { z as z8 } from "zod";
+import { z as z9 } 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)")
+  inputSchema: z9.object({
+    page_path: z9.string().optional().describe("Scope persona discovery to a specific page"),
+    num_personas: z9.number().optional().default(4).describe("Number of personas to discover (default 4, max 8)")
   }),
   handler: async (args) => {
     const { page_path, num_personas } = args;
@@ -730,14 +1426,14 @@ var discoverPersonasTool = {
 };
 
 // ../../libraries/mcp-tools/dist/tools/getAnomalies.js
-import { z as z9 } from "zod";
+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: z9.object({
-    threshold: z9.number().optional().default(0.35).describe("Anomaly threshold (0-1, default: 0.35)"),
-    days: z9.number().optional().default(7).describe("Days to analyze for frustration spikes (default: 7)"),
-    page_path: z9.string().optional().describe("Optional: filter to a specific page")
+  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;
@@ -757,15 +1453,15 @@ var getAnomaliesTool = {
 };
 
 // ../../libraries/mcp-tools/dist/tools/getConsoleErrors.js
-import { z as z10 } from "zod";
+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: z10.object({
-    page_path: z10.string().optional().describe("Filter errors to a specific page path"),
-    session_id: z10.string().optional().describe("Filter errors to a specific session"),
-    severity: z10.enum(["error", "warn", "all"]).optional().default("error").describe('Filter by severity: "error" (default), "warn", or "all"'),
-    limit: z10.number().optional().default(200).describe("Max log documents to scan (default 200)")
+  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;
@@ -786,17 +1482,17 @@ var getConsoleErrorsTool = {
 };
 
 // ../../libraries/mcp-tools/dist/tools/getCustomEvents.js
-import { z as z11 } from "zod";
+import { z as z12 } from "zod";
 var getCustomEventsTool = {
   name: "get_custom_events",
   description: "Query custom events tracked via Recapt.track(). Returns event occurrence counts, which pages they fire on, property distributions, and temporal patterns. Use to answer 'what custom events are being tracked?', 'how often does event X fire?', 'what properties does event Y have?', or 'which pages trigger the most events?'. These are app-specific events the developer explicitly tracks (purchases, signups, feature usage, etc.), not automatically captured behavioral data.",
-  inputSchema: z11.object({
-    event_name: z11.string().optional().describe("Filter by event name (case-insensitive partial match). If omitted, returns all event types."),
-    page_path: z11.string().optional().describe("Filter events to a specific page path (partial match)"),
-    session_id: z11.string().optional().describe("Filter events to a specific session"),
-    property_filters: z11.record(z11.string(), z11.union([z11.string(), z11.number(), z11.boolean(), z11.null()])).optional().describe("Filter events by property values, e.g. { plan: 'pro', amount: 99 }"),
-    days: z11.number().optional().describe("Look back N days (default: 30)"),
-    limit: z11.number().optional().describe("Max documents to scan (default: 500, max: 2000)")
+  inputSchema: z12.object({
+    event_name: z12.string().optional().describe("Filter by event name (case-insensitive partial match). If omitted, returns all event types."),
+    page_path: z12.string().optional().describe("Filter events to a specific page path (partial match)"),
+    session_id: z12.string().optional().describe("Filter events to a specific session"),
+    property_filters: z12.record(z12.string(), z12.union([z12.string(), z12.number(), z12.boolean(), z12.null()])).optional().describe("Filter events by property values, e.g. { plan: 'pro', amount: 99 }"),
+    days: z12.number().optional().describe("Look back N days (default: 30)"),
+    limit: z12.number().optional().describe("Max documents to scan (default: 500, max: 2000)")
   }),
   handler: async (args) => {
     const { event_name, page_path, session_id, property_filters, days, limit } = args;
@@ -823,8 +1519,8 @@ var getCustomEventsTool = {
 var listEventNamesTool = {
   name: "list_event_names",
   description: "List all unique custom event names tracked in the last N days. Use this to discover what events are available before querying specific events.",
-  inputSchema: z11.object({
-    days: z11.number().optional().describe("Look back N days (default: 30)")
+  inputSchema: z12.object({
+    days: z12.number().optional().describe("Look back N days (default: 30)")
   }),
   handler: async (args) => {
     const { days } = args;
@@ -840,16 +1536,16 @@ var listEventNamesTool = {
 };
 
 // ../../libraries/mcp-tools/dist/tools/getSessionComments.js
-import { z as z12 } from "zod";
+import { z as z13 } from "zod";
 var getSessionCommentsTool = {
   name: "get_session_comments",
   description: "Query user comments and feedback submitted during sessions. These are explicit comments users submit via the feedback widget or Recapt.comment() API - direct user voice about their experience. Use to find sessions where users reported issues, understand user sentiment, or identify pages generating the most feedback. Comments often contain valuable context about what frustrated or confused users.",
-  inputSchema: z12.object({
-    session_id: z12.string().optional().describe("Filter comments to a specific session"),
-    page_path: z12.string().optional().describe("Filter comments to a specific page path (partial match)"),
-    search: z12.string().optional().describe("Search comments by text content (case-insensitive partial match)"),
-    days: z12.number().optional().describe("Look back N days (default: 30)"),
-    limit: z12.number().optional().describe("Max comments to return (default: 100, max: 500)")
+  inputSchema: z13.object({
+    session_id: z13.string().optional().describe("Filter comments to a specific session"),
+    page_path: z13.string().optional().describe("Filter comments to a specific page path (partial match)"),
+    search: z13.string().optional().describe("Search comments by text content (case-insensitive partial match)"),
+    days: z13.number().optional().describe("Look back N days (default: 30)"),
+    limit: z13.number().optional().describe("Max comments to return (default: 100, max: 500)")
   }),
   handler: async (args) => {
     const { session_id, page_path, search, days, limit } = args;
@@ -872,8 +1568,8 @@ var getSessionCommentsTool = {
 var getCommentStatsTool = {
   name: "get_comment_stats",
   description: "Get statistics about user comments/feedback. Returns total comment count, which pages receive the most feedback, and daily trend. Use to understand feedback volume and identify pages where users are most vocal.",
-  inputSchema: z12.object({
-    days: z12.number().optional().describe("Look back N days (default: 30)")
+  inputSchema: z13.object({
+    days: z13.number().optional().describe("Look back N days (default: 30)")
   }),
   handler: async (args) => {
     const { days } = args;
@@ -889,12 +1585,12 @@ var getCommentStatsTool = {
 };
 
 // ../../libraries/mcp-tools/dist/tools/getDeadClicks.js
-import { z as z13 } from "zod";
+import { z as z14 } 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: z13.object({
-    page_path: z13.string().describe("Page path to check for dead clicks (required)")
+  inputSchema: z14.object({
+    page_path: z14.string().describe("Page path to check for dead clicks (required)")
   }),
   handler: async (args) => {
     const { page_path } = args;
@@ -912,11 +1608,11 @@ var getDeadClicksTool = {
 };
 
 // ../../libraries/mcp-tools/dist/tools/getDomains.js
-import { z as z14 } from "zod";
+import { z as z15 } 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: z14.object({}),
+  inputSchema: z15.object({}),
   handler: async () => {
     if (!isApiConfigured()) {
       return apiNotConfiguredResult();
@@ -930,13 +1626,13 @@ var getDomainsTool = {
 };
 
 // ../../libraries/mcp-tools/dist/tools/getElementFriction.js
-import { z as z15 } from "zod";
+import { z as z16 } 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: z15.object({
-    page_path: z15.string().describe("Page path to analyze (e.g., /checkout)"),
-    selector_filter: z15.string().optional().describe("Optional: filter elements by selector substring")
+  inputSchema: z16.object({
+    page_path: z16.string().describe("Page path to analyze (e.g., /checkout)"),
+    selector_filter: z16.string().optional().describe("Optional: filter elements by selector substring")
   }),
   handler: async (args) => {
     const { page_path, selector_filter } = args;
@@ -955,14 +1651,14 @@ var getElementFrictionTool = {
 };
 
 // ../../libraries/mcp-tools/dist/tools/getFlowFriction.js
-import { z as z16 } from "zod";
+import { z as z17 } 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: z16.object({
-    page_path: z16.string().optional().describe("Focus on flows involving this page (e.g., /checkout)"),
-    days: z16.number().optional().default(7).describe("Number of days to analyze (default: 7)"),
-    limit: z16.number().optional().default(10).describe("Maximum number of flows to return (default: 10)")
+  inputSchema: z17.object({
+    page_path: z17.string().optional().describe("Focus on flows involving this page (e.g., /checkout)"),
+    days: z17.number().optional().default(7).describe("Number of days to analyze (default: 7)"),
+    limit: z17.number().optional().default(10).describe("Maximum number of flows to return (default: 10)")
   }),
   handler: async (args) => {
     const { page_path, days, limit } = args;
@@ -982,12 +1678,12 @@ var getFlowFrictionTool = {
 };
 
 // ../../libraries/mcp-tools/dist/tools/getFormFriction.js
-import { z as z17 } from "zod";
+import { z as z18 } 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: z17.object({
-    page_path: z17.string().describe("Page path containing the form to analyze (required)")
+  inputSchema: z18.object({
+    page_path: z18.string().describe("Page path containing the form to analyze (required)")
   }),
   handler: async (args) => {
     const { page_path } = args;
@@ -1005,13 +1701,13 @@ var getFormFrictionTool = {
 };
 
 // ../../libraries/mcp-tools/dist/tools/getJourneyPatterns.js
-import { z as z18 } from "zod";
+import { z as z19 } 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)")
+  inputSchema: z19.object({
+    page_path: z19.string().optional().describe("Filter to transitions involving this page (e.g., /pricing)"),
+    days: z19.number().optional().default(7).describe("Number of days to analyze (default: 7)")
   }),
   handler: async (args) => {
     const { page_path, days } = args;
@@ -1030,13 +1726,13 @@ var getJourneyPatternsTool = {
 };
 
 // ../../libraries/mcp-tools/dist/tools/getPageMetrics.js
-import { z as z19 } from "zod";
+import { z as z20 } 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)")
+  inputSchema: z20.object({
+    page_path: z20.string().optional().describe("Page path to get metrics for (e.g., /checkout). Omit to get all pages."),
+    days: z20.number().optional().default(7).describe("Number of days to look back (default: 7)")
   }),
   handler: async (args) => {
     const { page_path, days } = args;
@@ -1055,13 +1751,13 @@ var getPageMetricsTool = {
 };
 
 // ../../libraries/mcp-tools/dist/tools/getPageTrends.js
-import { z as z20 } from "zod";
+import { z as z21 } 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)")
+  inputSchema: z21.object({
+    page_path: z21.string().describe("Page path to analyze (e.g., /checkout)"),
+    days: z21.number().optional().default(14).describe("Number of days to look back (default: 14)")
   }),
   handler: async (args) => {
     const { page_path, days } = args;
@@ -1080,13 +1776,13 @@ var getPageTrendsTool = {
 };
 
 // ../../libraries/mcp-tools/dist/tools/getSessionDetails.js
-import { z as z21 } from "zod";
+import { z as z22 } 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.preprocess((val) => {
+  inputSchema: z22.object({
+    session_id: z22.string().optional().describe("Single session ID to get details for"),
+    session_ids: z22.preprocess((val) => {
       if (typeof val === "string") {
         try {
           return JSON.parse(val);
@@ -1095,7 +1791,7 @@ var getSessionDetailsTool = {
         }
       }
       return val;
-    }, z21.array(z21.string()).max(20).optional()).describe("Array of session IDs to get details for (max 20)")
+    }, z22.array(z22.string()).max(20).optional()).describe("Array of session IDs to get details for (max 20)")
   }),
   handler: async (args) => {
     const { session_id, session_ids } = args;
@@ -1124,13 +1820,13 @@ var getSessionDetailsTool = {
 };
 
 // ../../libraries/mcp-tools/dist/tools/getSessionPages.js
-import { z as z22 } from "zod";
+import { z as z23 } 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.preprocess((val) => {
+  inputSchema: z23.object({
+    session_id: z23.string().optional().describe("Single session ID to get pages for"),
+    session_ids: z23.preprocess((val) => {
       if (typeof val === "string") {
         try {
           return JSON.parse(val);
@@ -1139,7 +1835,7 @@ var getSessionPagesTool = {
         }
       }
       return val;
-    }, z22.array(z22.string()).max(20).optional()).describe("Array of session IDs to get pages for (max 20)")
+    }, z23.array(z23.string()).max(20).optional()).describe("Array of session IDs to get pages for (max 20)")
   }),
   handler: async (args) => {
     const { session_id, session_ids } = args;
@@ -1168,13 +1864,13 @@ var getSessionPagesTool = {
 };
 
 // ../../libraries/mcp-tools/dist/tools/getUxHealthReport.js
-import { z as z23 } from "zod";
+import { z as z24 } 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)")
+  inputSchema: z24.object({
+    page_path: z24.string().optional().describe("Focus on a specific page (omit for site-wide report)"),
+    days: z24.number().optional().default(7).describe("Number of days to analyze (default: 7)")
   }),
   handler: async (args) => {
     const { page_path, days } = args;
@@ -1193,7 +1889,7 @@ var getUxHealthReportTool = {
 };
 
 // ../../libraries/mcp-tools/dist/tools/upgradeOptions.js
-import { z as z24 } from "zod";
+import { z as z25 } from "zod";
 function formatUpgradeOptions(data) {
   const lines = [];
   lines.push("# UPGRADE OPTIONS\n");
@@ -1225,7 +1921,7 @@ function formatUpgradeOptions(data) {
 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({}),
+  inputSchema: z25.object({}),
   handler: async () => {
     if (!isApiConfigured()) {
       return apiNotConfiguredResult();
@@ -1240,16 +1936,16 @@ var getUpgradeOptionsTool = {
 };
 
 // ../../libraries/mcp-tools/dist/tools/improvementRun.js
-import { z as z25 } from "zod";
+import { z as z26 } 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")
+  inputSchema: z26.object({
+    trigger_type: z26.enum(["github_actions", "cron", "manual", "api"]).describe("What triggered this improvement run"),
+    trigger_metadata: z26.record(z26.unknown()).optional().describe("Additional metadata about the trigger (e.g., GitHub run ID, branch, actor)"),
+    phases: z26.array(z26.object({
+      name: z26.string(),
+      status: z26.enum(["pending", "running", "completed", "skipped", "failed"]).default("pending")
     })).optional().describe("Initial phases to track (e.g., diagnose, investigate, fix)")
   }),
   handler: async (args) => {
@@ -1271,38 +1967,38 @@ var startImprovementRunTool = {
 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 user-friendly title summarizing what was improved (e.g., 'Fixed checkout responsiveness, improved mobile navigation'). Avoid technical jargon - write for non-developers."),
-    phases: z25.array(z25.object({
-      name: z25.string(),
-      status: z25.enum([
+  inputSchema: z26.object({
+    run_id: z26.string().describe("The ID of the improvement run to update"),
+    status: z26.enum(["running", "completed", "failed", "cancelled"]).optional().describe("New status for the run"),
+    title: z26.string().optional().describe("A user-friendly title summarizing what was improved (e.g., 'Fixed checkout responsiveness, improved mobile navigation'). Avoid technical jargon - write for non-developers."),
+    phases: z26.array(z26.object({
+      name: z26.string(),
+      status: z26.enum([
         "pending",
         "running",
         "completed",
         "skipped",
         "failed"
       ]),
-      startedAt: z25.string().nullable().optional(),
-      completedAt: z25.string().nullable().optional(),
-      output: z25.record(z25.unknown()).optional()
+      startedAt: z26.string().nullable().optional(),
+      completedAt: z26.string().nullable().optional(),
+      output: z26.record(z26.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()
+    summary: z26.object({
+      issuesFound: z26.number().optional(),
+      issuesFixed: z26.number().optional(),
+      issuesDeferred: z26.number().optional(),
+      issuesDismissed: z26.number().optional(),
+      prsCreated: z26.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")
+    diagnostic: z26.object({
+      healthScore: z26.number().describe("Site health score (0-100)"),
+      totalSessions: z26.number().describe("Number of sessions analyzed"),
+      pagesAnalyzed: z26.number().describe("Number of pages with data"),
+      summary: z26.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")
+    completed_at: z26.string().optional().describe("ISO timestamp when the run completed"),
+    duration_ms: z26.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;
@@ -1327,35 +2023,35 @@ var updateImprovementRunTool = {
 var recordImprovementActionTool = {
   name: "record_improvement_action",
   description: "Record an action taken during an improvement run. REQUIRED: run_id, action_type, hypothesis, expected_improvement. For code_fix: include code_changes array with actual unified diff format (not descriptions). For needs_more_data: include deferral_reason. For dismissed: include dismissal_reason. Use expected_improvement='N/A' for non-fix actions.",
-  inputSchema: z25.object({
-    run_id: z25.string().describe("REQUIRED. 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([
+  inputSchema: z26.object({
+    run_id: z26.string().describe("REQUIRED. The ID of the improvement run"),
+    issue_id: z26.string().optional().describe("The ID of the issue this action relates to (if any)"),
+    action_type: z26.enum([
       "code_fix",
       "needs_more_data",
       "dismissed",
       "marked_intended",
       "knowledge_added"
     ]).describe("REQUIRED. Type of action taken"),
-    hypothesis: z25.string().describe("REQUIRED. AI's reasoning for this action"),
-    expected_improvement: z25.string().describe("REQUIRED. What improvement is expected (use 'N/A' for non-fix actions)"),
-    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")
+    hypothesis: z26.string().describe("REQUIRED. AI's reasoning for this action"),
+    expected_improvement: z26.string().describe("REQUIRED. What improvement is expected (use 'N/A' for non-fix actions)"),
+    code_changes: z26.array(z26.object({
+      file: z26.string().describe("Path to the changed file"),
+      diff: z26.string().describe("Unified diff format code changes"),
+      startLine: z26.number().describe("Line number where the diff begins"),
+      linesAdded: z26.number().default(0).describe("Count of lines added"),
+      linesRemoved: z26.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")
+    pr_url: z26.string().optional().describe("GitHub PR URL if a PR was created"),
+    pr_number: z26.number().optional().describe("GitHub PR number"),
+    remediation_id: z26.string().optional().describe("ID of the associated remediation record (if any)"),
+    deferral_reason: z26.string().optional().describe("Explanation for why the issue was deferred (for needs_more_data actions)"),
+    dismissal_reason: z26.string().optional().describe("Explanation for why the issue was dismissed (for dismissed/marked_intended actions)"),
+    page_path: z26.string().optional().describe("Page path affected by the fix"),
+    element_selector: z26.string().optional().describe("CSS selector of the affected element"),
+    diagnosis: z26.string().optional().describe("Root cause analysis"),
+    proposed_fix: z26.string().optional().describe("Fix description"),
+    confidence: z26.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;
@@ -1394,11 +2090,11 @@ var recordImprovementActionTool = {
 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")
+  inputSchema: z26.object({
+    run_id: z26.string().describe("The ID of the improvement run"),
+    action_id: z26.string().describe("The ID of the action to update"),
+    pr_url: z26.string().optional().describe("GitHub PR URL to link to this action"),
+    pr_number: z26.number().optional().describe("GitHub PR number to link to this action")
   }),
   handler: async (args) => {
     const { run_id, action_id, pr_url, pr_number } = args;
@@ -1418,8 +2114,8 @@ var updateImprovementActionTool = {
 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")
+  inputSchema: z26.object({
+    run_id: z26.string().describe("The ID of the improvement run to retrieve")
   }),
   handler: async (args) => {
     const { run_id } = args;
@@ -1436,11 +2132,11 @@ var getImprovementRunTool = {
 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")
+  inputSchema: z26.object({
+    status: z26.enum(["running", "completed", "failed", "cancelled"]).optional().describe("Filter by run status"),
+    trigger_type: z26.enum(["github_actions", "cron", "manual", "api"]).optional().describe("Filter by trigger type"),
+    limit: z26.number().optional().default(20).describe("Maximum number of results (default: 20)"),
+    offset: z26.number().optional().default(0).describe("Offset for pagination")
   }),
   handler: async (args) => {
     const { status, trigger_type, limit, offset } = args;
@@ -1461,7 +2157,7 @@ var listImprovementRunsTool = {
 };
 
 // ../../libraries/mcp-tools/dist/tools/knowledge.js
-import { z as z26 } from "zod";
+import { z as z27 } from "zod";
 var KNOWLEDGE_CATEGORIES = [
   "false_positive",
   "intended_behavior",
@@ -1481,11 +2177,11 @@ var ISSUE_CATEGORIES = [
 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)")
+  inputSchema: z27.object({
+    category: z27.enum(KNOWLEDGE_CATEGORIES).optional().describe("Filter by knowledge category"),
+    page_path: z27.string().optional().describe("Filter by page path"),
+    issue_category: z27.enum(ISSUE_CATEGORIES).optional().describe("Filter by issue category"),
+    limit: z27.number().optional().default(50).describe("Maximum number of entries to return (default: 50)")
   }),
   handler: async (args) => {
     const { category, page_path, issue_category, limit } = args;
@@ -1507,13 +2203,13 @@ var getSiteKnowledgeTool = {
 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)")
+  inputSchema: z27.object({
+    category: z27.enum(KNOWLEDGE_CATEGORIES).describe("Category of knowledge: false_positive, intended_behavior, fix_pattern, or context"),
+    subject: z27.string().describe("Unique identifier/title for this knowledge entry"),
+    content: z27.string().describe("Detailed description of the learning"),
+    page_path: z27.string().optional().describe("Associated page path (if applicable)"),
+    element_selector: z27.string().optional().describe("Associated element selector (if applicable)"),
+    issue_category: z27.enum(ISSUE_CATEGORIES).optional().describe("Associated issue category (if applicable)")
   }),
   handler: async (args) => {
     const { category, subject, content, page_path, element_selector, issue_category } = args;
@@ -1538,8 +2234,8 @@ var addSiteKnowledgeTool = {
 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")
+  inputSchema: z27.object({
+    knowledge_id: z27.string().describe("The ID of the knowledge entry to delete")
   }),
   handler: async (args) => {
     const { knowledge_id } = args;
@@ -1555,13 +2251,13 @@ var deleteSiteKnowledgeTool = {
 };
 
 // ../../libraries/mcp-tools/dist/tools/listPages.js
-import { z as z27 } from "zod";
+import { z as z28 } 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)")
+  inputSchema: z28.object({
+    days: z28.number().optional().default(7).describe("Number of days to look back (default 7)"),
+    limit: z28.number().optional().default(50).describe("Maximum number of pages to return (default 50)")
   }),
   handler: async (args) => {
     const { days, limit } = args;
@@ -1580,16 +2276,16 @@ var listPagesTool = {
 };
 
 // ../../libraries/mcp-tools/dist/tools/listSessions.js
-import { z as z28 } from "zod";
+import { z as z29 } 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)")
+  inputSchema: z29.object({
+    domain: z29.string().optional().describe("Filter by domain name (partial match supported)"),
+    status: z29.enum(["active", "terminated", "all"]).optional().default("all").describe("Filter by session status"),
+    device: z29.enum(["desktop", "mobile", "tablet"]).optional().describe("Filter by device type"),
+    days: z29.number().optional().default(7).describe("Number of days to look back (default: 7)"),
+    limit: z29.number().optional().default(20).describe("Maximum sessions to return (default: 20, max: 200)")
   }),
   handler: async (args) => {
     const { domain, status, device, days, limit } = args;
@@ -1611,16 +2307,16 @@ var listSessionsTool = {
 };
 
 // ../../libraries/mcp-tools/dist/tools/predictOutcomes.js
-import { z as z29 } from "zod";
+import { z as z30 } 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)")
+  inputSchema: z30.object({
+    session_id: z30.string().optional().describe("Session ID to analyze and predict outcome for"),
+    behavioral_features: z30.object({
+      frustration: z30.number().describe("Frustration score (0-1)"),
+      confusion: z30.number().describe("Confusion score (0-1)"),
+      confidence: z30.number().describe("Confidence score (0-1)")
     }).optional().describe("Behavioral features to use for prediction")
   }),
   handler: async (args) => {
@@ -1643,13 +2339,13 @@ var predictOutcomesTool = {
 };
 
 // ../../libraries/mcp-tools/dist/tools/remediation.js
-import { z as z30 } from "zod";
+import { z as z31 } from "zod";
 var proposeFixTool = {
   name: "propose_fix",
   description: "Propose a fix for a UX issue. REQUIRED: page_path, diagnosis, proposed_fix, confidence. Creates a remediation record with baseline metrics for later evaluation. Returns remediation_id for tracking.",
-  inputSchema: z30.object({
-    page_path: z30.string().describe("REQUIRED. The page path where the issue occurs"),
-    category: z30.enum([
+  inputSchema: z31.object({
+    page_path: z31.string().describe("REQUIRED. The page path where the issue occurs"),
+    category: z31.enum([
       "code_error",
       "dead_click",
       "rage_click",
@@ -1659,26 +2355,32 @@ var proposeFixTool = {
       "behavioral_anomaly",
       "structural_issue"
     ]).optional().describe("The issue category"),
-    severity: z30.enum(["critical", "high", "medium", "low", "info"]).optional().describe("The issue severity"),
-    diagnosis: z30.string().describe("REQUIRED. Detailed analysis of the root cause of the issue"),
-    proposed_fix: z30.string().describe("REQUIRED. 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("REQUIRED. Confidence level in the fix (0-1). Use <0.7 when uncertain."),
-    title: z30.string().optional().describe("User-friendly title describing the issue from the user's perspective"),
-    execution_metadata: z30.object({
-      difficulty_class: z30.enum(["trivial", "light", "heavy"]),
-      difficulty_reasoning: z30.string(),
-      model_used: z30.string(),
-      was_escalated: z30.boolean().optional(),
-      escalation_reason: z30.string().optional(),
-      iterations: z30.number().optional(),
-      credits_used: z30.number().optional(),
-      duration_ms: z30.number().optional()
+    severity: z31.enum(["critical", "high", "medium", "low", "info"]).optional().describe("The issue severity"),
+    diagnosis: z31.string().describe("REQUIRED. Detailed analysis of the root cause of the issue"),
+    proposed_fix: z31.string().describe("REQUIRED. Description of the proposed fix and how it addresses the root cause"),
+    code_snippet: z31.string().optional().describe("Suggested code changes (if applicable)"),
+    affected_files: z31.array(z31.string()).optional().describe("List of files that need to be modified"),
+    code_changes: z31.array(z31.object({
+      file: z31.string().describe("File path relative to repository root"),
+      content: z31.string().optional().describe("New content for the file"),
+      diff: z31.string().optional().describe("Unified diff format"),
+      description: z31.string().optional().describe("Description of the change")
+    })).optional().describe("Detailed code changes with file contents for programmatic PR creation"),
+    confidence: z31.number().min(0).max(1).describe("REQUIRED. Confidence level in the fix (0-1). Use <0.7 when uncertain."),
+    title: z31.string().optional().describe("User-friendly title describing the issue from the user's perspective"),
+    execution_metadata: z31.object({
+      difficulty_class: z31.enum(["trivial", "light", "heavy"]),
+      difficulty_reasoning: z31.string(),
+      model_used: z31.string(),
+      was_escalated: z31.boolean().optional(),
+      escalation_reason: z31.string().optional(),
+      iterations: z31.number().optional(),
+      credits_used: z31.number().optional(),
+      duration_ms: z31.number().optional()
     }).optional().describe("AI execution metadata for tracking model selection and performance")
   }),
   handler: async (args) => {
-    const { page_path, category, severity, diagnosis, proposed_fix, code_snippet, affected_files, confidence, title, execution_metadata } = args;
+    const { page_path, category, severity, diagnosis, proposed_fix, code_snippet, affected_files, code_changes, confidence, title, execution_metadata } = args;
     if (!isApiConfigured()) {
       return apiNotConfiguredResult();
     }
@@ -1690,6 +2392,7 @@ var proposeFixTool = {
       proposed_fix,
       code_snippet,
       affected_files,
+      code_changes,
       confidence,
       title,
       execution_metadata
@@ -1703,7 +2406,7 @@ var proposeFixTool = {
 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({}),
+  inputSchema: z31.object({}),
   handler: async () => {
     if (!isApiConfigured()) {
       return apiNotConfiguredResult();
@@ -1718,20 +2421,19 @@ var listPendingFixesTool = {
 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",
+  inputSchema: z31.object({
+    status: z31.enum([
+      "pending",
       "deployed",
       "evaluating",
       "succeeded",
       "failed",
-      "reverted",
-      "deferred"
+      "dismissed",
+      "deferred",
+      "reverted"
     ]).optional().describe("Filter by remediation status"),
-    page_path: z30.string().optional().describe("Filter by page path"),
-    category: z30.enum([
+    page_path: z31.string().optional().describe("Filter by page path"),
+    category: z31.enum([
       "code_error",
       "dead_click",
       "rage_click",
@@ -1741,10 +2443,11 @@ var listRemediationsTool = {
       "behavioral_anomaly",
       "structural_issue"
     ]).optional().describe("Filter by issue category"),
-    limit: z30.number().optional().default(20).describe("Maximum number of results (default: 20)")
+    kind: z31.enum(["fix", "proposal"]).optional().describe("Filter by kind: 'fix' for code fixes, 'proposal' for audit suggestions"),
+    limit: z31.number().optional().default(20).describe("Maximum number of results (default: 20)")
   }),
   handler: async (args) => {
-    const { status, page_path, category, limit } = args;
+    const { status, page_path, category, kind, limit } = args;
     if (!isApiConfigured()) {
       return apiNotConfiguredResult();
     }
@@ -1752,6 +2455,7 @@ var listRemediationsTool = {
       status,
       page_path,
       category,
+      kind,
       limit: limit ?? 20
     });
     if (error) {
@@ -1763,8 +2467,8 @@ var listRemediationsTool = {
 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")
+  inputSchema: z31.object({
+    remediation_id: z31.string().describe("The ID of the remediation to mark as deployed")
   }),
   handler: async (args) => {
     const { remediation_id } = args;
@@ -1781,10 +2485,10 @@ var confirmDeploymentTool = {
 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)"),
-    skip_status_update: z30.boolean().optional().default(false).describe("When true, skips writing remediation status (used in phased mode where applyEvaluateUpdates is authoritative)")
+  inputSchema: z31.object({
+    remediation_id: z31.string().describe("The ID of the remediation to evaluate"),
+    min_hours: z31.number().optional().default(24).describe("Minimum hours since deployment required (default: 24)"),
+    skip_status_update: z31.boolean().optional().default(false).describe("When true, skips writing remediation status (used in phased mode where applyEvaluateUpdates is authoritative)")
   }),
   handler: async (args) => {
     const { remediation_id, min_hours, skip_status_update } = args;
@@ -1803,14 +2507,14 @@ var evaluateFixTool = {
 };
 var updateRemediationStatusTool = {
   name: "update_remediation_status",
-  description: "Update remediation status based on PR events. REQUIRED: remediation_id, status. Status values: 'waiting' (PR created), 'deployed' (PR merged), 'dismissed' (PR closed without merge).",
-  inputSchema: z30.object({
-    remediation_id: z30.string().describe("REQUIRED. The ID of the remediation to update"),
-    status: z30.enum(["waiting", "deployed", "dismissed"]).describe("REQUIRED. One of: waiting, deployed, dismissed"),
-    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")
+  description: "Update remediation status based on PR events. REQUIRED: remediation_id, status. Status values: 'deployed' (PR merged), 'dismissed' (PR closed without merge). Note: Remediations with open PRs stay in 'pending' status - use PR fields to track PR state.",
+  inputSchema: z31.object({
+    remediation_id: z31.string().describe("REQUIRED. The ID of the remediation to update"),
+    status: z31.enum(["deployed", "dismissed"]).describe("REQUIRED. One of: deployed, dismissed"),
+    pr_url: z31.string().optional().describe("URL of the pull request"),
+    pr_number: z31.number().optional().describe("PR number"),
+    pr_merged_at: z31.string().optional().describe("ISO timestamp when PR was merged"),
+    pr_closed_at: z31.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;
@@ -1832,28 +2536,29 @@ var updateRemediationStatusTool = {
 };
 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. Set include_execution to get difficulty classification for model selection.",
-  inputSchema: z30.object({
-    statuses: z30.array(z30.enum([
-      "proposed",
-      "waiting",
-      "dismissed",
+  description: "List remediations filtered by one or more statuses. Use to find 'pending' fixes with open PRs or 'deployed' fixes ready for evaluation. To find remediations awaiting PR merge, query for 'pending' status and check prUrl field. Set include_execution to get difficulty classification for model selection.",
+  inputSchema: z31.object({
+    statuses: z31.array(z31.enum([
+      "pending",
       "deployed",
       "evaluating",
       "succeeded",
       "failed",
-      "reverted",
-      "deferred"
+      "dismissed",
+      "deferred",
+      "reverted"
     ])).describe("List of statuses to filter by"),
-    include_execution: z30.boolean().optional().describe("Include execution metadata (difficulty class, model used) for each remediation")
+    kind: z31.enum(["fix", "proposal"]).optional().describe("Filter by kind: 'fix' for code fixes, 'proposal' for audit suggestions"),
+    include_execution: z31.boolean().optional().describe("Include execution metadata (difficulty class, model used) for each remediation")
   }),
   handler: async (args) => {
-    const { statuses, include_execution } = args;
+    const { statuses, kind, include_execution } = args;
     if (!isApiConfigured()) {
       return apiNotConfiguredResult();
     }
     const { data, error } = await apiGet(`/remediations/by-status`, {
       statuses: statuses.join(","),
+      kind,
       include_execution: include_execution ? "true" : void 0
     });
     if (error) {
@@ -1865,8 +2570,8 @@ var listRemediationsByStatusTool = {
 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")
+  inputSchema: z31.object({
+    pr_number: z31.number().describe("The PR number to look up")
   }),
   handler: async (args) => {
     const { pr_number } = args;
@@ -1880,15 +2585,51 @@ var getRemediationByPrTool = {
     return successResult(data);
   }
 };
+var updateRemediationTool = {
+  name: "update_remediation",
+  description: "Update an existing remediation with new information. Use to add code changes, update the proposed fix, or modify other fields. REQUIRED: remediation_id. At least one other field must be provided.",
+  inputSchema: z31.object({
+    remediation_id: z31.string().describe("REQUIRED. The ID of the remediation to update"),
+    proposed_fix: z31.string().optional().describe("Updated description of the proposed fix"),
+    code_snippet: z31.string().optional().describe("Updated code snippet (if applicable)"),
+    affected_files: z31.array(z31.string()).optional().describe("Updated list of files that need to be modified"),
+    code_changes: z31.array(z31.object({
+      file: z31.string().describe("File path relative to repository root"),
+      content: z31.string().optional().describe("New content for the file"),
+      diff: z31.string().optional().describe("Unified diff format"),
+      description: z31.string().optional().describe("Description of the change")
+    })).optional().describe("Detailed code changes with file contents"),
+    confidence: z31.number().min(0).max(1).optional().describe("Updated confidence level in the fix (0-1)"),
+    title: z31.string().optional().describe("Updated user-friendly title")
+  }),
+  handler: async (args) => {
+    const { remediation_id, proposed_fix, code_snippet, affected_files, code_changes, confidence, title } = args;
+    if (!isApiConfigured()) {
+      return apiNotConfiguredResult();
+    }
+    const { data, error } = await apiPatch(`/remediations/${remediation_id}`, {
+      proposed_fix,
+      code_snippet,
+      affected_files,
+      code_changes,
+      confidence,
+      title
+    });
+    if (error) {
+      return errorResult(error);
+    }
+    return successResult(data);
+  }
+};
 
 // ../../libraries/mcp-tools/dist/tools/scanSite.js
-import { z as z31 } from "zod";
+import { z as z32 } 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)")
+  inputSchema: z32.object({
+    top_n: z32.number().optional().default(10).describe("Number of top pages to analyze (default 10)"),
+    offset: z32.number().optional().default(0).describe("Skip first N pages for pagination (default 0)")
   }),
   handler: async (args) => {
     const { top_n, offset } = args;
@@ -1907,14 +2648,14 @@ var scanSiteTool = {
 };
 
 // ../../libraries/mcp-tools/dist/tools/searchSessions.js
-import { z as z32 } from "zod";
+import { z as z33 } 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)")
+  inputSchema: z33.object({
+    query: z33.string().describe("Natural language search query describing the sessions you want to find"),
+    page_path: z33.string().optional().describe("Optional: filter to a specific page path"),
+    limit: z33.number().optional().default(10).describe("Maximum number of sessions to return (default: 10)")
   }),
   handler: async (args) => {
     const { query, page_path, limit } = args;
@@ -1934,7 +2675,7 @@ var searchSessionsTool = {
 };
 
 // ../../libraries/mcp-tools/dist/tools/triageSessions.js
-import { z as z33 } from "zod";
+import { z as z34 } from "zod";
 function formatDuration(seconds) {
   if (!seconds)
     return "unknown";
@@ -2057,939 +2798,264 @@ function formatTriageOutput(data) {
 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: z33.object({
-    session_ids: z33.preprocess((val) => {
+  inputSchema: z34.object({
+    session_ids: z34.preprocess((val) => {
       if (typeof val === "string") {
         try {
           return JSON.parse(val);
         } catch {
           return val;
-        }
-      }
-      return val;
-    }, z33.array(z33.string()).optional()).describe("Triage specific sessions by ID. If provided, other filters are ignored."),
-    days: z33.number().optional().default(7).describe("Lookback period in days (default: 7). Ignored if session_ids is provided."),
-    page_path: z33.string().optional().describe("Filter to sessions that visited a specific page"),
-    min_severity: z33.enum(["critical", "high", "medium", "low"]).optional().describe("Minimum severity to include in results"),
-    limit: z33.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 z34 } 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: "AUDIT MODE ONLY. Create a fix proposal. REQUIRED: title, diagnosis, proposed_fix, confidence, page_path, category, severity. Proposals are suggestions that developers review and implement manually. Do NOT use in fix mode - use propose_fix instead.",
-  inputSchema: z34.object({
-    issue_id: z34.string().optional().describe("The ID of the related issue (if any)"),
-    improvement_run_id: z34.string().optional().describe("The ID of the improvement run creating this proposal"),
-    title: z34.string().describe("REQUIRED. Short user-friendly title describing the issue from the user's perspective"),
-    diagnosis: z34.string().describe("REQUIRED. Detailed analysis of the root cause of the issue"),
-    proposed_fix: z34.string().describe("REQUIRED. Description of the proposed fix and how it addresses the root cause"),
-    affected_files: z34.array(z34.string()).optional().describe("List of files that likely need to be modified"),
-    confidence: z34.number().min(0).max(1).describe("REQUIRED. Confidence level in the fix (0-1). Use <0.7 when uncertain."),
-    page_path: z34.string().describe("REQUIRED. The page path where the issue occurs"),
-    element_selector: z34.string().optional().describe("CSS selector of the affected element (if applicable)"),
-    category: z34.enum(ISSUE_CATEGORIES2).describe("REQUIRED. Category: code_error, dead_click, rage_click, ux_friction, performance, form_issue, behavioral_anomaly, structural_issue"),
-    severity: z34.enum(ISSUE_SEVERITIES).describe("REQUIRED. Severity: critical, high, medium, low, info"),
-    execution_metadata: z34.object({
-      difficulty_class: z34.enum(["trivial", "light", "heavy"]),
-      difficulty_reasoning: z34.string(),
-      model_used: z34.string(),
-      was_escalated: z34.boolean().optional(),
-      escalation_reason: z34.string().optional(),
-      iterations: z34.number().optional(),
-      credits_used: z34.number().optional(),
-      duration_ms: z34.number().optional()
-    }).optional().describe("AI execution metadata for tracking model selection and performance")
-  }),
-  handler: async (args) => {
-    const { issue_id, improvement_run_id, title, diagnosis, proposed_fix, affected_files, confidence, page_path, element_selector, category, severity, execution_metadata } = 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,
-      execution_metadata
-    });
-    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: z34.object({
-    status: z34.enum(PROPOSAL_STATUSES).optional().describe("Filter by single status"),
-    statuses: z34.array(z34.enum(PROPOSAL_STATUSES)).optional().describe("Filter by multiple statuses"),
-    issue_id: z34.string().optional().describe("Filter by related issue ID"),
-    page_path: z34.string().optional().describe("Filter by page path"),
-    category: z34.enum(ISSUE_CATEGORIES2).optional().describe("Filter by category"),
-    severity: z34.enum(ISSUE_SEVERITIES).optional().describe("Filter by severity"),
-    limit: z34.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: z34.object({
-    proposal_id: z34.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: z34.object({
-    proposal_id: z34.string().describe("The ID of the proposal to mark as resolved"),
-    member_id: z34.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. REQUIRED: proposal_id, reason. Use when the proposal is not applicable, the issue is intended behavior, or a different approach is preferred.",
-  inputSchema: z34.object({
-    proposal_id: z34.string().describe("REQUIRED. The ID of the proposal to dismiss"),
-    reason: z34.string().describe("REQUIRED. Explanation of why the proposal is being dismissed"),
-    member_id: z34.string().optional().describe("The ID of the member who dismissed it")
-  }),
-  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: z34.object({
-    proposal_id: z34.string().describe("The ID of the proposal to evaluate"),
-    min_hours: z34.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: z34.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: z34.object({
-    min_hours: z34.number().optional().default(24).describe("Minimum hours since resolution (default: 24)")
+        }
+      }
+      return val;
+    }, 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 { min_hours } = args;
+    const { session_ids, days, page_path, min_severity, limit } = args;
     if (!isApiConfigured()) {
       return apiNotConfiguredResult();
     }
-    const { data, error } = await apiGet("/proposals/ready-for-evaluation", { min_hours: min_hours ?? 24 });
+    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);
     }
-    return successResult(data);
+    const formattedOutput = formatTriageOutput(data);
+    return { content: [{ type: "text", text: formattedOutput }] };
   }
 };
 
-// ../../libraries/mcp-tools/dist/tools/git.js
+// ../../libraries/mcp-tools/dist/tools/proposal.js
 import { z as z35 } 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}`;
-  const authHeader = ctx.token.startsWith("glpat-") ? { "PRIVATE-TOKEN": ctx.token } : { Authorization: `Bearer ${ctx.token}` };
-  return fetch(url, {
-    ...options,
-    headers: {
-      ...authHeader,
-      "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: z35.object({
-    branch_name: z35.string().describe("Name of the new branch to create"),
-    from_branch: z35.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: z35.object({
-    path: z35.string().describe("Path to the file in the repository"),
-    branch: z35.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. SHA is auto-fetched for existing files.",
-  inputSchema: z35.object({
-    path: z35.string().describe("Path to the file in the repository"),
-    content: z35.string().describe("New content for the file"),
-    message: z35.string().describe("Commit message"),
-    branch: z35.string().describe("Branch to commit to"),
-    sha: z35.string().optional().describe("SHA of the file being replaced (auto-fetched if not provided)")
-  }),
-  handler: async (args) => {
-    try {
-      const ctx = getGitContext();
-      const filePath = args.path;
-      const content = args.content;
-      const message = args.message;
-      const branch = args.branch;
-      let sha = args.sha;
-      if (ctx.provider === "github") {
-        if (!sha) {
-          const checkRes = await githubRequest(`/repos/${ctx.repoFullName}/contents/${filePath}?ref=${branch}`);
-          if (checkRes.ok) {
-            const existingFile = await checkRes.json();
-            sha = existingFile.sha;
-          }
-        }
-        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);
-        let method = "POST";
-        if (!sha) {
-          const checkRes = await gitlabRequest(`/projects/${encodedPath}/repository/files/${encodedFilePath}?ref=${branch}`);
-          if (checkRes.ok) {
-            method = "PUT";
-          }
-        } else {
-          method = "PUT";
-        }
-        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 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",
+  "deployed",
+  "dismissed",
+  "evaluating",
+  "succeeded",
+  "failed",
+  "deferred"
+];
+var createProposalTool = {
+  name: "create_proposal",
+  description: "AUDIT MODE ONLY. Create a fix proposal. REQUIRED: title, diagnosis, proposed_fix, confidence, page_path, category, severity. Proposals are suggestions that developers review and implement manually. Do NOT use in fix mode - use propose_fix instead.",
+  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("REQUIRED. Short user-friendly title describing the issue from the user's perspective"),
+    diagnosis: z35.string().describe("REQUIRED. Detailed analysis of the root cause of the issue"),
+    proposed_fix: z35.string().describe("REQUIRED. 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("REQUIRED. Confidence level in the fix (0-1). Use <0.7 when uncertain."),
+    page_path: z35.string().describe("REQUIRED. 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("REQUIRED. Category: code_error, dead_click, rage_click, ux_friction, performance, form_issue, behavioral_anomaly, structural_issue"),
+    severity: z35.enum(ISSUE_SEVERITIES).describe("REQUIRED. Severity: critical, high, medium, low, info"),
+    execution_metadata: z35.object({
+      difficulty_class: z35.enum(["trivial", "light", "heavy"]),
+      difficulty_reasoning: z35.string(),
+      model_used: z35.string(),
+      was_escalated: z35.boolean().optional(),
+      escalation_reason: z35.string().optional(),
+      iterations: z35.number().optional(),
+      credits_used: z35.number().optional(),
+      duration_ms: z35.number().optional()
+    }).optional().describe("AI execution metadata for tracking model selection and performance")
+  }),
+  handler: async (args) => {
+    const { issue_id, improvement_run_id, title, diagnosis, proposed_fix, affected_files, confidence, page_path, element_selector, category, severity, execution_metadata } = 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,
+      execution_metadata
+    });
+    if (error) {
+      return errorResult(error);
     }
+    return successResult(data);
   }
 };
-var createMergeRequestTool = {
-  name: "create_merge_request",
-  description: "Create a merge request (GitHub: Pull Request, GitLab: Merge Request). Works with both providers.",
+var listProposalsTool = {
+  name: "list_proposals",
+  description: "List proposals with optional filters. Use to review pending proposals, check deployed proposals, or filter by page/category/severity.",
   inputSchema: z35.object({
-    title: z35.string().describe("Title of the merge request"),
-    description: z35.string().describe("Description/body of the merge request"),
-    source_branch: z35.string().describe("Branch containing the changes"),
-    target_branch: z35.string().optional().default("main").describe("Branch to merge into (default: main)")
+    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) => {
-    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");
+    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 checkMrStatusTool = {
-  name: "check_mr_status",
-  description: "Check the status of a merge request. Works with both GitHub and GitLab.",
+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({
-    mr_number: z35.number().describe("The merge request number")
+    proposal_id: z35.string().describe("The ID of the proposal to retrieve")
   }),
   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");
+    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 listOpenMrsTool = {
-  name: "list_open_mrs",
-  description: "List open merge requests for the repository. Works with both GitHub and GitLab.",
+var resolveProposalTool = {
+  name: "resolve_proposal",
+  description: "Mark a proposal as deployed 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({
-    limit: z35.number().optional().default(10).describe("Maximum number of MRs to return (default: 10)")
+    proposal_id: z35.string().describe("The ID of the proposal to mark as deployed"),
+    member_id: z35.string().optional().describe("The ID of the member who deployed it (optional)")
   }),
   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");
+    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 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.",
+};
+var dismissProposalTool = {
+  name: "dismiss_proposal",
+  description: "Dismiss a proposal that won't be implemented. REQUIRED: proposal_id, reason. Use when the proposal is not applicable, the issue is intended behavior, or a different approach is preferred.",
   inputSchema: z35.object({
-    path: z35.string().optional().default("").describe("Directory path to list (empty for root)"),
-    branch: z35.string().optional().describe("Branch to list from (default: main)"),
-    recursive: z35.boolean().optional().default(false).describe("If true, list all files recursively (may be slow for large repos)")
+    proposal_id: z35.string().describe("REQUIRED. The ID of the proposal to dismiss"),
+    reason: z35.string().describe("REQUIRED. Explanation of why the proposal is being dismissed"),
+    member_id: z35.string().optional().describe("The ID of the member who dismissed it")
   }),
   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");
+    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 getRepoTreeTool = {
-  name: "get_repo_tree",
-  description: "Get a condensed directory-only tree of the repository structure. Returns a nested object showing the folder hierarchy up to a configurable depth. Much faster than recursive list_repository_files for understanding project layout. Use this FIRST to orient yourself, then list_repository_files on specific directories.",
+var evaluateProposalTool = {
+  name: "evaluate_proposal",
+  description: "Evaluate if a deployed proposal improved metrics. Compares post-deploy metrics to baseline. Returns success/partial/failed outcome with detailed verdict. Wait at least 24 hours after deployment for reliable results.",
   inputSchema: z35.object({
-    max_depth: z35.number().optional().default(4).describe("Maximum directory depth to return (default: 4)"),
-    branch: z35.string().optional().describe("Branch to read from (default: main)")
+    proposal_id: z35.string().describe("The ID of the proposal to evaluate"),
+    min_hours: z35.number().optional().default(24).describe("Minimum hours since deployment required (default: 24)")
   }),
   handler: async (args) => {
-    try {
-      const ctx = getGitContext();
-      const maxDepth = args.max_depth || 4;
-      const branch = args.branch || "main";
-      if (ctx.provider === "github") {
-        const res = await githubRequest(`/repos/${ctx.repoFullName}/git/trees/${branch}?recursive=1`);
-        if (!res.ok) {
-          return errorResult(`Failed to get repo tree: ${res.statusText}`);
-        }
-        const data = await res.json();
-        const dirs = data.tree.filter((item) => item.type === "tree").map((item) => item.path);
-        const tree = buildNestedTree(dirs, maxDepth);
-        const totalDirs = dirs.length;
-        return successResult({
-          tree,
-          total_directories: totalDirs,
-          depth: maxDepth,
-          provider: "github"
-        });
-      } else {
-        const encodedPath = encodeURIComponent(ctx.repoFullName);
-        const res = await gitlabRequest(`/projects/${encodedPath}/repository/tree?ref=${branch}&recursive=true&per_page=100`);
-        if (!res.ok) {
-          return errorResult(`Failed to get repo tree: ${res.statusText}`);
-        }
-        const data = await res.json();
-        const dirs = data.filter((item) => item.type === "tree").map((item) => item.path);
-        const tree = buildNestedTree(dirs, maxDepth);
-        const totalDirs = dirs.length;
-        return successResult({
-          tree,
-          total_directories: totalDirs,
-          depth: maxDepth,
-          provider: "gitlab"
-        });
-      }
-    } catch (error) {
-      return errorResult(error instanceof Error ? error.message : "Failed to get repo tree");
+    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 searchCodeTool = {
-  name: "search_code",
-  description: "Search for code patterns, symbols, or imports across the repository. Use this to find existing conventions, verify import paths, or discover reusable utilities before writing code. Rate-limited (~10 req/min on GitHub) \u2014 use sparingly and with specific queries.",
+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 deployed proposals that are ready for evaluation (24+ hours since deployment). Use during audit runs to check outcomes of previously deployed proposals.",
   inputSchema: z35.object({
-    query: z35.string().describe('Search terms (e.g., "import { Button }", "useMemo", "className={styles.")'),
-    path_filter: z35.string().optional().describe('Restrict search to a directory (e.g., "client/src/components")'),
-    extension: z35.string().optional().describe('Filter by file extension (e.g., "tsx", "ts", "css")')
+    min_hours: z35.number().optional().default(24).describe("Minimum hours since deployment (default: 24)")
   }),
   handler: async (args) => {
-    try {
-      const ctx = getGitContext();
-      const query = args.query;
-      const pathFilter = args.path_filter;
-      const extension = args.extension;
-      if (ctx.provider === "github") {
-        let q = `${query} repo:${ctx.repoFullName}`;
-        if (pathFilter)
-          q += ` path:${pathFilter}`;
-        if (extension)
-          q += ` extension:${extension}`;
-        const res = await githubRequest(`/search/code?q=${encodeURIComponent(q)}&per_page=10`, {
-          headers: {
-            Accept: "application/vnd.github.text-match+json"
-          }
-        });
-        if (!res.ok) {
-          const err = await res.json();
-          return errorResult(err.message || `Code search failed: ${res.status}`);
-        }
-        const data = await res.json();
-        const results = data.items.map((item) => ({
-          path: item.path,
-          score: item.score,
-          matched_lines: (item.text_matches ?? []).map((m) => m.fragment),
-          url: item.html_url
-        }));
-        return successResult({
-          total_count: data.total_count,
-          results,
-          provider: "github"
-        });
-      } else {
-        const encodedPath = encodeURIComponent(ctx.repoFullName);
-        const searchQuery = pathFilter ? `${query} filename:${pathFilter}` : query;
-        const res = await gitlabRequest(`/projects/${encodedPath}/search?scope=blobs&search=${encodeURIComponent(searchQuery)}&per_page=10`);
-        if (!res.ok) {
-          const err = await res.json();
-          return errorResult(err.message || `Code search failed: ${res.status}`);
-        }
-        const data = await res.json();
-        const results = data.map((item) => ({
-          path: item.path,
-          matched_lines: [item.data],
-          startline: item.startline
-        }));
-        return successResult({
-          total_count: results.length,
-          results,
-          provider: "gitlab"
-        });
-      }
-    } catch (error) {
-      return errorResult(error instanceof Error ? error.message : "Code search failed");
+    const { min_hours } = args;
+    if (!isApiConfigured()) {
+      return apiNotConfiguredResult();
     }
-  }
-};
-function buildNestedTree(dirs, maxDepth) {
-  const tree = {};
-  for (const dir of dirs) {
-    const parts = dir.split("/");
-    if (parts.length > maxDepth)
-      continue;
-    let current = tree;
-    for (const part of parts) {
-      const key = `${part}/`;
-      if (!current[key]) {
-        current[key] = {};
-      }
-      current = current[key];
+    const { data, error } = await apiGet("/proposals/ready-for-evaluation", { min_hours: min_hours ?? 24 });
+    if (error) {
+      return errorResult(error);
     }
+    return successResult(data);
   }
-  return tree;
-}
+};
 
 // ../../libraries/mcp-tools/dist/tools/index.js
 var allTools = [
@@ -3050,6 +3116,7 @@ var allTools = [
   updateRemediationStatusTool,
   listRemediationsByStatusTool,
   getRemediationByPrTool,
+  updateRemediationTool,
   // Scan
   scanSiteTool,
   // Search