@bbearai/admin 0.1.0

package/dist/index.mjs

@@ -0,0 +1,2437 @@
+// src/index.ts
+import { createClient } from "@supabase/supabase-js";
+
+// src/utils.ts
+var UUID_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+function isValidUUID(str) {
+  return typeof str === "string" && UUID_REGEX.test(str);
+}
+function sanitizeSearchQuery(query) {
+  if (!query) return void 0;
+  return query.replace(/[%_\\]/g, "").slice(0, 500);
+}
+function extractFunctionName(codeSnippet) {
+  if (!codeSnippet) return void 0;
+  const patterns = [
+    /function\s+(\w+)/,
+    /const\s+(\w+)\s*=\s*(?:async\s*)?\(/,
+    /export\s+(?:default\s+)?(?:async\s+)?function\s+(\w+)/,
+    /class\s+(\w+)/,
+    /(\w+)\s*:\s*(?:React\.)?FC/
+  ];
+  for (const pattern of patterns) {
+    const match = codeSnippet.match(pattern);
+    if (match) return match[1];
+  }
+  return void 0;
+}
+function analyzeFileTypes(files) {
+  const analysis = {
+    hasUIComponents: false,
+    hasAPIRoutes: false,
+    hasTests: false,
+    hasStyles: false,
+    hasConfig: false,
+    primaryType: "unknown"
+  };
+  for (const file of files) {
+    const lower = file.toLowerCase();
+    if (lower.includes("component") || lower.endsWith(".tsx") || lower.endsWith(".jsx") || lower.includes("/pages/") || lower.includes("/app/") || lower.includes("/screens/")) {
+      analysis.hasUIComponents = true;
+    }
+    if (lower.includes("/api/") || lower.includes("route.ts") || lower.includes("handler") || lower.includes("service") || lower.includes("controller")) {
+      analysis.hasAPIRoutes = true;
+    }
+    if (lower.includes(".test.") || lower.includes(".spec.") || lower.includes("__tests__")) {
+      analysis.hasTests = true;
+    }
+    if (lower.endsWith(".css") || lower.endsWith(".scss") || lower.includes("style") || lower.includes("tailwind")) {
+      analysis.hasStyles = true;
+    }
+    if (lower.includes("config") || lower.endsWith(".json") || lower.endsWith(".env") || lower.includes("settings")) {
+      analysis.hasConfig = true;
+    }
+  }
+  if (analysis.hasUIComponents) analysis.primaryType = "ui";
+  else if (analysis.hasAPIRoutes) analysis.primaryType = "api";
+  else if (analysis.hasConfig) analysis.primaryType = "config";
+  else if (analysis.hasStyles) analysis.primaryType = "styles";
+  return analysis;
+}
+function getTrackTemplates(track) {
+  const templates = {
+    functional: [
+      {
+        title: "Happy path navigation to {route}",
+        description: "Verify basic navigation and page load for {route}",
+        steps: [
+          { action: "Navigate to {route}", expectedResult: "Page loads without errors" },
+          { action: "Verify all main elements are visible", expectedResult: "Headers, content, and navigation present" },
+          { action: "Check for console errors", expectedResult: "No JavaScript errors in console" }
+        ],
+        expected_result: "Page functions correctly with all elements visible"
+      },
+      {
+        title: "Error handling at {route}",
+        description: "Test error states and edge cases at {route}",
+        steps: [
+          { action: "Navigate to {route}", expectedResult: "Page loads" },
+          { action: "Trigger an error condition (e.g., invalid input)", expectedResult: "Error message displayed" },
+          { action: "Verify error is user-friendly", expectedResult: "Clear explanation of what went wrong" }
+        ],
+        expected_result: "Errors are handled gracefully with clear messaging"
+      },
+      {
+        title: "Form submission at {route}",
+        description: "Test form validation and submission at {route}",
+        steps: [
+          { action: "Navigate to {route}", expectedResult: "Form is visible" },
+          { action: "Submit form with empty fields", expectedResult: "Validation errors shown" },
+          { action: "Fill in valid data and submit", expectedResult: "Success message or redirect" }
+        ],
+        expected_result: "Form validates input and submits successfully"
+      }
+    ],
+    design: [
+      {
+        title: "Visual consistency at {route}",
+        description: "Check design system compliance at {route}",
+        steps: [
+          { action: "Navigate to {route}", expectedResult: "Page loads" },
+          { action: "Check typography matches design system", expectedResult: "Fonts, sizes, weights are correct" },
+          { action: "Verify color usage", expectedResult: "Colors match brand guidelines" },
+          { action: "Check spacing and alignment", expectedResult: "Consistent margins and padding" }
+        ],
+        expected_result: "Page matches design specifications"
+      },
+      {
+        title: "Responsive behavior at {route}",
+        description: "Test responsive design at {route}",
+        steps: [
+          { action: "View {route} on desktop (1920px)", expectedResult: "Full layout visible" },
+          { action: "Resize to tablet (768px)", expectedResult: "Layout adapts appropriately" },
+          { action: "Resize to mobile (375px)", expectedResult: "Mobile-friendly layout" }
+        ],
+        expected_result: "Page is fully responsive across breakpoints"
+      }
+    ],
+    accessibility: [
+      {
+        title: "Keyboard navigation at {route}",
+        description: "Test keyboard accessibility at {route}",
+        steps: [
+          { action: "Navigate to {route}", expectedResult: "Page loads" },
+          { action: "Press Tab to navigate through elements", expectedResult: "Focus moves in logical order" },
+          { action: "Verify focus indicators are visible", expectedResult: "Clear focus ring on interactive elements" },
+          { action: "Test Enter/Space on buttons", expectedResult: "Buttons activate correctly" }
+        ],
+        expected_result: "Page is fully navigable by keyboard"
+      },
+      {
+        title: "Screen reader compatibility at {route}",
+        description: "Test screen reader accessibility at {route}",
+        steps: [
+          { action: "Enable screen reader", expectedResult: "Screen reader activates" },
+          { action: "Navigate to {route}", expectedResult: "Page title is announced" },
+          { action: "Tab through content", expectedResult: "All content is announced meaningfully" },
+          { action: "Check form labels", expectedResult: "Inputs have associated labels" }
+        ],
+        expected_result: "Page is fully accessible via screen reader"
+      }
+    ],
+    performance: [
+      {
+        title: "Page load performance at {route}",
+        description: "Measure load times at {route}",
+        steps: [
+          { action: "Clear browser cache", expectedResult: "Cache cleared" },
+          { action: "Navigate to {route}", expectedResult: "Page loads" },
+          { action: "Check Network tab for load time", expectedResult: "Initial load under 3 seconds" },
+          { action: "Note Largest Contentful Paint", expectedResult: "LCP under 2.5 seconds" }
+        ],
+        expected_result: "Page loads within performance budget"
+      }
+    ]
+  };
+  return templates[track] || templates.functional;
+}
+
+// src/reports.ts
+async function listReports(supabase, projectId, args) {
+  let query = supabase.from("reports").select("id, report_type, severity, status, description, app_context, created_at, reporter_name, tester:testers(name)").eq("project_id", projectId).order("created_at", { ascending: false }).limit(Math.min(args.limit || 10, 50));
+  if (args.status) query = query.eq("status", args.status);
+  if (args.severity) query = query.eq("severity", args.severity);
+  if (args.type) query = query.eq("report_type", args.type);
+  const { data, error } = await query;
+  if (error) return { error: error.message };
+  return {
+    reports: data?.map((r) => ({
+      id: r.id,
+      type: r.report_type,
+      severity: r.severity,
+      status: r.status,
+      description: r.description,
+      route: r.app_context?.currentRoute,
+      reporter: r.tester?.name || r.reporter_name || "Anonymous",
+      created_at: r.created_at
+    })),
+    total: data?.length || 0
+  };
+}
+async function getReport(supabase, projectId, args) {
+  if (!isValidUUID(args.report_id)) {
+    return { error: "Invalid report_id format" };
+  }
+  const { data, error } = await supabase.from("reports").select("*, tester:testers(*), track:qa_tracks(*)").eq("id", args.report_id).eq("project_id", projectId).single();
+  if (error) return { error: error.message };
+  return {
+    report: {
+      id: data.id,
+      type: data.report_type,
+      severity: data.severity,
+      status: data.status,
+      description: data.description,
+      app_context: data.app_context,
+      device_info: data.device_info,
+      navigation_history: data.navigation_history,
+      screenshots: data.screenshots,
+      created_at: data.created_at,
+      reporter: data.tester ? { name: data.tester.name } : data.reporter_name ? { name: data.reporter_name } : null,
+      track: data.track ? { name: data.track.name, icon: data.track.icon } : null
+    }
+  };
+}
+async function searchReports(supabase, projectId, args) {
+  const sanitizedQuery = sanitizeSearchQuery(args.query);
+  const sanitizedRoute = sanitizeSearchQuery(args.route);
+  let query = supabase.from("reports").select("id, report_type, severity, status, description, app_context, created_at").eq("project_id", projectId).order("created_at", { ascending: false }).limit(20);
+  if (sanitizedQuery) {
+    query = query.ilike("description", `%${sanitizedQuery}%`);
+  }
+  const { data, error } = await query;
+  if (error) return { error: error.message };
+  let results = data || [];
+  if (sanitizedRoute) {
+    results = results.filter((r) => {
+      const route = r.app_context?.currentRoute;
+      return route && route.includes(sanitizedRoute);
+    });
+  }
+  return {
+    reports: results.map((r) => ({
+      id: r.id,
+      type: r.report_type,
+      severity: r.severity,
+      status: r.status,
+      description: r.description,
+      route: r.app_context?.currentRoute,
+      created_at: r.created_at
+    })),
+    total: results.length
+  };
+}
+async function updateReportStatus(supabase, projectId, args) {
+  if (!isValidUUID(args.report_id)) {
+    return { error: "Invalid report_id format" };
+  }
+  const updates = { status: args.status };
+  if (args.resolution_notes) updates.resolution_notes = args.resolution_notes;
+  const { error } = await supabase.from("reports").update(updates).eq("id", args.report_id).eq("project_id", projectId);
+  if (error) return { error: error.message };
+  return { success: true, message: `Report status updated to ${args.status}` };
+}
+async function getReportContext(supabase, projectId, args) {
+  if (!isValidUUID(args.report_id)) {
+    return { error: "Invalid report_id format" };
+  }
+  const { data, error } = await supabase.from("reports").select("app_context, device_info, navigation_history, enhanced_context").eq("id", args.report_id).eq("project_id", projectId).single();
+  if (error) return { error: error.message };
+  return {
+    context: {
+      app_context: data.app_context,
+      device_info: data.device_info,
+      navigation_history: data.navigation_history,
+      enhanced_context: data.enhanced_context || {}
+    }
+  };
+}
+async function bulkUpdateReports(supabase, projectId, args) {
+  if (!args.report_ids || args.report_ids.length === 0) {
+    return { error: "At least one report_id is required" };
+  }
+  if (args.report_ids.length > 50) {
+    return { error: "Maximum 50 reports per bulk update" };
+  }
+  for (const id of args.report_ids) {
+    if (!isValidUUID(id)) return { error: `Invalid report_id format: ${id}` };
+  }
+  const updates = { status: args.status };
+  if (args.resolution_notes) updates.resolution_notes = args.resolution_notes;
+  if (["fixed", "resolved", "verified", "wont_fix", "duplicate", "closed"].includes(args.status)) {
+    updates.resolved_at = (/* @__PURE__ */ new Date()).toISOString();
+  }
+  const { data, error } = await supabase.from("reports").update(updates).eq("project_id", projectId).in("id", args.report_ids).select("id, status, description");
+  if (error) return { error: error.message };
+  const updated = data || [];
+  const updatedIds = new Set(updated.map((r) => r.id));
+  const notFound = args.report_ids.filter((id) => !updatedIds.has(id));
+  return {
+    success: true,
+    updatedCount: updated.length,
+    requestedCount: args.report_ids.length,
+    notFound: notFound.length > 0 ? notFound : void 0,
+    status: args.status,
+    reports: updated.map((r) => ({
+      id: r.id,
+      status: r.status,
+      description: r.description?.slice(0, 80)
+    })),
+    message: `Updated ${updated.length} report(s) to "${args.status}".${notFound.length > 0 ? ` ${notFound.length} report(s) not found.` : ""}`
+  };
+}
+
+// src/project.ts
+async function getProjectInfo(supabase, projectId) {
+  const { data: project, error: projectError } = await supabase.from("projects").select("id, name, slug, is_qa_enabled").eq("id", projectId).single();
+  if (projectError) return { error: projectError.message };
+  const { data: tracks } = await supabase.from("qa_tracks").select("id, name, icon, test_template").eq("project_id", projectId);
+  const { count: testCaseCount } = await supabase.from("test_cases").select("id", { count: "exact", head: true }).eq("project_id", projectId);
+  const { count: openBugCount } = await supabase.from("reports").select("id", { count: "exact", head: true }).eq("project_id", projectId).eq("report_type", "bug").in("status", ["new", "confirmed", "in_progress"]);
+  return {
+    project: {
+      id: project.id,
+      name: project.name,
+      slug: project.slug,
+      qaEnabled: project.is_qa_enabled
+    },
+    stats: {
+      tracks: tracks?.length || 0,
+      testCases: testCaseCount || 0,
+      openBugs: openBugCount || 0
+    },
+    tracks: tracks?.map((t) => ({
+      id: t.id,
+      name: t.name,
+      icon: t.icon,
+      template: t.test_template
+    })) || []
+  };
+}
+async function getQaTracks(supabase, projectId) {
+  const { data, error } = await supabase.from("qa_tracks").select("*").eq("project_id", projectId).order("sort_order");
+  if (error) return { error: error.message };
+  return {
+    tracks: data?.map((t) => ({
+      id: t.id,
+      name: t.name,
+      slug: t.slug,
+      icon: t.icon,
+      color: t.color,
+      testTemplate: t.test_template,
+      description: t.description,
+      requiresCertification: t.requires_certification,
+      evaluationCriteria: t.evaluation_criteria
+    })) || []
+  };
+}
+
+// src/tests.ts
+async function createTestCase(supabase, projectId, args) {
+  let trackId = null;
+  if (args.track) {
+    const sanitizedTrack = sanitizeSearchQuery(args.track);
+    if (sanitizedTrack) {
+      const { data: trackData } = await supabase.from("qa_tracks").select("id").eq("project_id", projectId).ilike("name", `%${sanitizedTrack}%`).single();
+      trackId = trackData?.id || null;
+    }
+  }
+  const testCase = {
+    project_id: projectId,
+    test_key: args.test_key,
+    title: args.title,
+    description: args.description || "",
+    track_id: trackId,
+    priority: args.priority || "P2",
+    steps: args.steps,
+    expected_result: args.expected_result,
+    preconditions: args.preconditions || "",
+    target_route: args.target_route || null
+  };
+  const { data, error } = await supabase.from("test_cases").insert(testCase).select("id, test_key, title").single();
+  if (error) return { error: error.message };
+  return {
+    success: true,
+    testCase: { id: data.id, testKey: data.test_key, title: data.title },
+    message: `Test case ${data.test_key} created successfully`
+  };
+}
+async function updateTestCase(supabase, projectId, args) {
+  if (!args.test_case_id && !args.test_key) {
+    return { error: "Must provide either test_case_id or test_key to identify the test case" };
+  }
+  let testCaseId = args.test_case_id;
+  if (!testCaseId && args.test_key) {
+    const { data: existing } = await supabase.from("test_cases").select("id").eq("project_id", projectId).eq("test_key", args.test_key).single();
+    if (!existing) return { error: `Test case with key ${args.test_key} not found` };
+    testCaseId = existing.id;
+  }
+  const updates = {};
+  if (args.title !== void 0) updates.title = args.title;
+  if (args.description !== void 0) updates.description = args.description;
+  if (args.priority !== void 0) updates.priority = args.priority;
+  if (args.steps !== void 0) updates.steps = args.steps;
+  if (args.expected_result !== void 0) updates.expected_result = args.expected_result;
+  if (args.preconditions !== void 0) updates.preconditions = args.preconditions;
+  if (args.target_route !== void 0) updates.target_route = args.target_route;
+  if (Object.keys(updates).length === 0) return { error: "No fields to update" };
+  const { data, error } = await supabase.from("test_cases").update(updates).eq("id", testCaseId).eq("project_id", projectId).select("id, test_key, title, target_route").single();
+  if (error) return { error: error.message };
+  return {
+    success: true,
+    testCase: { id: data.id, testKey: data.test_key, title: data.title, targetRoute: data.target_route },
+    message: `Test case ${data.test_key} updated successfully`,
+    updatedFields: Object.keys(updates)
+  };
+}
+async function deleteTestCases(supabase, projectId, args) {
+  const modes = [args.test_case_id, args.test_key, args.test_case_ids, args.test_keys].filter((v) => v !== void 0 && v !== null);
+  if (modes.length === 0) return { error: "Must provide one of: test_case_id, test_key, test_case_ids, or test_keys" };
+  if (modes.length > 1) return { error: "Provide only one of: test_case_id, test_key, test_case_ids, or test_keys" };
+  let idsToDelete = [];
+  if (args.test_case_id) {
+    if (!isValidUUID(args.test_case_id)) return { error: "Invalid test_case_id format (must be UUID)" };
+    idsToDelete = [args.test_case_id];
+  }
+  if (args.test_key) {
+    const { data: existing } = await supabase.from("test_cases").select("id").eq("project_id", projectId).eq("test_key", args.test_key).single();
+    if (!existing) return { error: `Test case with key "${args.test_key}" not found` };
+    idsToDelete = [existing.id];
+  }
+  if (args.test_case_ids) {
+    if (!Array.isArray(args.test_case_ids) || args.test_case_ids.length === 0) return { error: "test_case_ids must be a non-empty array" };
+    if (args.test_case_ids.length > 50) return { error: "Cannot delete more than 50 test cases at once" };
+    const invalidIds = args.test_case_ids.filter((id) => !isValidUUID(id));
+    if (invalidIds.length > 0) return { error: `Invalid UUID(s): ${invalidIds.join(", ")}` };
+    idsToDelete = args.test_case_ids;
+  }
+  if (args.test_keys) {
+    if (!Array.isArray(args.test_keys) || args.test_keys.length === 0) return { error: "test_keys must be a non-empty array" };
+    if (args.test_keys.length > 50) return { error: "Cannot delete more than 50 test cases at once" };
+    const { data: existing, error: lookupError } = await supabase.from("test_cases").select("id, test_key").eq("project_id", projectId).in("test_key", args.test_keys);
+    if (lookupError) return { error: lookupError.message };
+    const foundKeys = (existing || []).map((tc) => tc.test_key);
+    const notFound = args.test_keys.filter((k) => !foundKeys.includes(k));
+    if (notFound.length > 0) return { error: `Test case(s) not found: ${notFound.join(", ")}` };
+    idsToDelete = (existing || []).map((tc) => tc.id);
+  }
+  const { data: toDelete } = await supabase.from("test_cases").select("id, test_key, title").eq("project_id", projectId).in("id", idsToDelete);
+  if (!toDelete || toDelete.length === 0) return { error: "No matching test cases found in this project" };
+  const { error: deleteError } = await supabase.from("test_cases").delete().eq("project_id", projectId).in("id", idsToDelete);
+  if (deleteError) return { error: deleteError.message };
+  return {
+    success: true,
+    deletedCount: toDelete.length,
+    deleted: toDelete.map((tc) => ({ id: tc.id, testKey: tc.test_key, title: tc.title })),
+    message: toDelete.length === 1 ? `Test case ${toDelete[0].test_key} deleted successfully` : `${toDelete.length} test cases deleted successfully`,
+    warning: "Associated test_assignments, test_feedback, and ai_test_runs have been cascade-deleted. Reports and qa_findings referencing these tests now have null test_case_id."
+  };
+}
+async function listTestCases(supabase, projectId, args) {
+  let query = supabase.from("test_cases").select(`id, test_key, title, description, priority, target_route, preconditions, expected_result, steps, track:qa_tracks(id, name, icon, color)`).eq("project_id", projectId).order("test_key", { ascending: true });
+  if (args.priority) query = query.eq("priority", args.priority);
+  if (args.missing_target_route) query = query.is("target_route", null);
+  const limit = args.limit || 100;
+  const offset = args.offset || 0;
+  query = query.range(offset, offset + limit - 1);
+  const { data, error } = await query;
+  if (error) return { error: error.message };
+  let testCases = data || [];
+  if (args.track) {
+    testCases = testCases.filter(
+      (tc) => tc.track?.name?.toLowerCase().includes(args.track.toLowerCase())
+    );
+  }
+  return {
+    count: testCases.length,
+    testCases: testCases.map((tc) => ({
+      id: tc.id,
+      testKey: tc.test_key,
+      title: tc.title,
+      description: tc.description,
+      priority: tc.priority,
+      targetRoute: tc.target_route,
+      hasTargetRoute: !!tc.target_route,
+      track: tc.track?.name || null,
+      stepsCount: tc.steps?.length || 0
+    })),
+    pagination: { limit, offset, hasMore: testCases.length === limit }
+  };
+}
+async function listTestRuns(supabase, projectId, args) {
+  const limit = Math.min(args.limit || 20, 50);
+  let query = supabase.from("test_runs").select("id, name, description, status, total_tests, passed_tests, failed_tests, started_at, completed_at, created_at").eq("project_id", projectId).order("created_at", { ascending: false }).limit(limit);
+  if (args.status) query = query.eq("status", args.status);
+  const { data, error } = await query;
+  if (error) return { error: error.message };
+  return {
+    count: (data || []).length,
+    testRuns: (data || []).map((r) => ({
+      id: r.id,
+      name: r.name,
+      description: r.description,
+      status: r.status,
+      totalTests: r.total_tests,
+      passedTests: r.passed_tests,
+      failedTests: r.failed_tests,
+      passRate: r.total_tests > 0 ? Math.round(r.passed_tests / r.total_tests * 100) : 0,
+      startedAt: r.started_at,
+      completedAt: r.completed_at,
+      createdAt: r.created_at
+    }))
+  };
+}
+async function createTestRun(supabase, projectId, args) {
+  if (!args.name || args.name.trim().length === 0) return { error: "Test run name is required" };
+  const { data, error } = await supabase.from("test_runs").insert({ project_id: projectId, name: args.name.trim(), description: args.description?.trim() || null, status: "draft" }).select("id, name, description, status, created_at").single();
+  if (error) return { error: error.message };
+  return {
+    success: true,
+    testRun: { id: data.id, name: data.name, description: data.description, status: data.status, createdAt: data.created_at },
+    message: `Test run "${data.name}" created. Use assign_tests to add test assignments.`
+  };
+}
+async function listTestAssignments(supabase, projectId, args) {
+  const limit = Math.min(args.limit || 50, 200);
+  if (args.tester_id && !isValidUUID(args.tester_id)) return { error: "Invalid tester_id format" };
+  if (args.test_run_id && !isValidUUID(args.test_run_id)) return { error: "Invalid test_run_id format" };
+  let query = supabase.from("test_assignments").select(`id, status, assigned_at, started_at, completed_at, duration_seconds, is_verification, notes,
+      test_case:test_cases(id, test_key, title, priority, target_route),
+      tester:testers(id, name, email), test_run:test_runs(id, name)`).eq("project_id", projectId).order("assigned_at", { ascending: false }).limit(limit);
+  if (args.tester_id) query = query.eq("tester_id", args.tester_id);
+  if (args.test_run_id) query = query.eq("test_run_id", args.test_run_id);
+  if (args.status) query = query.eq("status", args.status);
+  const { data, error } = await query;
+  if (error) return { error: error.message };
+  return {
+    count: (data || []).length,
+    assignments: (data || []).map((a) => ({
+      id: a.id,
+      status: a.status,
+      assignedAt: a.assigned_at,
+      startedAt: a.started_at,
+      completedAt: a.completed_at,
+      durationSeconds: a.duration_seconds,
+      isVerification: a.is_verification,
+      notes: a.notes,
+      testCase: a.test_case ? { id: a.test_case.id, testKey: a.test_case.test_key, title: a.test_case.title, priority: a.test_case.priority, targetRoute: a.test_case.target_route } : null,
+      tester: a.tester ? { id: a.tester.id, name: a.tester.name, email: a.tester.email } : null,
+      testRun: a.test_run ? { id: a.test_run.id, name: a.test_run.name } : null
+    }))
+  };
+}
+async function assignTests(supabase, projectId, args) {
+  if (!isValidUUID(args.tester_id)) return { error: "Invalid tester_id format" };
+  if (!args.test_case_ids || args.test_case_ids.length === 0) return { error: "At least one test_case_id is required" };
+  if (args.test_case_ids.length > 50) return { error: "Maximum 50 test cases per assignment batch" };
+  for (const id of args.test_case_ids) {
+    if (!isValidUUID(id)) return { error: `Invalid test_case_id format: ${id}` };
+  }
+  if (args.test_run_id && !isValidUUID(args.test_run_id)) return { error: "Invalid test_run_id format" };
+  const { data: tester, error: testerErr } = await supabase.from("testers").select("id, name, email, status").eq("id", args.tester_id).eq("project_id", projectId).single();
+  if (testerErr || !tester) return { error: "Tester not found in this project" };
+  if (tester.status !== "active") return { error: `Tester "${tester.name}" is ${tester.status}, not active` };
+  const { data: testCases, error: tcErr } = await supabase.from("test_cases").select("id, test_key, title").eq("project_id", projectId).in("id", args.test_case_ids);
+  if (tcErr) return { error: tcErr.message };
+  const foundIds = new Set((testCases || []).map((tc) => tc.id));
+  const missingIds = args.test_case_ids.filter((id) => !foundIds.has(id));
+  if (missingIds.length > 0) return { error: `Test cases not found in this project: ${missingIds.join(", ")}` };
+  if (args.test_run_id) {
+    const { data: run, error: runErr } = await supabase.from("test_runs").select("id").eq("id", args.test_run_id).eq("project_id", projectId).single();
+    if (runErr || !run) return { error: "Test run not found in this project" };
+  }
+  const rows = args.test_case_ids.map((tcId) => ({
+    project_id: projectId,
+    test_case_id: tcId,
+    tester_id: args.tester_id,
+    test_run_id: args.test_run_id || null,
+    status: "pending"
+  }));
+  async function syncRunCounter() {
+    if (!args.test_run_id) return;
+    const { count } = await supabase.from("test_assignments").select("id", { count: "exact", head: true }).eq("test_run_id", args.test_run_id).eq("project_id", projectId);
+    if (count !== null) {
+      await supabase.from("test_runs").update({ total_tests: count }).eq("id", args.test_run_id);
+    }
+  }
+  const { data: inserted, error: insertErr } = await supabase.from("test_assignments").insert(rows).select("id, test_case_id");
+  if (insertErr) {
+    if (insertErr.message.includes("duplicate") || insertErr.message.includes("unique")) {
+      const created = [];
+      const skipped = [];
+      for (const row of rows) {
+        const { data: single, error: singleErr } = await supabase.from("test_assignments").insert(row).select("id, test_case_id").single();
+        if (singleErr) {
+          const tc = testCases?.find((t) => t.id === row.test_case_id);
+          skipped.push(tc?.test_key || row.test_case_id);
+        } else if (single) {
+          created.push(single);
+        }
+      }
+      await syncRunCounter();
+      return {
+        success: true,
+        created: created.length,
+        skipped: skipped.length,
+        skippedTests: skipped,
+        tester: { id: tester.id, name: tester.name },
+        message: `Assigned ${created.length} test(s) to ${tester.name}. ${skipped.length} skipped (already assigned).`
+      };
+    }
+    return { error: insertErr.message };
+  }
+  await syncRunCounter();
+  return {
+    success: true,
+    created: (inserted || []).length,
+    skipped: 0,
+    tester: { id: tester.id, name: tester.name },
+    testRun: args.test_run_id || null,
+    message: `Assigned ${(inserted || []).length} test(s) to ${tester.name}.`
+  };
+}
+
+// src/intelligence.ts
+async function tryRefreshRouteStats(supabase, projectId) {
+  try {
+    await supabase.rpc("refresh_route_test_stats", { p_project_id: projectId });
+  } catch {
+  }
+}
+async function getBugPatterns(supabase, projectId, args) {
+  const query = supabase.from("reports").select("app_context, severity, status, created_at").eq("project_id", projectId).eq("report_type", "bug").order("created_at", { ascending: false }).limit(100);
+  const { data: bugs, error } = await query;
+  if (error) return { error: error.message };
+  const routePatterns = {};
+  for (const bug of bugs || []) {
+    const route = bug.app_context?.currentRoute || "unknown";
+    if (args.route && !route.includes(args.route)) continue;
+    if (!routePatterns[route]) routePatterns[route] = { total: 0, critical: 0, open: 0, resolved: 0 };
+    routePatterns[route].total++;
+    if (bug.severity === "critical" || bug.severity === "high") routePatterns[route].critical++;
+    if (["new", "confirmed", "in_progress"].includes(bug.status)) routePatterns[route].open++;
+    else routePatterns[route].resolved++;
+  }
+  const hotspots = Object.entries(routePatterns).map(([route, stats]) => ({ route, ...stats })).sort((a, b) => b.total - a.total).slice(0, 10);
+  return {
+    hotspots,
+    summary: {
+      totalRoutes: Object.keys(routePatterns).length,
+      totalBugs: bugs?.length || 0,
+      criticalRoutes: hotspots.filter((h) => h.critical > 0).length
+    },
+    recommendations: hotspots.filter((h) => h.open > 0).map((h) => `Route "${h.route}" has ${h.open} open bugs - prioritize testing here`)
+  };
+}
+async function suggestTestCases(supabase, projectId, args) {
+  const count = args.count || 5;
+  const { data: existingTests } = await supabase.from("test_cases").select("test_key, title").eq("project_id", projectId).order("test_key", { ascending: false }).limit(1);
+  const lastKey = existingTests?.[0]?.test_key || "TC-000";
+  const lastNum = parseInt(lastKey.replace("TC-", "")) || 0;
+  const patterns = await getBugPatterns(supabase, projectId, { route: args.route });
+  const suggestions = [];
+  const track = args.track || "functional";
+  const route = args.route || "/";
+  const templates = getTrackTemplates(track);
+  for (let i = 0; i < count; i++) {
+    const keyNum = lastNum + i + 1;
+    const template = templates[i % templates.length];
+    suggestions.push({
+      test_key: `TC-${String(keyNum).padStart(3, "0")}`,
+      title: template.title.replace("{route}", route),
+      description: template.description.replace("{route}", route),
+      track,
+      priority: i === 0 ? "P1" : "P2",
+      steps: template.steps.map((s, idx) => ({
+        stepNumber: idx + 1,
+        action: s.action.replace("{route}", route),
+        expectedResult: s.expectedResult.replace("{route}", route)
+      })),
+      expected_result: template.expected_result.replace("{route}", route)
+    });
+  }
+  const { data: relatedBugs } = await supabase.from("reports").select("id, description, severity").eq("project_id", projectId).eq("report_type", "bug").limit(10);
+  const routeBugs = (relatedBugs || []).slice(0, 5);
+  return {
+    suggestions,
+    context: { route: args.route || "all", track, bugHotspots: patterns.hotspots?.slice(0, 3) || [] },
+    historicalContext: {
+      relatedBugs: routeBugs.map((b) => ({ id: b.id, description: b.description.slice(0, 100), severity: b.severity })),
+      recommendation: routeBugs.length > 0 ? `These test suggestions are informed by ${routeBugs.length} historical bug(s) in this area.` : "No historical bugs found for this route."
+    },
+    instructions: `Review these suggestions and use create_test_case to add them to BugBear.
+You can modify the suggestions before creating them.`
+  };
+}
+async function getTestPriorities(supabase, projectId, args) {
+  const limit = args.limit || 10;
+  const minScore = args.min_score || 0;
+  const includeFactors = args.include_factors !== false;
+  await tryRefreshRouteStats(supabase, projectId);
+  const { data: routes, error } = await supabase.from("route_test_stats").select("*").eq("project_id", projectId).gte("priority_score", minScore).order("priority_score", { ascending: false }).limit(limit);
+  if (error) return { error: error.message };
+  if (!routes || routes.length === 0) {
+    return { priorities: [], summary: { totalRoutes: 0, criticalCount: 0, highCount: 0, mediumCount: 0 }, guidance: "No routes found with test data." };
+  }
+  const getUrgency = (score) => score >= 70 ? "critical" : score >= 50 ? "high" : score >= 30 ? "medium" : "low";
+  const getRecommendation = (route) => {
+    if (route.critical_bugs > 0) return `Critical bugs exist - prioritize immediate testing and bug fixes`;
+    if (route.open_bugs >= 3) return `Multiple open bugs (${route.open_bugs}) - comprehensive testing needed`;
+    if (route.last_tested_at === null) return `Never tested - establish baseline coverage`;
+    const daysSinceTest = Math.floor((Date.now() - new Date(route.last_tested_at).getTime()) / (1e3 * 60 * 60 * 24));
+    if (daysSinceTest > 14) return `Stale coverage (${daysSinceTest} days) - refresh testing`;
+    if (route.regression_count > 0) return `Regression risk (${route.regression_count} past regressions) - add regression tests`;
+    if (route.test_case_count < 3) return `Low test coverage (${route.test_case_count} tests) - add more test cases`;
+    return "Maintain current testing cadence";
+  };
+  const priorities = routes.map((route, idx) => {
+    const daysSinceTest = route.last_tested_at ? Math.floor((Date.now() - new Date(route.last_tested_at).getTime()) / (1e3 * 60 * 60 * 24)) : null;
+    const priority = {
+      rank: idx + 1,
+      route: route.route,
+      priorityScore: route.priority_score,
+      urgency: getUrgency(route.priority_score),
+      stats: { openBugs: route.open_bugs, criticalBugs: route.critical_bugs, highBugs: route.high_bugs, testCases: route.test_case_count, daysSinceTest, regressions: route.regression_count, recentBugs: route.bugs_last_7_days },
+      recommendation: getRecommendation(route)
+    };
+    if (includeFactors) {
+      const bugFreqScore = Math.min(route.open_bugs * 5, 30);
+      const criticalScore = Math.min(route.critical_bugs * 25 + route.high_bugs * 10, 25);
+      const stalenessScore = daysSinceTest === null ? 20 : Math.min(daysSinceTest, 20);
+      const coverageScore = Math.max(15 - route.test_case_count * 5, 0);
+      const regressionScore = Math.min(route.regression_count * 10, 10);
+      priority.factors = {
+        bugFrequency: { score: bugFreqScore, openBugs: route.open_bugs, bugs7d: route.bugs_last_7_days },
+        criticalSeverity: { score: criticalScore, critical: route.critical_bugs, high: route.high_bugs },
+        staleness: { score: stalenessScore, daysSinceTest },
+        coverageGap: { score: coverageScore, testCount: route.test_case_count },
+        regressionRisk: { score: regressionScore, regressionCount: route.regression_count }
+      };
+    }
+    return priority;
+  });
+  const criticalCount = priorities.filter((p) => p.urgency === "critical").length;
+  const highCount = priorities.filter((p) => p.urgency === "high").length;
+  const mediumCount = priorities.filter((p) => p.urgency === "medium").length;
+  return {
+    priorities,
+    summary: { totalRoutes: routes.length, criticalCount, highCount, mediumCount },
+    guidance: criticalCount > 0 ? `URGENT: ${criticalCount} route(s) need immediate attention.` : highCount > 0 ? `${highCount} route(s) have high priority.` : "QA coverage is in good shape."
+  };
+}
+async function getCoverageGaps(supabase, projectId, args) {
+  const gapType = args.gap_type || "all";
+  const staleDays = args.stale_days || 14;
+  const gaps = { untested: [], missingTracks: [], stale: [] };
+  const { data: routesFromReports } = await supabase.from("reports").select("app_context").eq("project_id", projectId).not("app_context->currentRoute", "is", null);
+  const allRoutes = /* @__PURE__ */ new Set();
+  (routesFromReports || []).forEach((r) => {
+    const route = r.app_context?.currentRoute;
+    if (route) allRoutes.add(route);
+  });
+  const { data: testCases } = await supabase.from("test_cases").select("target_route, category, track_id").eq("project_id", projectId);
+  const coveredRoutes = /* @__PURE__ */ new Set();
+  const routeTrackCoverage = {};
+  (testCases || []).forEach((tc) => {
+    const route = tc.target_route || tc.category;
+    if (route) {
+      coveredRoutes.add(route);
+      if (!routeTrackCoverage[route]) routeTrackCoverage[route] = /* @__PURE__ */ new Set();
+      if (tc.track_id) routeTrackCoverage[route].add(tc.track_id);
+    }
+  });
+  const { data: tracks } = await supabase.from("qa_tracks").select("id, name").eq("project_id", projectId);
+  const trackMap = new Map((tracks || []).map((t) => [t.id, t.name]));
+  const { data: routeStats } = await supabase.from("route_test_stats").select("route, last_tested_at, open_bugs, critical_bugs").eq("project_id", projectId);
+  const routeStatsMap = new Map((routeStats || []).map((r) => [r.route, r]));
+  if (gapType === "all" || gapType === "untested_routes") {
+    allRoutes.forEach((route) => {
+      if (!coveredRoutes.has(route)) {
+        const stats = routeStatsMap.get(route);
+        const severity = (stats?.critical_bugs || 0) > 0 ? "critical" : (stats?.open_bugs || 0) > 2 ? "high" : "medium";
+        gaps.untested.push({ route, severity, type: "untested", details: { openBugs: stats?.open_bugs || 0, criticalBugs: stats?.critical_bugs || 0 }, recommendation: `Create test cases for ${route}` });
+      }
+    });
+    gaps.untested.sort((a, b) => {
+      const o = { critical: 0, high: 1, medium: 2 };
+      return (o[a.severity] || 2) - (o[b.severity] || 2);
+    });
+  }
+  if (gapType === "all" || gapType === "missing_tracks") {
+    coveredRoutes.forEach((route) => {
+      const coveredTracks = routeTrackCoverage[route] || /* @__PURE__ */ new Set();
+      const missingTracks = [];
+      trackMap.forEach((name, id) => {
+        if (!coveredTracks.has(id)) missingTracks.push(name);
+      });
+      if (missingTracks.length > 0 && missingTracks.length < trackMap.size) {
+        gaps.missingTracks.push({ route, severity: missingTracks.length > trackMap.size / 2 ? "high" : "medium", type: "missing_tracks", details: { missingTracks }, recommendation: `Add tests for tracks: ${missingTracks.join(", ")}` });
+      }
+    });
+  }
+  if (gapType === "all" || gapType === "stale_coverage") {
+    (routeStats || []).forEach((stat) => {
+      if (stat.last_tested_at) {
+        const daysSince = Math.floor((Date.now() - new Date(stat.last_tested_at).getTime()) / 864e5);
+        if (daysSince >= staleDays) {
+          gaps.stale.push({ route: stat.route, severity: daysSince >= staleDays * 2 ? "high" : "medium", type: "stale", details: { daysSinceTest: daysSince, openBugs: stat.open_bugs, criticalBugs: stat.critical_bugs }, recommendation: `Re-run tests for ${stat.route}` });
+        }
+      }
+    });
+    gaps.stale.sort((a, b) => (b.details.daysSinceTest || 0) - (a.details.daysSinceTest || 0));
+  }
+  const recommendations = [];
+  if (gaps.untested.length > 0) recommendations.push(`${gaps.untested.length} route(s) have bugs but no test coverage`);
+  if (gaps.missingTracks.length > 0) recommendations.push(`${gaps.missingTracks.length} route(s) are missing track-specific tests`);
+  if (gaps.stale.length > 0) recommendations.push(`${gaps.stale.length} route(s) have stale coverage (>${staleDays} days)`);
+  return { gaps, summary: { untestedRoutes: gaps.untested.length, routesMissingTracks: gaps.missingTracks.length, staleRoutes: gaps.stale.length }, recommendations };
+}
+async function getRegressions(supabase, projectId, args) {
+  const days = args.days || 30;
+  const includeHistory = args.include_history || false;
+  const cutoff = new Date(Date.now() - days * 864e5).toISOString();
+  const { data: resolvedBugs } = await supabase.from("reports").select("id, description, severity, app_context, resolved_at").eq("project_id", projectId).eq("report_type", "bug").in("status", ["resolved", "fixed", "verified", "closed"]).gte("resolved_at", cutoff);
+  const { data: newBugs } = await supabase.from("reports").select("id, description, severity, app_context, created_at").eq("project_id", projectId).eq("report_type", "bug").in("status", ["new", "triaging", "confirmed", "in_progress", "reviewed"]).gte("created_at", cutoff);
+  const routeData = {};
+  (resolvedBugs || []).forEach((bug) => {
+    const route = bug.app_context?.currentRoute;
+    if (route) {
+      if (!routeData[route]) routeData[route] = { resolved: [], new: [] };
+      routeData[route].resolved.push(bug);
+    }
+  });
+  (newBugs || []).forEach((bug) => {
+    const route = bug.app_context?.currentRoute;
+    if (route) {
+      if (!routeData[route]) routeData[route] = { resolved: [], new: [] };
+      routeData[route].new.push(bug);
+    }
+  });
+  const regressions = [];
+  let criticalCount = 0;
+  const recurringPatterns = [];
+  Object.entries(routeData).forEach(([route, data]) => {
+    if (data.resolved.length > 0 && data.new.length > 0) {
+      const latestResolved = data.resolved.sort((a, b) => new Date(b.resolved_at).getTime() - new Date(a.resolved_at).getTime())[0];
+      const daysSinceResolution = latestResolved.resolved_at ? Math.floor((Date.now() - new Date(latestResolved.resolved_at).getTime()) / 864e5) : null;
+      const severity = data.new.some((b) => b.severity === "critical") ? "critical" : data.new.some((b) => b.severity === "high") ? "high" : "medium";
+      if (severity === "critical") criticalCount++;
+      if (data.resolved.length >= 2 && data.new.length >= 2) recurringPatterns.push(route);
+      const regression = {
+        route,
+        severity,
+        originalBug: { id: latestResolved.id, description: latestResolved.description?.slice(0, 100) || "", resolvedAt: latestResolved.resolved_at },
+        newBugs: data.new.map((b) => ({ id: b.id, description: b.description?.slice(0, 100) || "", severity: b.severity, createdAt: b.created_at })),
+        daysSinceResolution,
+        regressionCount: data.resolved.length
+      };
+      if (includeHistory) regression.history = { totalResolved: data.resolved.length, totalNew: data.new.length, resolvedBugs: data.resolved.map((b) => ({ id: b.id, severity: b.severity, resolvedAt: b.resolved_at })) };
+      regressions.push(regression);
+    }
+  });
+  regressions.sort((a, b) => {
+    const o = { critical: 0, high: 1, medium: 2 };
+    return (o[a.severity] || 2) - (o[b.severity] || 2) || b.newBugs.length - a.newBugs.length;
+  });
+  const recommendations = [];
+  if (criticalCount > 0) recommendations.push(`URGENT: ${criticalCount} regression(s) involve critical bugs`);
+  if (recurringPatterns.length > 0) recommendations.push(`Recurring patterns in ${recurringPatterns.length} route(s): ${recurringPatterns.slice(0, 3).join(", ")}`);
+  if (regressions.length > 0) recommendations.push("Add regression tests to prevent recurrence");
+  return { regressions, summary: { totalRegressions: regressions.length, criticalRegressions: criticalCount, recurringPatterns: recurringPatterns.length }, recommendations };
+}
+async function getCoverageMatrix(supabase, projectId, args) {
+  const includeExecution = args.include_execution_data !== false;
+  const includeBugs = args.include_bug_counts !== false;
+  const { data: tracks } = await supabase.from("qa_tracks").select("id, name, icon, color").eq("project_id", projectId).order("sort_order");
+  const { data: testCases } = await supabase.from("test_cases").select("id, target_route, category, track_id").eq("project_id", projectId);
+  let assignments = [];
+  if (includeExecution) {
+    const { data } = await supabase.from("test_assignments").select("test_case_id, status, completed_at").eq("project_id", projectId).in("status", ["passed", "failed"]).order("completed_at", { ascending: false }).limit(2e3);
+    assignments = data || [];
+  }
+  let routeStats = [];
+  if (includeBugs) {
+    const { data } = await supabase.from("route_test_stats").select("route, open_bugs, critical_bugs").eq("project_id", projectId);
+    routeStats = data || [];
+  }
+  const routeStatsMap = new Map(routeStats.map((r) => [r.route, r]));
+  const assignmentsByTestCase = {};
+  assignments.forEach((a) => {
+    if (!assignmentsByTestCase[a.test_case_id]) assignmentsByTestCase[a.test_case_id] = { passed: 0, failed: 0, lastTested: null };
+    if (a.status === "passed") assignmentsByTestCase[a.test_case_id].passed++;
+    if (a.status === "failed") assignmentsByTestCase[a.test_case_id].failed++;
+    if (a.completed_at) {
+      const current = assignmentsByTestCase[a.test_case_id].lastTested;
+      if (!current || new Date(a.completed_at) > new Date(current)) assignmentsByTestCase[a.test_case_id].lastTested = a.completed_at;
+    }
+  });
+  const routeMap = {};
+  (testCases || []).forEach((tc) => {
+    const route = tc.target_route || tc.category || "Uncategorized";
+    if (!routeMap[route]) routeMap[route] = { testCases: [], trackCoverage: {} };
+    routeMap[route].testCases.push(tc);
+    const trackId = tc.track_id || "none";
+    if (!routeMap[route].trackCoverage[trackId]) routeMap[route].trackCoverage[trackId] = [];
+    routeMap[route].trackCoverage[trackId].push(tc);
+  });
+  const matrix = [];
+  const now = Date.now();
+  Object.entries(routeMap).forEach(([route, data]) => {
+    const row = { route, totalTests: data.testCases.length, tracks: {} };
+    if (includeBugs) {
+      const stats = routeStatsMap.get(route);
+      row.openBugs = stats?.open_bugs || 0;
+      row.criticalBugs = stats?.critical_bugs || 0;
+    }
+    let latestTest = null;
+    data.testCases.forEach((tc) => {
+      const execData = assignmentsByTestCase[tc.id];
+      if (execData?.lastTested && (!latestTest || new Date(execData.lastTested) > new Date(latestTest))) latestTest = execData.lastTested;
+    });
+    row.lastTestedAt = latestTest;
+    (tracks || []).forEach((track) => {
+      const trackTests = data.trackCoverage[track.id] || [];
+      const cell = { testCount: trackTests.length };
+      if (includeExecution && trackTests.length > 0) {
+        let passCount = 0, failCount = 0;
+        let trackLastTested = null;
+        trackTests.forEach((tc) => {
+          const execData = assignmentsByTestCase[tc.id];
+          if (execData) {
+            passCount += execData.passed;
+            failCount += execData.failed;
+            if (execData.lastTested && (!trackLastTested || new Date(execData.lastTested) > new Date(trackLastTested))) trackLastTested = execData.lastTested;
+          }
+        });
+        cell.passCount = passCount;
+        cell.failCount = failCount;
+        cell.passRate = passCount + failCount > 0 ? Math.round(passCount / (passCount + failCount) * 100) : null;
+        cell.lastTestedAt = trackLastTested;
+        cell.staleDays = trackLastTested ? Math.floor((now - new Date(trackLastTested).getTime()) / 864e5) : null;
+      }
+      row.tracks[track.id] = cell;
+    });
+    const unassignedTests = data.trackCoverage["none"] || [];
+    if (unassignedTests.length > 0) {
+      const cell = { testCount: unassignedTests.length };
+      if (includeExecution) {
+        let passCount = 0, failCount = 0;
+        unassignedTests.forEach((tc) => {
+          const execData = assignmentsByTestCase[tc.id];
+          if (execData) {
+            passCount += execData.passed;
+            failCount += execData.failed;
+          }
+        });
+        cell.passCount = passCount;
+        cell.failCount = failCount;
+        cell.passRate = passCount + failCount > 0 ? Math.round(passCount / (passCount + failCount) * 100) : null;
+      }
+      row.tracks["none"] = cell;
+    }
+    matrix.push(row);
+  });
+  matrix.sort((a, b) => a.route.localeCompare(b.route));
+  return {
+    matrix,
+    tracks: (tracks || []).map((t) => ({ id: t.id, name: t.name, icon: t.icon, color: t.color })),
+    summary: { totalRoutes: matrix.length, totalTests: matrix.reduce((sum, r) => sum + r.totalTests, 0), routesWithCriticalBugs: includeBugs ? matrix.filter((r) => r.criticalBugs > 0).length : void 0 }
+  };
+}
+async function getStaleCoverage(supabase, projectId, args) {
+  const daysThreshold = args.days_threshold || 14;
+  const limit = args.limit || 20;
+  await tryRefreshRouteStats(supabase, projectId);
+  const { data: routes, error } = await supabase.from("route_test_stats").select("route, last_tested_at, open_bugs, critical_bugs, test_case_count, priority_score").eq("project_id", projectId).order("last_tested_at", { ascending: true, nullsFirst: true }).limit(limit * 2);
+  if (error) return { error: error.message };
+  const now = Date.now();
+  const staleRoutes = [];
+  (routes || []).forEach((route) => {
+    let daysSinceTest = null;
+    if (route.last_tested_at) {
+      daysSinceTest = Math.floor((now - new Date(route.last_tested_at).getTime()) / 864e5);
+      if (daysSinceTest < daysThreshold) return;
+    }
+    const riskLevel = route.critical_bugs > 0 ? "critical" : route.open_bugs > 2 ? "high" : daysSinceTest === null ? "high" : "medium";
+    staleRoutes.push({
+      route: route.route,
+      daysSinceTest,
+      neverTested: route.last_tested_at === null,
+      lastTestedAt: route.last_tested_at,
+      openBugs: route.open_bugs,
+      criticalBugs: route.critical_bugs,
+      testCaseCount: route.test_case_count,
+      riskLevel,
+      priorityScore: route.priority_score,
+      recommendation: route.last_tested_at === null ? "Never tested - establish baseline coverage immediately" : `Last tested ${daysSinceTest} days ago - refresh testing`
+    });
+  });
+  staleRoutes.sort((a, b) => {
+    const o = { critical: 0, high: 1, medium: 2 };
+    const riskDiff = (o[a.riskLevel] || 2) - (o[b.riskLevel] || 2);
+    if (riskDiff !== 0) return riskDiff;
+    if (a.neverTested && !b.neverTested) return -1;
+    if (!a.neverTested && b.neverTested) return 1;
+    return (b.daysSinceTest || 999) - (a.daysSinceTest || 999);
+  });
+  return {
+    staleRoutes: staleRoutes.slice(0, limit),
+    summary: { totalStale: staleRoutes.length, neverTested: staleRoutes.filter((r) => r.neverTested).length, withCriticalBugs: staleRoutes.filter((r) => r.criticalBugs > 0).length, threshold: daysThreshold },
+    guidance: staleRoutes.length > 0 ? `${staleRoutes.length} route(s) have stale or missing test coverage.` : "All routes have been tested within the threshold period."
+  };
+}
+async function generateDeployChecklist(supabase, projectId, args) {
+  const routes = args.routes;
+  const deploymentType = args.deployment_type || "feature";
+  const allRoutes = new Set(routes);
+  if (args.changed_files) {
+    args.changed_files.forEach((file) => {
+      const matches = [/\/app\/(.+?)\/page\./, /\/pages\/(.+?)\./, /\/routes\/(.+?)\./, /\/screens\/(.+?)\./];
+      for (const pattern of matches) {
+        const match = file.match(pattern);
+        if (match) {
+          allRoutes.add("/" + match[1].replace(/\[.*?\]/g, ":id"));
+        }
+      }
+    });
+  }
+  const safeRoutes = routes.slice(0, 100);
+  const [{ data: byRoute }, { data: byCategory }] = await Promise.all([
+    supabase.from("test_cases").select("id, test_key, title, target_route, category, priority, track:qa_tracks(name)").eq("project_id", projectId).in("target_route", safeRoutes),
+    supabase.from("test_cases").select("id, test_key, title, target_route, category, priority, track:qa_tracks(name)").eq("project_id", projectId).in("category", safeRoutes)
+  ]);
+  const seenIds = /* @__PURE__ */ new Set();
+  const testCases = [...byRoute || [], ...byCategory || []].filter((tc) => {
+    if (seenIds.has(tc.id)) return false;
+    seenIds.add(tc.id);
+    return true;
+  });
+  const { data: routeStats } = await supabase.from("route_test_stats").select("*").eq("project_id", projectId).in("route", Array.from(allRoutes));
+  const routeStatsMap = new Map((routeStats || []).map((r) => [r.route, r]));
+  const checklist = { critical: [], recommended: [], optional: [], gaps: [] };
+  const coveredRoutes = /* @__PURE__ */ new Set();
+  (testCases || []).forEach((tc) => {
+    const route = tc.target_route || tc.category || "";
+    coveredRoutes.add(route);
+    const stats = routeStatsMap.get(route);
+    const item = { testCaseId: tc.id, testKey: tc.test_key, title: tc.title, route, track: tc.track?.name, priority: tc.priority, hasCriticalBugs: (stats?.critical_bugs || 0) > 0, lastTested: stats?.last_tested_at, reason: "" };
+    if (tc.priority === "P0" || (stats?.critical_bugs || 0) > 0) {
+      item.reason = tc.priority === "P0" ? "P0 priority test case" : `Route has ${stats?.critical_bugs} critical bug(s)`;
+      checklist.critical.push(item);
+    } else if (tc.priority === "P1" || deploymentType === "hotfix") {
+      item.reason = deploymentType === "hotfix" ? "Hotfix deployment - verify fix" : "P1 priority test case";
+      checklist.recommended.push(item);
+    } else if (deploymentType === "release") {
+      item.reason = "Release deployment - full verification";
+      checklist.recommended.push(item);
+    } else {
+      item.reason = "Standard test coverage";
+      checklist.optional.push(item);
+    }
+  });
+  allRoutes.forEach((route) => {
+    if (!coveredRoutes.has(route)) {
+      const stats = routeStatsMap.get(route);
+      checklist.gaps.push({ route, title: `No test coverage for ${route}`, reason: "Route is being deployed but has no test cases", hasCriticalBugs: (stats?.critical_bugs || 0) > 0, openBugs: stats?.open_bugs || 0, recommendation: `Create test cases for ${route} before deploying` });
+    }
+  });
+  const thoroughness = allRoutes.size > 0 ? Math.round(coveredRoutes.size / allRoutes.size * 100) : 100;
+  let guidance = "";
+  if (checklist.critical.length > 0) guidance = `MUST RUN: ${checklist.critical.length} critical test(s) before deploying. `;
+  if (checklist.gaps.length > 0) guidance += `WARNING: ${checklist.gaps.length} route(s) have no test coverage. `;
+  if (deploymentType === "hotfix") guidance += "Hotfix mode: Focus on critical and recommended tests.";
+  else if (deploymentType === "release") guidance += "Release mode: Run all tests for comprehensive verification.";
+  return { checklist, summary: { criticalTests: checklist.critical.length, recommendedTests: checklist.recommended.length, optionalTests: checklist.optional.length, coverageGaps: checklist.gaps.length, thoroughness, deploymentType }, guidance: guidance || "Ready to deploy with standard test coverage." };
+}
+async function getQAHealth(supabase, projectId, args) {
+  const periodDays = args.period_days || 30;
+  const comparePrevious = args.compare_previous !== false;
+  const now = /* @__PURE__ */ new Date();
+  const periodStart = new Date(now.getTime() - periodDays * 864e5);
+  const previousStart = new Date(periodStart.getTime() - periodDays * 864e5);
+  const { data: currentTests } = await supabase.from("test_assignments").select("id, status, completed_at").eq("project_id", projectId).gte("completed_at", periodStart.toISOString()).in("status", ["passed", "failed"]);
+  const { data: currentBugs } = await supabase.from("reports").select("id, severity, status, created_at").eq("project_id", projectId).eq("report_type", "bug").gte("created_at", periodStart.toISOString());
+  const { data: resolvedBugs } = await supabase.from("reports").select("id, created_at, resolved_at").eq("project_id", projectId).eq("report_type", "bug").in("status", ["resolved", "fixed", "verified", "closed"]).gte("resolved_at", periodStart.toISOString());
+  const { data: testers } = await supabase.from("testers").select("id, status").eq("project_id", projectId);
+  const { data: routeStats } = await supabase.from("route_test_stats").select("route, test_case_count").eq("project_id", projectId);
+  let previousTests = [], previousBugs = [], previousResolved = [];
+  if (comparePrevious) {
+    const { data: pt } = await supabase.from("test_assignments").select("id, status").eq("project_id", projectId).gte("completed_at", previousStart.toISOString()).lt("completed_at", periodStart.toISOString()).in("status", ["passed", "failed"]);
+    previousTests = pt || [];
+    const { data: pb } = await supabase.from("reports").select("id, severity").eq("project_id", projectId).eq("report_type", "bug").gte("created_at", previousStart.toISOString()).lt("created_at", periodStart.toISOString());
+    previousBugs = pb || [];
+    const { data: pr } = await supabase.from("reports").select("id").eq("project_id", projectId).in("status", ["resolved", "fixed", "verified", "closed"]).gte("resolved_at", previousStart.toISOString()).lt("resolved_at", periodStart.toISOString());
+    previousResolved = pr || [];
+  }
+  const testsCompleted = (currentTests || []).length;
+  const testsPerWeek = Math.round(testsCompleted / (periodDays / 7));
+  const prevTestsPerWeek = comparePrevious ? Math.round(previousTests.length / (periodDays / 7)) : 0;
+  const bugsFound = (currentBugs || []).length;
+  const criticalBugs = (currentBugs || []).filter((b) => b.severity === "critical").length;
+  const bugsPerTest = testsCompleted > 0 ? Math.round(bugsFound / testsCompleted * 100) / 100 : 0;
+  const bugsResolvedCount = (resolvedBugs || []).length;
+  let avgResolutionDays = 0;
+  if (resolvedBugs && resolvedBugs.length > 0) {
+    const totalDays = resolvedBugs.reduce((sum, bug) => {
+      if (bug.created_at && bug.resolved_at) return sum + (new Date(bug.resolved_at).getTime() - new Date(bug.created_at).getTime()) / 864e5;
+      return sum;
+    }, 0);
+    avgResolutionDays = Math.round(totalDays / resolvedBugs.length);
+  }
+  const totalRoutes = (routeStats || []).length;
+  const routesWithTests = (routeStats || []).filter((r) => r.test_case_count > 0).length;
+  const routeCoverage = totalRoutes > 0 ? Math.round(routesWithTests / totalRoutes * 100) : 0;
+  const totalTesters = (testers || []).length;
+  const activeTesters = (testers || []).filter((t) => t.status === "active").length;
+  const utilizationPercent = totalTesters > 0 ? Math.round(activeTesters / totalTesters * 100) : 0;
+  const getTrend = (current, previous) => {
+    if (!comparePrevious || previous === 0) return "stable";
+    const change = (current - previous) / previous * 100;
+    return change > 10 ? "up" : change < -10 ? "down" : "stable";
+  };
+  const getChangePercent = (current, previous) => !comparePrevious || previous === 0 ? void 0 : Math.round((current - previous) / previous * 100);
+  const coverageScore = routeCoverage;
+  const velocityScore = Math.min(testsPerWeek * 10, 100);
+  const resolutionScore = avgResolutionDays <= 3 ? 100 : avgResolutionDays <= 7 ? 75 : avgResolutionDays <= 14 ? 50 : 25;
+  const stabilityScore = criticalBugs === 0 ? 100 : criticalBugs === 1 ? 75 : criticalBugs <= 3 ? 50 : 25;
+  const overallScore = Math.round(coverageScore * 0.3 + velocityScore * 0.25 + resolutionScore * 0.25 + stabilityScore * 0.2);
+  const getGrade = (score) => score >= 90 ? "A" : score >= 80 ? "B" : score >= 70 ? "C" : score >= 60 ? "D" : "F";
+  const recommendations = [];
+  if (coverageScore < 70) recommendations.push(`Increase test coverage (currently ${routeCoverage}%)`);
+  if (velocityScore < 50) recommendations.push(`Increase testing velocity (${testsPerWeek}/week)`);
+  if (avgResolutionDays > 7) recommendations.push(`Improve bug resolution time (currently ${avgResolutionDays} days)`);
+  if (criticalBugs > 0) recommendations.push(`Address ${criticalBugs} critical bug(s) immediately`);
+  if (utilizationPercent < 50) recommendations.push(`Improve tester utilization (${utilizationPercent}%)`);
+  return {
+    metrics: {
+      velocity: { testsPerWeek, testsCompleted, trend: getTrend(testsPerWeek, prevTestsPerWeek), changePercent: getChangePercent(testsPerWeek, prevTestsPerWeek) },
+      bugDiscovery: { bugsFound, bugsPerTest, criticalBugs, trend: getTrend(bugsFound, previousBugs.length), changePercent: getChangePercent(bugsFound, previousBugs.length) },
+      resolution: { bugsResolved: bugsResolvedCount, avgResolutionDays, trend: getTrend(bugsResolvedCount, previousResolved.length), changePercent: getChangePercent(bugsResolvedCount, previousResolved.length) },
+      coverage: { routeCoverage, routesWithTests, totalRoutes },
+      testerHealth: { activeTesters, totalTesters, utilizationPercent }
+    },
+    healthScore: { score: overallScore, grade: getGrade(overallScore), breakdown: { coverage: coverageScore, velocity: velocityScore, resolution: resolutionScore, stability: stabilityScore } },
+    recommendations,
+    period: { days: periodDays, start: periodStart.toISOString(), end: now.toISOString() }
+  };
+}
+async function getQASessions(supabase, projectId, args) {
+  const status = args.status || "all";
+  const limit = Math.min(args.limit || 20, 50);
+  const includeFindings = args.include_findings !== false;
+  let query = supabase.from("qa_sessions").select(`id, focus_area, track, platform, started_at, ended_at, notes, routes_covered, status, duration_minutes, findings_count, bugs_filed, created_at, tester:testers(id, name, email)`).eq("project_id", projectId).order("started_at", { ascending: false }).limit(limit);
+  if (status !== "all") query = query.eq("status", status);
+  if (args.tester_id && isValidUUID(args.tester_id)) query = query.eq("tester_id", args.tester_id);
+  const { data: sessions, error } = await query;
+  if (error) return { error: error.message };
+  let sessionsWithFindings = sessions || [];
+  if (includeFindings && sessions && sessions.length > 0) {
+    const sessionIds = sessions.map((s) => s.id);
+    const { data: findings } = await supabase.from("qa_findings").select("id, session_id, type, severity, title, description, route, converted_to_bug_id, dismissed").in("session_id", sessionIds);
+    const findingsBySession = (findings || []).reduce((acc, f) => {
+      acc[f.session_id] = acc[f.session_id] || [];
+      acc[f.session_id].push(f);
+      return acc;
+    }, {});
+    sessionsWithFindings = sessions.map((s) => ({ ...s, findings: findingsBySession[s.id] || [] }));
+  }
+  return {
+    sessions: sessionsWithFindings,
+    summary: { total: sessionsWithFindings.length, active: sessionsWithFindings.filter((s) => s.status === "active").length, completed: sessionsWithFindings.filter((s) => s.status === "completed").length, totalFindings: sessionsWithFindings.reduce((sum, s) => sum + (s.findings_count || 0), 0), totalBugsFiled: sessionsWithFindings.reduce((sum, s) => sum + (s.bugs_filed || 0), 0) }
+  };
+}
+async function getQAAlerts(supabase, projectId, args) {
+  const severity = args.severity || "all";
+  const type = args.type || "all";
+  const status = args.status || "active";
+  if (args.refresh) await supabase.rpc("detect_all_alerts", { p_project_id: projectId });
+  let query = supabase.from("qa_alerts").select("*").eq("project_id", projectId).order("severity", { ascending: true }).order("created_at", { ascending: false });
+  if (severity !== "all") query = query.eq("severity", severity);
+  if (type !== "all") query = query.eq("type", type);
+  if (status !== "all") query = query.eq("status", status);
+  const { data: alerts, error } = await query;
+  if (error) return { error: error.message };
+  return {
+    alerts: alerts?.map((a) => ({ id: a.id, type: a.type, severity: a.severity, title: a.title, description: a.description, route: a.trigger_route, track: a.trigger_track, recommendation: a.recommendation, action_type: a.action_type, status: a.status, created_at: a.created_at })),
+    summary: { total: alerts?.length || 0, critical: alerts?.filter((a) => a.severity === "critical").length || 0, warning: alerts?.filter((a) => a.severity === "warning").length || 0, info: alerts?.filter((a) => a.severity === "info").length || 0, byType: { hot_spot: alerts?.filter((a) => a.type === "hot_spot").length || 0, coverage_gap: alerts?.filter((a) => a.type === "coverage_gap").length || 0, track_gap: alerts?.filter((a) => a.type === "track_gap").length || 0 } }
+  };
+}
+
+// src/deploy.ts
+async function getDeploymentAnalysis(supabase, projectId, args) {
+  const limit = Math.min(args.limit || 10, 50);
+  const includeTestingPriority = args.include_testing_priority !== false;
+  if (args.deployment_id && isValidUUID(args.deployment_id)) {
+    const { data: deployment, error: error2 } = await supabase.from("deployments").select("*").eq("id", args.deployment_id).eq("project_id", projectId).single();
+    if (error2) return { error: error2.message };
+    return { deployment };
+  }
+  let query = supabase.from("deployments").select("*").eq("project_id", projectId).order("deployed_at", { ascending: false }).limit(limit);
+  if (args.environment && args.environment !== "all") {
+    query = query.eq("environment", args.environment);
+  }
+  const { data: deployments, error } = await query;
+  if (error) return { error: error.message };
+  const summary = {
+    total: deployments?.length || 0,
+    avgRiskScore: deployments?.length ? Math.round(deployments.reduce((sum, d) => sum + (d.risk_score || 0), 0) / deployments.length) : 0,
+    highRisk: deployments?.filter((d) => (d.risk_score || 0) >= 70).length || 0,
+    verified: deployments?.filter((d) => d.verified_at).length || 0
+  };
+  return {
+    deployments: deployments?.map((d) => ({
+      id: d.id,
+      environment: d.environment,
+      commit_sha: d.commit_sha,
+      commit_message: d.commit_message,
+      branch: d.branch,
+      deployed_at: d.deployed_at,
+      risk_score: d.risk_score,
+      routes_affected: d.routes_affected,
+      testing_priority: includeTestingPriority ? d.testing_priority : void 0,
+      verified: !!d.verified_at
+    })),
+    summary
+  };
+}
+async function getTesterRecommendations(supabase, _projectId, args) {
+  if (!isValidUUID(args.test_case_id)) {
+    return { error: "Invalid test_case_id format" };
+  }
+  const limit = Math.min(args.limit || 5, 10);
+  const { data: recommendations, error } = await supabase.rpc("get_tester_recommendations", {
+    p_test_case_id: args.test_case_id,
+    p_limit: limit
+  });
+  if (error) return { error: error.message };
+  const { data: testCase } = await supabase.from("test_cases").select("test_key, title, track:qa_tracks(name)").eq("id", args.test_case_id).single();
+  return {
+    test_case: testCase ? {
+      id: args.test_case_id,
+      test_key: testCase.test_key,
+      title: testCase.title,
+      track: testCase.track?.name
+    } : null,
+    recommendations: recommendations?.map((r) => ({
+      tester_id: r.tester_id,
+      name: r.tester_name,
+      email: r.tester_email,
+      match_score: r.match_score,
+      reasons: r.match_reasons
+    })) || []
+  };
+}
+async function analyzeCommitForTesting(supabase, projectId, args) {
+  const filesChanged = args.files_changed || [];
+  const { data: mappings } = await supabase.from("file_route_mapping").select("file_pattern, route, feature, confidence").eq("project_id", projectId);
+  const affectedRoutes = [];
+  for (const mapping of mappings || []) {
+    const matchedFiles = filesChanged.filter((file) => {
+      try {
+        if (mapping.file_pattern.length > 200) return false;
+        const pattern = mapping.file_pattern.replace(/[.+?^${}()|[\]\\]/g, "\\$&").replace(/\\\*\\\*/g, ".*").replace(/\\\*/g, "[^/]*");
+        return new RegExp(`^${pattern}$`).test(file);
+      } catch {
+        return false;
+      }
+    });
+    if (matchedFiles.length > 0) {
+      affectedRoutes.push({
+        route: mapping.route,
+        feature: mapping.feature || void 0,
+        confidence: mapping.confidence,
+        matched_files: matchedFiles
+      });
+    }
+  }
+  const routes = affectedRoutes.map((r) => r.route);
+  let bugHistory = [];
+  if (routes.length > 0) {
+    const { data: bugs } = await supabase.from("reports").select("id, severity, description, route, created_at").eq("project_id", projectId).eq("report_type", "bug").in("route", routes).gte("created_at", new Date(Date.now() - 30 * 24 * 60 * 60 * 1e3).toISOString());
+    bugHistory = bugs || [];
+  }
+  let riskScore = 0;
+  riskScore += Math.min(filesChanged.length * 2, 20);
+  riskScore += Math.min(affectedRoutes.length * 5, 30);
+  riskScore += Math.min(bugHistory.length * 10, 50);
+  const recommendations = affectedRoutes.map((r) => {
+    const routeBugs = bugHistory.filter((b) => b.route === r.route);
+    const priority = routeBugs.length >= 3 ? "critical" : routeBugs.length >= 1 ? "high" : "medium";
+    return {
+      route: r.route,
+      feature: r.feature,
+      priority,
+      reason: routeBugs.length > 0 ? `${routeBugs.length} bug(s) in last 30 days` : "Code changed in this area",
+      recent_bugs: routeBugs.length
+    };
+  }).sort((a, b) => {
+    const order = { critical: 0, high: 1, medium: 2 };
+    return (order[a.priority] || 2) - (order[b.priority] || 2);
+  });
+  if (args.record_deployment) {
+    await supabase.rpc("record_deployment", {
+      p_project_id: projectId,
+      p_environment: "production",
+      p_commit_sha: args.commit_sha || null,
+      p_commit_message: args.commit_message || null,
+      p_files_changed: filesChanged,
+      p_webhook_source: "mcp"
+    });
+  }
+  return {
+    commit_sha: args.commit_sha,
+    files_analyzed: filesChanged.length,
+    risk_score: Math.min(riskScore, 100),
+    affected_routes: affectedRoutes,
+    bug_history_summary: {
+      total: bugHistory.length,
+      critical: bugHistory.filter((b) => b.severity === "critical").length,
+      high: bugHistory.filter((b) => b.severity === "high").length
+    },
+    testing_recommendations: recommendations,
+    deployment_recorded: args.record_deployment || false
+  };
+}
+async function getTestingPatterns(supabase, _projectId, args) {
+  let patterns = [];
+  if (args.search) {
+    const { data, error } = await supabase.rpc("search_patterns", {
+      p_query: args.search,
+      p_limit: 20
+    });
+    if (!error) patterns = data || [];
+  } else if (args.feature_type) {
+    const { data, error } = await supabase.rpc("get_patterns_for_feature", {
+      p_category: args.feature_type,
+      p_framework: args.framework || null,
+      p_tracks: args.tracks || null
+    });
+    if (!error) patterns = data || [];
+  } else {
+    const { data, error } = await supabase.from("qa_patterns").select("*").eq("is_active", true).order("severity").limit(30);
+    if (!error) patterns = data || [];
+  }
+  const summary = {
+    total: patterns.length,
+    by_severity: {
+      critical: patterns.filter((p) => p.severity === "critical").length,
+      high: patterns.filter((p) => p.severity === "high").length,
+      medium: patterns.filter((p) => p.severity === "medium").length,
+      low: patterns.filter((p) => p.severity === "low").length
+    },
+    by_track: patterns.reduce((acc, p) => {
+      acc[p.track] = (acc[p.track] || 0) + 1;
+      return acc;
+    }, {})
+  };
+  return {
+    patterns: patterns.map((p) => ({
+      title: p.title,
+      category: p.category,
+      track: p.track,
+      severity: p.severity,
+      description: p.description,
+      why_it_happens: p.why_it_happens,
+      suggested_tests: p.suggested_tests,
+      common_fix: p.common_fix,
+      source: p.source,
+      frameworks: p.frameworks
+    })),
+    summary,
+    note: "Patterns are from public knowledge (OWASP, WCAG, framework docs), not customer data."
+  };
+}
+async function analyzeChangesForTests(supabase, projectId, args) {
+  const { data: existingTests } = await supabase.from("test_cases").select("test_key, title, target_route, description").eq("project_id", projectId);
+  const { data: lastTest } = await supabase.from("test_cases").select("test_key").eq("project_id", projectId).order("test_key", { ascending: false }).limit(1);
+  const lastKey = lastTest?.[0]?.test_key || "TC-000";
+  const lastNum = parseInt(lastKey.replace("TC-", "")) || 0;
+  const routes = args.affected_routes || [];
+  let relatedBugs = [];
+  if (routes.length > 0) {
+    const { data: bugs } = await supabase.from("reports").select("id, description, severity, app_context").eq("project_id", projectId).eq("report_type", "bug").limit(50);
+    relatedBugs = (bugs || []).filter((bug) => {
+      const bugRoute = bug.app_context?.currentRoute;
+      return bugRoute && routes.some((r) => bugRoute.includes(r) || r.includes(bugRoute));
+    });
+  }
+  const fileAnalysis = analyzeFileTypes(args.changed_files);
+  const existingCoverage = (existingTests || []).filter(
+    (test) => routes.some((r) => test.target_route?.includes(r) || test.title.toLowerCase().includes(r.toLowerCase()))
+  );
+  const suggestions = [];
+  let testNum = lastNum;
+  if (args.change_type === "feature") {
+    for (const route of routes.slice(0, 2)) {
+      testNum++;
+      suggestions.push({
+        test_key: `TC-${String(testNum).padStart(3, "0")}`,
+        title: `Verify new feature: ${args.change_summary.slice(0, 40)}`,
+        description: `Test the new functionality added: ${args.change_summary}`,
+        track: "functional",
+        priority: "P1",
+        target_route: route,
+        rationale: "New features require verification that they work as intended",
+        steps: [
+          { stepNumber: 1, action: `Navigate to ${route}`, expectedResult: "Page loads successfully" },
+          { stepNumber: 2, action: "Locate the new feature/element", expectedResult: "Feature is visible and accessible" },
+          { stepNumber: 3, action: "Interact with the new feature", expectedResult: "Feature responds as expected" },
+          { stepNumber: 4, action: "Verify the expected outcome", expectedResult: "Correct result is produced" }
+        ],
+        expected_result: "New feature functions correctly without errors"
+      });
+    }
+    if (routes.length > 0) {
+      testNum++;
+      suggestions.push({
+        test_key: `TC-${String(testNum).padStart(3, "0")}`,
+        title: `Edge cases: ${args.change_summary.slice(0, 35)}`,
+        description: `Test edge cases and error handling for the new feature`,
+        track: "functional",
+        priority: "P2",
+        target_route: routes[0],
+        rationale: "Edge cases often reveal bugs that happy-path testing misses",
+        steps: [
+          { stepNumber: 1, action: `Navigate to ${routes[0]}`, expectedResult: "Page loads" },
+          { stepNumber: 2, action: "Test with empty/null input", expectedResult: "Graceful handling, no crash" },
+          { stepNumber: 3, action: "Test with invalid input", expectedResult: "Appropriate error message" },
+          { stepNumber: 4, action: "Test boundary conditions", expectedResult: "Correct behavior at limits" }
+        ],
+        expected_result: "Feature handles edge cases gracefully without errors"
+      });
+    }
+  }
+  if (args.change_type === "bugfix") {
+    for (const route of routes.slice(0, 1)) {
+      testNum++;
+      suggestions.push({
+        test_key: `TC-${String(testNum).padStart(3, "0")}`,
+        title: `Regression: ${args.change_summary.slice(0, 40)}`,
+        description: `Verify the bug fix works and hasn't regressed: ${args.change_summary}`,
+        track: "functional",
+        priority: "P1",
+        target_route: route,
+        rationale: "Bug fixes should have regression tests to prevent recurrence",
+        steps: [
+          { stepNumber: 1, action: `Navigate to ${route}`, expectedResult: "Page loads" },
+          { stepNumber: 2, action: "Reproduce the original bug scenario", expectedResult: "Bug no longer occurs" },
+          { stepNumber: 3, action: "Test related functionality", expectedResult: "No side effects from fix" }
+        ],
+        expected_result: "Bug is fixed and related functionality still works"
+      });
+    }
+  }
+  if (args.change_type === "ui_change") {
+    for (const route of routes.slice(0, 1)) {
+      testNum++;
+      suggestions.push({
+        test_key: `TC-${String(testNum).padStart(3, "0")}`,
+        title: `UI verification: ${args.change_summary.slice(0, 35)}`,
+        description: `Verify UI changes display correctly across devices`,
+        track: "design",
+        priority: "P2",
+        target_route: route,
+        rationale: "UI changes should be verified visually and for responsiveness",
+        steps: [
+          { stepNumber: 1, action: `Navigate to ${route}`, expectedResult: "Page loads" },
+          { stepNumber: 2, action: "Verify visual appearance matches design", expectedResult: "UI looks correct" },
+          { stepNumber: 3, action: "Test on mobile viewport (375px)", expectedResult: "Responsive layout works" },
+          { stepNumber: 4, action: "Test interactive elements", expectedResult: "Buttons, links work correctly" }
+        ],
+        expected_result: "UI changes look correct and are responsive"
+      });
+    }
+  }
+  if (args.change_type === "api_change") {
+    for (const route of routes.slice(0, 1)) {
+      testNum++;
+      suggestions.push({
+        test_key: `TC-${String(testNum).padStart(3, "0")}`,
+        title: `API integration: ${args.change_summary.slice(0, 35)}`,
+        description: `Verify API changes work correctly end-to-end`,
+        track: "functional",
+        priority: "P1",
+        target_route: route,
+        rationale: "API changes can break frontend functionality",
+        steps: [
+          { stepNumber: 1, action: `Navigate to ${route}`, expectedResult: "Page loads" },
+          { stepNumber: 2, action: "Trigger the API call", expectedResult: "Request is sent" },
+          { stepNumber: 3, action: "Verify response handling", expectedResult: "Data displays correctly" },
+          { stepNumber: 4, action: "Test error scenarios", expectedResult: "Errors handled gracefully" }
+        ],
+        expected_result: "API integration works correctly"
+      });
+    }
+  }
+  if (fileAnalysis.hasUIComponents && (args.change_type === "feature" || args.change_type === "ui_change")) {
+    testNum++;
+    suggestions.push({
+      test_key: `TC-${String(testNum).padStart(3, "0")}`,
+      title: `Accessibility: ${args.change_summary.slice(0, 35)}`,
+      description: `Verify changes meet accessibility standards`,
+      track: "accessibility",
+      priority: "P2",
+      target_route: routes[0] || null,
+      rationale: "UI changes should maintain accessibility compliance",
+      steps: [
+        { stepNumber: 1, action: "Navigate using keyboard only (Tab)", expectedResult: "All interactive elements reachable" },
+        { stepNumber: 2, action: "Check focus indicators", expectedResult: "Focus is visible on all elements" },
+        { stepNumber: 3, action: "Verify with screen reader", expectedResult: "Content is announced correctly" }
+      ],
+      expected_result: "Changes are accessible to all users"
+    });
+  }
+  const shouldCreateTests = suggestions.length > 0 && (args.change_type !== "config" && args.change_type !== "refactor");
+  const coverageRatio = existingCoverage.length / Math.max(routes.length, 1);
+  return {
+    analysis: {
+      change_type: args.change_type,
+      files_changed: args.changed_files.length,
+      file_types: fileAnalysis,
+      affected_routes: routes,
+      existing_coverage: existingCoverage.length,
+      related_bugs: relatedBugs.length,
+      coverage_ratio: coverageRatio
+    },
+    recommendation: {
+      should_create_tests: shouldCreateTests,
+      urgency: args.change_type === "feature" || args.change_type === "bugfix" ? "high" : args.change_type === "api_change" ? "medium" : "low",
+      reason: shouldCreateTests ? `${args.change_type === "feature" ? "New features" : args.change_type === "bugfix" ? "Bug fixes" : "Changes"} should have QA coverage to catch issues early.` : args.change_type === "config" ? "Config changes typically don't need manual QA tests." : "Refactoring with good existing coverage may not need new tests."
+    },
+    suggestions: suggestions.map((s) => ({
+      ...s,
+      create_command: `create_test_case with test_key="${s.test_key}", title="${s.title}", target_route="${s.target_route}"`
+    })),
+    existing_tests: existingCoverage.slice(0, 5).map((t) => ({
+      test_key: t.test_key,
+      title: t.title,
+      target_route: t.target_route
+    })),
+    next_steps: shouldCreateTests ? [
+      "Review the suggested tests above",
+      "Modify titles/steps as needed for your specific implementation",
+      "Use create_test_case to add the ones that make sense",
+      "Skip any that duplicate existing coverage"
+    ] : ["No new tests recommended for this change type"]
+  };
+}
+
+// src/bugs.ts
+async function createBugReport(supabase, projectId, args) {
+  const codeContext = {};
+  if (args.file_path) {
+    codeContext.file_path = args.file_path;
+    codeContext.line_number = args.line_number;
+    codeContext.code_snippet = args.code_snippet;
+    codeContext.function_name = extractFunctionName(args.code_snippet);
+  }
+  if (args.related_files) codeContext.related_files = args.related_files;
+  if (args.suggested_fix) codeContext.suggested_fix = args.suggested_fix;
+  let reporterId = null;
+  const { data: project } = await supabase.from("projects").select("owner_id").eq("id", projectId).single();
+  if (project?.owner_id) {
+    reporterId = project.owner_id;
+  } else {
+    const { data: testers } = await supabase.from("testers").select("id").eq("project_id", projectId).limit(1);
+    if (testers && testers.length > 0) reporterId = testers[0].id;
+  }
+  const report = {
+    project_id: projectId,
+    report_type: "bug",
+    title: args.title,
+    description: args.description,
+    severity: args.severity,
+    status: "new",
+    app_context: {
+      currentRoute: args.file_path || "code",
+      source: "claude_code",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    },
+    device_info: {
+      platform: "claude_code",
+      environment: "development"
+    },
+    code_context: codeContext
+  };
+  if (reporterId) report.reporter_id = reporterId;
+  const { data, error } = await supabase.from("reports").insert(report).select("id").single();
+  if (error) return { error: error.message };
+  return {
+    success: true,
+    report_id: data.id,
+    message: `Bug report created: ${args.title}`,
+    details: { id: data.id, severity: args.severity, file: args.file_path, line: args.line_number }
+  };
+}
+async function getBugsForFile(supabase, projectId, args) {
+  const normalizedPath = args.file_path.replace(/^\.\//, "").replace(/^\//, "");
+  let query = supabase.from("reports").select("id, title, description, severity, status, created_at, code_context").eq("project_id", projectId).eq("report_type", "bug");
+  if (!args.include_resolved) {
+    query = query.in("status", ["new", "confirmed", "in_progress", "reviewed"]);
+  }
+  const { data, error } = await query.order("created_at", { ascending: false });
+  if (error) return { error: error.message };
+  const matchingBugs = (data || []).filter((bug) => {
+    const codeContext = bug.code_context;
+    if (!codeContext) return false;
+    const bugFilePath = codeContext.file_path;
+    if (!bugFilePath) return false;
+    const normalizedBugPath = bugFilePath.replace(/^\.\//, "").replace(/^\//, "");
+    return normalizedBugPath.includes(normalizedPath) || normalizedPath.includes(normalizedBugPath);
+  });
+  const relatedBugs = (data || []).filter((bug) => {
+    if (matchingBugs.includes(bug)) return false;
+    const codeContext = bug.code_context;
+    const relatedFiles = codeContext?.related_files;
+    if (!relatedFiles) return false;
+    return relatedFiles.some((f) => f.includes(normalizedPath) || normalizedPath.includes(f));
+  });
+  return {
+    file: args.file_path,
+    direct_bugs: matchingBugs.map((b) => ({
+      id: b.id,
+      title: b.title,
+      severity: b.severity,
+      status: b.status,
+      line: b.code_context?.line_number,
+      description: b.description.slice(0, 200)
+    })),
+    related_bugs: relatedBugs.map((b) => ({
+      id: b.id,
+      title: b.title,
+      severity: b.severity,
+      status: b.status,
+      source_file: b.code_context?.file_path
+    })),
+    summary: {
+      total: matchingBugs.length + relatedBugs.length,
+      critical: matchingBugs.filter((b) => b.severity === "critical").length,
+      open: matchingBugs.filter((b) => ["new", "confirmed", "in_progress"].includes(b.status)).length
+    },
+    recommendation: matchingBugs.length > 0 ? `Found ${matchingBugs.length} bug(s) in this file. Consider fixing them while you're here.` : "No known bugs in this file."
+  };
+}
+async function markFixedWithCommit(supabase, projectId, args) {
+  if (!isValidUUID(args.report_id)) return { error: "Invalid report_id format" };
+  const { data: existing, error: fetchError } = await supabase.from("reports").select("code_context").eq("id", args.report_id).eq("project_id", projectId).single();
+  if (fetchError) return { error: fetchError.message };
+  const existingContext = existing?.code_context || {};
+  const updates = {
+    status: "resolved",
+    resolved_at: (/* @__PURE__ */ new Date()).toISOString(),
+    resolution_notes: args.resolution_notes || `Fixed in commit ${args.commit_sha.slice(0, 7)}`,
+    notify_tester: args.notify_tester === true,
+    code_context: {
+      ...existingContext,
+      fix: {
+        commit_sha: args.commit_sha,
+        commit_message: args.commit_message,
+        files_changed: args.files_changed,
+        fixed_at: (/* @__PURE__ */ new Date()).toISOString(),
+        fixed_by: "claude_code"
+      }
+    }
+  };
+  const { error } = await supabase.from("reports").update(updates).eq("id", args.report_id).eq("project_id", projectId);
+  if (error) return { error: error.message };
+  const notificationStatus = args.notify_tester ? "The original tester will be notified and assigned a verification task." : "No notification sent (silent resolve). A verification task was created.";
+  return {
+    success: true,
+    message: `Bug marked as fixed in commit ${args.commit_sha.slice(0, 7)}. ${notificationStatus}`,
+    report_id: args.report_id,
+    commit: args.commit_sha,
+    tester_notified: args.notify_tester === true,
+    next_steps: [
+      "Consider running create_regression_test to prevent this bug from recurring",
+      "Push your changes to trigger CI/CD"
+    ]
+  };
+}
+async function getBugsAffectingCode(supabase, projectId, args) {
+  const includeRelated = args.include_related !== false;
+  const { data, error } = await supabase.from("reports").select("id, title, description, severity, status, code_context, app_context").eq("project_id", projectId).eq("report_type", "bug").in("status", ["new", "confirmed", "in_progress", "reviewed"]).order("severity", { ascending: true });
+  if (error) return { error: error.message };
+  const normalizedPaths = args.file_paths.map((p) => p.replace(/^\.\//, "").replace(/^\//, ""));
+  const affectedBugs = [];
+  for (const bug of data || []) {
+    const codeContext = bug.code_context;
+    const appContext = bug.app_context;
+    const bugFile = codeContext?.file_path;
+    if (bugFile) {
+      const normalizedBugFile = bugFile.replace(/^\.\//, "").replace(/^\//, "");
+      for (const path of normalizedPaths) {
+        if (normalizedBugFile.includes(path) || path.includes(normalizedBugFile)) {
+          affectedBugs.push({ id: bug.id, title: bug.title, severity: bug.severity, status: bug.status, matched_file: path, match_type: "direct" });
+          break;
+        }
+      }
+    }
+    if (includeRelated && codeContext?.related_files) {
+      const relatedFiles = codeContext.related_files;
+      for (const relatedFile of relatedFiles) {
+        for (const path of normalizedPaths) {
+          if (relatedFile.includes(path) || path.includes(relatedFile)) {
+            if (!affectedBugs.find((b) => b.id === bug.id)) {
+              affectedBugs.push({ id: bug.id, title: bug.title, severity: bug.severity, status: bug.status, matched_file: path, match_type: "related" });
+            }
+            break;
+          }
+        }
+      }
+    }
+    const route = appContext?.currentRoute;
+    if (route && route !== "code") {
+      for (const path of normalizedPaths) {
+        if (path.includes("page") || path.includes("route") || path.includes("component")) {
+          const pathParts = path.split("/");
+          const fileName = pathParts[pathParts.length - 1].replace(/\.(tsx?|jsx?)$/, "");
+          if (route.toLowerCase().includes(fileName.toLowerCase())) {
+            if (!affectedBugs.find((b) => b.id === bug.id)) {
+              affectedBugs.push({ id: bug.id, title: bug.title, severity: bug.severity, status: bug.status, matched_file: path, match_type: "route" });
+            }
+          }
+        }
+      }
+    }
+  }
+  const critical = affectedBugs.filter((b) => b.severity === "critical");
+  return {
+    files_checked: args.file_paths,
+    affected_bugs: affectedBugs,
+    summary: {
+      total: affectedBugs.length,
+      critical: critical.length,
+      high: affectedBugs.filter((b) => b.severity === "high").length,
+      direct_matches: affectedBugs.filter((b) => b.match_type === "direct").length
+    },
+    warnings: critical.length > 0 ? [`${critical.length} CRITICAL bug(s) may be affected by your changes!`] : [],
+    recommendation: affectedBugs.length > 0 ? `Review ${affectedBugs.length} potentially affected bug(s) before pushing.` : "No known bugs affected by these changes."
+  };
+}
+async function linkBugToCode(supabase, projectId, args) {
+  if (!isValidUUID(args.report_id)) return { error: "Invalid report_id format" };
+  const { data: existing, error: fetchError } = await supabase.from("reports").select("code_context").eq("id", args.report_id).eq("project_id", projectId).single();
+  if (fetchError) return { error: fetchError.message };
+  const existingContext = existing?.code_context || {};
+  const { error } = await supabase.from("reports").update({
+    code_context: {
+      ...existingContext,
+      file_path: args.file_path,
+      line_number: args.line_number,
+      code_snippet: args.code_snippet,
+      function_name: args.function_name || extractFunctionName(args.code_snippet),
+      linked_at: (/* @__PURE__ */ new Date()).toISOString(),
+      linked_by: "claude_code"
+    }
+  }).eq("id", args.report_id).eq("project_id", projectId);
+  if (error) return { error: error.message };
+  return {
+    success: true,
+    message: `Bug linked to ${args.file_path}${args.line_number ? `:${args.line_number}` : ""}`,
+    report_id: args.report_id
+  };
+}
+async function createRegressionTest(supabase, projectId, args) {
+  if (!isValidUUID(args.report_id)) return { error: "Invalid report_id format" };
+  const { data: report, error: fetchError } = await supabase.from("reports").select("*").eq("id", args.report_id).eq("project_id", projectId).single();
+  if (fetchError) return { error: fetchError.message };
+  if (report.status !== "resolved") {
+    return { error: "Bug must be resolved before creating a regression test", current_status: report.status };
+  }
+  const codeContext = report.code_context;
+  const testType = args.test_type || "integration";
+  const { data: existingTests } = await supabase.from("test_cases").select("test_key").eq("project_id", projectId).order("test_key", { ascending: false }).limit(1);
+  const lastKey = existingTests?.[0]?.test_key || "TC-000";
+  const lastNum = parseInt(lastKey.replace("TC-", "")) || 0;
+  const newKey = `TC-${String(lastNum + 1).padStart(3, "0")}`;
+  const appContext = report.app_context;
+  const targetRoute = appContext?.currentRoute;
+  const testCase = {
+    project_id: projectId,
+    test_key: newKey,
+    title: `Regression: ${report.title}`,
+    description: `Regression test to prevent recurrence of bug #${args.report_id.slice(0, 8)}
+
+Original bug: ${report.description}`,
+    priority: report.severity === "critical" ? "P0" : report.severity === "high" ? "P1" : "P2",
+    steps: [
+      {
+        stepNumber: 1,
+        action: codeContext?.file_path ? `Navigate to the code/feature in ${codeContext.file_path}` : "Navigate to the affected feature",
+        expectedResult: "Feature loads correctly"
+      },
+      { stepNumber: 2, action: "Reproduce the original bug scenario", expectedResult: "The bug should NOT occur" },
+      { stepNumber: 3, action: "Verify the fix is working", expectedResult: report.resolution_notes || "Feature works as expected" }
+    ],
+    expected_result: `The bug "${report.title}" should not recur`,
+    preconditions: codeContext?.fix ? `Requires commit ${codeContext.fix.commit_sha?.slice(0, 7) || "unknown"} or later` : "",
+    target_route: targetRoute,
+    metadata: {
+      source: "regression_from_bug",
+      original_bug_id: args.report_id,
+      test_type: testType,
+      created_by: "claude_code"
+    }
+  };
+  const { data, error } = await supabase.from("test_cases").insert(testCase).select("id, test_key, title").single();
+  if (error) return { error: error.message };
+  return {
+    success: true,
+    test_case: { id: data.id, test_key: data.test_key, title: data.title, type: testType },
+    message: `Regression test ${data.test_key} created from bug report`,
+    original_bug: { id: args.report_id, title: report.title }
+  };
+}
+
+// src/fixes.ts
+async function getPendingFixes(supabase, projectId, args) {
+  const limit = args.limit || 10;
+  let query = supabase.from("fix_requests").select(`
+      id, title, description, prompt, file_path, status, claimed_at, claimed_by, created_at,
+      report:reports(id, title, severity, description)
+    `).eq("project_id", projectId).order("created_at", { ascending: true }).limit(limit);
+  if (!args.include_claimed) {
+    query = query.eq("status", "pending");
+  } else {
+    query = query.in("status", ["pending", "claimed"]);
+  }
+  const { data, error } = await query;
+  if (error) return { error: error.message };
+  if (!data || data.length === 0) {
+    return {
+      fix_requests: [],
+      count: 0,
+      message: "No pending fix requests in the queue. Great job keeping up!"
+    };
+  }
+  return {
+    fix_requests: data.map((fr) => ({
+      id: fr.id,
+      title: fr.title,
+      description: fr.description,
+      prompt: fr.prompt,
+      file_path: fr.file_path,
+      status: fr.status,
+      claimed_by: fr.claimed_by,
+      claimed_at: fr.claimed_at,
+      created_at: fr.created_at,
+      related_report: fr.report ? {
+        id: fr.report.id,
+        title: fr.report.title,
+        severity: fr.report.severity
+      } : null
+    })),
+    count: data.length,
+    message: `Found ${data.length} fix request(s) waiting. Use claim_fix_request to start working on one.`
+  };
+}
+async function claimFixRequest(supabase, projectId, args) {
+  if (!isValidUUID(args.fix_request_id)) return { error: "Invalid fix_request_id format" };
+  const { data: existing, error: checkError } = await supabase.from("fix_requests").select("id, status, claimed_by, prompt, title").eq("id", args.fix_request_id).eq("project_id", projectId).single();
+  if (checkError) return { error: checkError.message };
+  if (existing.status === "claimed") {
+    return { error: `This fix request is already claimed by ${existing.claimed_by || "another instance"}`, status: existing.status };
+  }
+  if (existing.status === "completed") {
+    return { error: "This fix request has already been completed", status: existing.status };
+  }
+  const claimedBy = args.claimed_by || `claude-code-${Date.now()}`;
+  const { error: updateError } = await supabase.from("fix_requests").update({
+    status: "claimed",
+    claimed_at: (/* @__PURE__ */ new Date()).toISOString(),
+    claimed_by: claimedBy
+  }).eq("id", args.fix_request_id).eq("project_id", projectId).eq("status", "pending");
+  if (updateError) return { error: updateError.message };
+  return {
+    success: true,
+    message: `Fix request claimed successfully. Here's your task:`,
+    fix_request: { id: args.fix_request_id, title: existing.title, prompt: existing.prompt },
+    next_steps: [
+      "1. Read and understand the prompt below",
+      "2. Implement the fix",
+      "3. Test your changes",
+      "4. Use complete_fix_request when done"
+    ]
+  };
+}
+async function completeFixRequest(supabase, projectId, args) {
+  if (!isValidUUID(args.fix_request_id)) return { error: "Invalid fix_request_id format" };
+  const isSuccess = args.success !== false;
+  const updates = {
+    status: isSuccess ? "completed" : "cancelled",
+    completed_at: (/* @__PURE__ */ new Date()).toISOString(),
+    completion_notes: args.completion_notes || (isSuccess ? "Fix completed" : "Could not complete fix")
+  };
+  const { error } = await supabase.from("fix_requests").update(updates).eq("id", args.fix_request_id).eq("project_id", projectId);
+  if (error) return { error: error.message };
+  return {
+    success: true,
+    message: isSuccess ? "Fix request marked as completed!" : "Fix request marked as cancelled.",
+    fix_request_id: args.fix_request_id,
+    status: updates.status
+  };
+}
+
+// src/team.ts
+async function listTesters(supabase, projectId, args) {
+  let query = supabase.from("testers").select("id, name, email, status, platforms, tier, assigned_count, completed_count, notes, created_at").eq("project_id", projectId).order("name", { ascending: true });
+  if (args.status) query = query.eq("status", args.status);
+  const { data, error } = await query;
+  if (error) return { error: error.message };
+  let testers = data || [];
+  if (args.platform) {
+    testers = testers.filter((t) => t.platforms && t.platforms.includes(args.platform));
+  }
+  return {
+    count: testers.length,
+    testers: testers.map((t) => ({
+      id: t.id,
+      name: t.name,
+      email: t.email,
+      status: t.status,
+      platforms: t.platforms,
+      tier: t.tier,
+      assignedCount: t.assigned_count,
+      completedCount: t.completed_count,
+      notes: t.notes
+    }))
+  };
+}
+async function createTester(supabase, projectId, args) {
+  if (!args.name || args.name.trim().length === 0) return { error: "Tester name is required" };
+  if (!args.email || !args.email.includes("@")) return { error: "A valid email address is required" };
+  if (args.tier !== void 0 && (args.tier < 1 || args.tier > 3)) return { error: "Tier must be 1, 2, or 3" };
+  const validPlatforms = ["ios", "android", "web"];
+  if (args.platforms) {
+    for (const p of args.platforms) {
+      if (!validPlatforms.includes(p)) {
+        return { error: `Invalid platform "${p}". Must be one of: ${validPlatforms.join(", ")}` };
+      }
+    }
+  }
+  const { data, error } = await supabase.from("testers").insert({
+    project_id: projectId,
+    name: args.name.trim(),
+    email: args.email.trim().toLowerCase(),
+    platforms: args.platforms || ["ios", "web"],
+    tier: args.tier ?? 1,
+    notes: args.notes?.trim() || null,
+    status: "active"
+  }).select("id, name, email, status, platforms, tier, notes, created_at").single();
+  if (error) {
+    if (error.message.includes("duplicate") || error.message.includes("unique")) {
+      return { error: `A tester with email "${args.email}" already exists in this project` };
+    }
+    return { error: error.message };
+  }
+  return {
+    success: true,
+    tester: {
+      id: data.id,
+      name: data.name,
+      email: data.email,
+      status: data.status,
+      platforms: data.platforms,
+      tier: data.tier,
+      notes: data.notes,
+      createdAt: data.created_at
+    },
+    message: `Tester "${data.name}" added to the project. Use assign_tests to give them test cases.`
+  };
+}
+async function updateTester(supabase, projectId, args) {
+  if (!isValidUUID(args.tester_id)) return { error: "Invalid tester_id format" };
+  const updates = {};
+  if (args.status) updates.status = args.status;
+  if (args.platforms) updates.platforms = args.platforms;
+  if (args.tier !== void 0) {
+    if (args.tier < 1 || args.tier > 3) return { error: "Tier must be 1, 2, or 3" };
+    updates.tier = args.tier;
+  }
+  if (args.notes !== void 0) updates.notes = args.notes.trim() || null;
+  if (args.name) updates.name = args.name.trim();
+  if (Object.keys(updates).length === 0) {
+    return { error: "No fields to update. Provide at least one of: status, platforms, tier, notes, name" };
+  }
+  const { data, error } = await supabase.from("testers").update(updates).eq("id", args.tester_id).eq("project_id", projectId).select("id, name, email, status, platforms, tier, notes").single();
+  if (error) return { error: error.message };
+  if (!data) return { error: "Tester not found in this project" };
+  return {
+    success: true,
+    tester: {
+      id: data.id,
+      name: data.name,
+      email: data.email,
+      status: data.status,
+      platforms: data.platforms,
+      tier: data.tier,
+      notes: data.notes
+    },
+    updatedFields: Object.keys(updates)
+  };
+}
+async function getTesterWorkload(supabase, projectId, args) {
+  if (!isValidUUID(args.tester_id)) return { error: "Invalid tester_id format" };
+  const { data: tester, error: testerErr } = await supabase.from("testers").select("id, name, email, status, platforms, tier").eq("id", args.tester_id).eq("project_id", projectId).single();
+  if (testerErr || !tester) return { error: "Tester not found in this project" };
+  const { data: assignments, error: assignErr } = await supabase.from("test_assignments").select(`
+      id, status, assigned_at, completed_at,
+      test_case:test_cases(test_key, title, priority),
+      test_run:test_runs(name)
+    `).eq("project_id", projectId).eq("tester_id", args.tester_id).order("assigned_at", { ascending: false });
+  if (assignErr) return { error: assignErr.message };
+  const all = assignments || [];
+  const counts = {
+    pending: 0,
+    in_progress: 0,
+    passed: 0,
+    failed: 0,
+    blocked: 0,
+    skipped: 0
+  };
+  for (const a of all) counts[a.status] = (counts[a.status] || 0) + 1;
+  return {
+    tester: {
+      id: tester.id,
+      name: tester.name,
+      email: tester.email,
+      status: tester.status,
+      platforms: tester.platforms,
+      tier: tester.tier
+    },
+    totalAssignments: all.length,
+    counts,
+    activeLoad: counts.pending + counts.in_progress,
+    recentAssignments: all.slice(0, 10).map((a) => ({
+      id: a.id,
+      status: a.status,
+      assignedAt: a.assigned_at,
+      completedAt: a.completed_at,
+      testCase: a.test_case ? { testKey: a.test_case.test_key, title: a.test_case.title, priority: a.test_case.priority } : null,
+      testRun: a.test_run?.name || null
+    }))
+  };
+}
+
+// src/analytics.ts
+async function getBugTrends(supabase, projectId, args) {
+  const days = Math.min(args.days || 30, 180);
+  const groupBy = args.group_by || "week";
+  const since = new Date(Date.now() - days * 864e5).toISOString();
+  const { data, error } = await supabase.from("reports").select("id, severity, category, status, report_type, created_at").eq("project_id", projectId).gte("created_at", since).order("created_at", { ascending: true });
+  if (error) return { error: error.message };
+  const reports = data || [];
+  if (groupBy === "week") {
+    const weeks = {};
+    for (const r of reports) {
+      const d = new Date(r.created_at);
+      const day = d.getDay();
+      const diff = d.getDate() - day + (day === 0 ? -6 : 1);
+      const monday = new Date(d.setDate(diff));
+      const weekKey = monday.toISOString().slice(0, 10);
+      if (!weeks[weekKey]) weeks[weekKey] = { count: 0, critical: 0, high: 0, medium: 0, low: 0 };
+      weeks[weekKey].count++;
+      const sev = r.severity || "low";
+      weeks[weekKey][sev]++;
+    }
+    return {
+      period: `${days} days`,
+      groupBy: "week",
+      totalReports: reports.length,
+      weeks: Object.entries(weeks).map(([week, data2]) => ({ week, ...data2 }))
+    };
+  }
+  if (groupBy === "severity") {
+    const groups = { critical: 0, high: 0, medium: 0, low: 0 };
+    for (const r of reports) groups[r.severity || "low"]++;
+    return { period: `${days} days`, groupBy: "severity", totalReports: reports.length, breakdown: groups };
+  }
+  if (groupBy === "category") {
+    const groups = {};
+    for (const r of reports) {
+      const cat = r.category || "uncategorized";
+      groups[cat] = (groups[cat] || 0) + 1;
+    }
+    return { period: `${days} days`, groupBy: "category", totalReports: reports.length, breakdown: groups };
+  }
+  if (groupBy === "status") {
+    const groups = {};
+    for (const r of reports) groups[r.status] = (groups[r.status] || 0) + 1;
+    return { period: `${days} days`, groupBy: "status", totalReports: reports.length, breakdown: groups };
+  }
+  return { error: `Invalid group_by: ${groupBy}. Must be one of: week, severity, category, status` };
+}
+async function getTesterLeaderboard(supabase, projectId, args) {
+  const days = Math.min(args.days || 30, 180);
+  const sortBy = args.sort_by || "tests_completed";
+  const since = new Date(Date.now() - days * 864e5).toISOString();
+  const { data: testers, error: testerErr } = await supabase.from("testers").select("id, name, email, status, platforms, tier").eq("project_id", projectId).eq("status", "active");
+  if (testerErr) return { error: testerErr.message };
+  const { data: assignments, error: assignErr } = await supabase.from("test_assignments").select("tester_id, status, completed_at, duration_seconds").eq("project_id", projectId).gte("completed_at", since).in("status", ["passed", "failed"]);
+  if (assignErr) return { error: assignErr.message };
+  const { data: bugs, error: bugErr } = await supabase.from("reports").select("tester_id, severity").eq("project_id", projectId).gte("created_at", since).not("tester_id", "is", null);
+  if (bugErr) return { error: bugErr.message };
+  const testerMap = /* @__PURE__ */ new Map();
+  for (const t of testers || []) {
+    testerMap.set(t.id, {
+      id: t.id,
+      name: t.name,
+      email: t.email,
+      tier: t.tier,
+      testsCompleted: 0,
+      testsPassed: 0,
+      testsFailed: 0,
+      bugsFound: 0,
+      criticalBugs: 0,
+      avgDurationSeconds: 0,
+      totalDuration: 0
+    });
+  }
+  for (const a of assignments || []) {
+    const entry = testerMap.get(a.tester_id);
+    if (!entry) continue;
+    entry.testsCompleted++;
+    if (a.status === "passed") entry.testsPassed++;
+    if (a.status === "failed") entry.testsFailed++;
+    if (a.duration_seconds) entry.totalDuration += a.duration_seconds;
+  }
+  for (const b of bugs || []) {
+    const entry = testerMap.get(b.tester_id);
+    if (!entry) continue;
+    entry.bugsFound++;
+    if (b.severity === "critical") entry.criticalBugs++;
+  }
+  let leaderboard = Array.from(testerMap.values()).map((t) => ({
+    ...t,
+    passRate: t.testsCompleted > 0 ? Math.round(t.testsPassed / t.testsCompleted * 100) : 0,
+    avgDurationSeconds: t.testsCompleted > 0 ? Math.round(t.totalDuration / t.testsCompleted) : 0,
+    totalDuration: void 0
+  }));
+  if (sortBy === "bugs_found") leaderboard.sort((a, b) => b.bugsFound - a.bugsFound);
+  else if (sortBy === "pass_rate") leaderboard.sort((a, b) => b.passRate - a.passRate);
+  else leaderboard.sort((a, b) => b.testsCompleted - a.testsCompleted);
+  return { period: `${days} days`, sortedBy: sortBy, leaderboard };
+}
+async function exportTestResults(supabase, projectId, args) {
+  if (!isValidUUID(args.test_run_id)) return { error: "Invalid test_run_id format" };
+  const { data: run, error: runErr } = await supabase.from("test_runs").select("id, name, description, status, total_tests, passed_tests, failed_tests, started_at, completed_at, created_at").eq("id", args.test_run_id).eq("project_id", projectId).single();
+  if (runErr || !run) return { error: "Test run not found in this project" };
+  const { data: assignments, error: assignErr } = await supabase.from("test_assignments").select(`
+      id, status, assigned_at, started_at, completed_at, duration_seconds,
+      is_verification, notes, skip_reason, test_result, feedback_rating, feedback_note,
+      test_case:test_cases(id, test_key, title, priority, description, target_route),
+      tester:testers(id, name, email)
+    `).eq("test_run_id", args.test_run_id).eq("project_id", projectId).order("assigned_at", { ascending: true });
+  if (assignErr) return { error: assignErr.message };
+  const all = assignments || [];
+  const passCount = all.filter((a) => a.status === "passed").length;
+  const failCount = all.filter((a) => a.status === "failed").length;
+  return {
+    testRun: {
+      id: run.id,
+      name: run.name,
+      description: run.description,
+      status: run.status,
+      startedAt: run.started_at,
+      completedAt: run.completed_at,
+      createdAt: run.created_at
+    },
+    summary: {
+      totalAssignments: all.length,
+      passed: passCount,
+      failed: failCount,
+      blocked: all.filter((a) => a.status === "blocked").length,
+      skipped: all.filter((a) => a.status === "skipped").length,
+      pending: all.filter((a) => a.status === "pending").length,
+      inProgress: all.filter((a) => a.status === "in_progress").length,
+      passRate: all.length > 0 ? Math.round(passCount / all.length * 100) : 0
+    },
+    assignments: all.map((a) => ({
+      id: a.id,
+      status: a.status,
+      assignedAt: a.assigned_at,
+      startedAt: a.started_at,
+      completedAt: a.completed_at,
+      durationSeconds: a.duration_seconds,
+      isVerification: a.is_verification,
+      notes: a.notes,
+      skipReason: a.skip_reason,
+      testResult: a.test_result,
+      feedbackRating: a.feedback_rating,
+      feedbackNote: a.feedback_note,
+      testCase: a.test_case ? {
+        id: a.test_case.id,
+        testKey: a.test_case.test_key,
+        title: a.test_case.title,
+        priority: a.test_case.priority,
+        description: a.test_case.description,
+        targetRoute: a.test_case.target_route
+      } : null,
+      tester: a.tester ? { id: a.tester.id, name: a.tester.name, email: a.tester.email } : null
+    }))
+  };
+}
+async function getTestingVelocity(supabase, projectId, args) {
+  const days = Math.min(args.days || 14, 90);
+  const since = new Date(Date.now() - days * 864e5).toISOString();
+  const { data, error } = await supabase.from("test_assignments").select("completed_at, status").eq("project_id", projectId).gte("completed_at", since).in("status", ["passed", "failed"]).order("completed_at", { ascending: true });
+  if (error) return { error: error.message };
+  const completions = data || [];
+  const dailyCounts = {};
+  for (let i = 0; i < days; i++) {
+    const d = new Date(Date.now() - (days - 1 - i) * 864e5);
+    dailyCounts[d.toISOString().slice(0, 10)] = 0;
+  }
+  for (const c of completions) {
+    const day = new Date(c.completed_at).toISOString().slice(0, 10);
+    if (dailyCounts[day] !== void 0) dailyCounts[day]++;
+  }
+  const dailyArray = Object.entries(dailyCounts).map(([date, count]) => ({ date, count }));
+  const totalCompleted = completions.length;
+  const avgPerDay = days > 0 ? Math.round(totalCompleted / days * 10) / 10 : 0;
+  const mid = Math.floor(dailyArray.length / 2);
+  const firstHalf = dailyArray.slice(0, mid).reduce((sum, d) => sum + d.count, 0);
+  const secondHalf = dailyArray.slice(mid).reduce((sum, d) => sum + d.count, 0);
+  const trend = secondHalf > firstHalf ? "increasing" : secondHalf < firstHalf ? "decreasing" : "stable";
+  return { period: `${days} days`, totalCompleted, averagePerDay: avgPerDay, trend, daily: dailyArray };
+}
+
+// src/index.ts
+var BugBearAdmin = class {
+  supabase;
+  projectId;
+  constructor(opts) {
+    this.supabase = createClient(opts.supabaseUrl, opts.supabaseKey);
+    this.projectId = opts.projectId;
+  }
+  /** Switch the active project. */
+  setProjectId(projectId) {
+    this.projectId = projectId;
+  }
+  /** Get the current project ID. */
+  getProjectId() {
+    return this.projectId;
+  }
+  // ── Reports ──────────────────────────────────────────
+  listReports(args) {
+    return listReports(this.supabase, this.projectId, args);
+  }
+  getReport(args) {
+    return getReport(this.supabase, this.projectId, args);
+  }
+  searchReports(args) {
+    return searchReports(this.supabase, this.projectId, args);
+  }
+  updateReportStatus(args) {
+    return updateReportStatus(this.supabase, this.projectId, args);
+  }
+  getReportContext(args) {
+    return getReportContext(this.supabase, this.projectId, args);
+  }
+  bulkUpdateReports(args) {
+    return bulkUpdateReports(this.supabase, this.projectId, args);
+  }
+  // ── Project ──────────────────────────────────────────
+  getProjectInfo() {
+    return getProjectInfo(this.supabase, this.projectId);
+  }
+  getQaTracks() {
+    return getQaTracks(this.supabase, this.projectId);
+  }
+  // ── Tests ────────────────────────────────────────────
+  createTestCase(args) {
+    return createTestCase(this.supabase, this.projectId, args);
+  }
+  updateTestCase(args) {
+    return updateTestCase(this.supabase, this.projectId, args);
+  }
+  deleteTestCases(args) {
+    return deleteTestCases(this.supabase, this.projectId, args);
+  }
+  listTestCases(args) {
+    return listTestCases(this.supabase, this.projectId, args);
+  }
+  listTestRuns(args) {
+    return listTestRuns(this.supabase, this.projectId, args);
+  }
+  createTestRun(args) {
+    return createTestRun(this.supabase, this.projectId, args);
+  }
+  listTestAssignments(args) {
+    return listTestAssignments(this.supabase, this.projectId, args);
+  }
+  assignTests(args) {
+    return assignTests(this.supabase, this.projectId, args);
+  }
+  // ── Intelligence ─────────────────────────────────────
+  getBugPatterns(args) {
+    return getBugPatterns(this.supabase, this.projectId, args);
+  }
+  suggestTestCases(args) {
+    return suggestTestCases(this.supabase, this.projectId, args);
+  }
+  getTestPriorities(args) {
+    return getTestPriorities(this.supabase, this.projectId, args);
+  }
+  getCoverageGaps(args) {
+    return getCoverageGaps(this.supabase, this.projectId, args);
+  }
+  getRegressions(args) {
+    return getRegressions(this.supabase, this.projectId, args);
+  }
+  getCoverageMatrix(args) {
+    return getCoverageMatrix(this.supabase, this.projectId, args);
+  }
+  getStaleCoverage(args) {
+    return getStaleCoverage(this.supabase, this.projectId, args);
+  }
+  generateDeployChecklist(args) {
+    return generateDeployChecklist(this.supabase, this.projectId, args);
+  }
+  getQAHealth(args) {
+    return getQAHealth(this.supabase, this.projectId, args);
+  }
+  getQASessions(args) {
+    return getQASessions(this.supabase, this.projectId, args);
+  }
+  getQAAlerts(args) {
+    return getQAAlerts(this.supabase, this.projectId, args);
+  }
+  // ── Deploy & Analysis ────────────────────────────────
+  getDeploymentAnalysis(args) {
+    return getDeploymentAnalysis(this.supabase, this.projectId, args);
+  }
+  getTesterRecommendations(args) {
+    return getTesterRecommendations(this.supabase, this.projectId, args);
+  }
+  analyzeCommitForTesting(args) {
+    return analyzeCommitForTesting(this.supabase, this.projectId, args);
+  }
+  getTestingPatterns(args) {
+    return getTestingPatterns(this.supabase, this.projectId, args);
+  }
+  analyzeChangesForTests(args) {
+    return analyzeChangesForTests(this.supabase, this.projectId, args);
+  }
+  // ── Bug Lifecycle ────────────────────────────────────
+  createBugReport(args) {
+    return createBugReport(this.supabase, this.projectId, args);
+  }
+  getBugsForFile(args) {
+    return getBugsForFile(this.supabase, this.projectId, args);
+  }
+  markFixedWithCommit(args) {
+    return markFixedWithCommit(this.supabase, this.projectId, args);
+  }
+  getBugsAffectingCode(args) {
+    return getBugsAffectingCode(this.supabase, this.projectId, args);
+  }
+  linkBugToCode(args) {
+    return linkBugToCode(this.supabase, this.projectId, args);
+  }
+  createRegressionTest(args) {
+    return createRegressionTest(this.supabase, this.projectId, args);
+  }
+  // ── Fix Queue ────────────────────────────────────────
+  getPendingFixes(args) {
+    return getPendingFixes(this.supabase, this.projectId, args);
+  }
+  claimFixRequest(args) {
+    return claimFixRequest(this.supabase, this.projectId, args);
+  }
+  completeFixRequest(args) {
+    return completeFixRequest(this.supabase, this.projectId, args);
+  }
+  // ── Team ─────────────────────────────────────────────
+  listTesters(args) {
+    return listTesters(this.supabase, this.projectId, args);
+  }
+  createTester(args) {
+    return createTester(this.supabase, this.projectId, args);
+  }
+  updateTester(args) {
+    return updateTester(this.supabase, this.projectId, args);
+  }
+  getTesterWorkload(args) {
+    return getTesterWorkload(this.supabase, this.projectId, args);
+  }
+  // ── Analytics ────────────────────────────────────────
+  getBugTrends(args) {
+    return getBugTrends(this.supabase, this.projectId, args);
+  }
+  getTesterLeaderboard(args) {
+    return getTesterLeaderboard(this.supabase, this.projectId, args);
+  }
+  exportTestResults(args) {
+    return exportTestResults(this.supabase, this.projectId, args);
+  }
+  getTestingVelocity(args) {
+    return getTestingVelocity(this.supabase, this.projectId, args);
+  }
+};
+export {
+  BugBearAdmin,
+  analyzeChangesForTests,
+  analyzeCommitForTesting,
+  analyzeFileTypes,
+  assignTests,
+  bulkUpdateReports,
+  claimFixRequest,
+  completeFixRequest,
+  createBugReport,
+  createRegressionTest,
+  createTestCase,
+  createTestRun,
+  createTester,
+  deleteTestCases,
+  exportTestResults,
+  extractFunctionName,
+  generateDeployChecklist,
+  getBugPatterns,
+  getBugTrends,
+  getBugsAffectingCode,
+  getBugsForFile,
+  getCoverageGaps,
+  getCoverageMatrix,
+  getDeploymentAnalysis,
+  getPendingFixes,
+  getProjectInfo,
+  getQAAlerts,
+  getQAHealth,
+  getQASessions,
+  getQaTracks,
+  getRegressions,
+  getReport,
+  getReportContext,
+  getStaleCoverage,
+  getTestPriorities,
+  getTesterLeaderboard,
+  getTesterRecommendations,
+  getTesterWorkload,
+  getTestingPatterns,
+  getTestingVelocity,
+  getTrackTemplates,
+  isValidUUID,
+  linkBugToCode,
+  listReports,
+  listTestAssignments,
+  listTestCases,
+  listTestRuns,
+  listTesters,
+  markFixedWithCommit,
+  sanitizeSearchQuery,
+  searchReports,
+  suggestTestCases,
+  updateReportStatus,
+  updateTestCase,
+  updateTester
+};