@bbearai/mcp-server 0.5.1 → 0.7.0

package/src/index.ts

@@ -19,32 +19,36 @@ import { createClient, SupabaseClient } from '@supabase/supabase-js';
 // Configuration from environment
 const SUPABASE_URL = process.env.SUPABASE_URL || 'https://kyxgzjnqgvapvlnvqawz.supabase.co';
 const SUPABASE_ANON_KEY = process.env.SUPABASE_ANON_KEY || '';
-const PROJECT_ID = process.env.BUGBEAR_PROJECT_ID || '';
+
+// Active project — set from env var, switchable via switch_project tool
+let currentProjectId = process.env.BUGBEAR_currentProjectId || '';
 
 // Initialize Supabase client
 let supabase: SupabaseClient;
 
 function validateConfig() {
-  const errors: string[] = [];
-
   if (!SUPABASE_ANON_KEY) {
-    errors.push('SUPABASE_ANON_KEY environment variable is required');
+    console.error('BugBear MCP Server: SUPABASE_ANON_KEY environment variable is required');
+    process.exit(1);
   }
 
-  if (!PROJECT_ID) {
-    errors.push('BUGBEAR_PROJECT_ID environment variable is required');
+  // Validate project ID format if provided
+  if (currentProjectId && !/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(currentProjectId)) {
+    console.error('BugBear MCP Server: BUGBEAR_currentProjectId must be a valid UUID');
+    process.exit(1);
   }
 
-  // Basic UUID format validation for project ID
-  if (PROJECT_ID && !/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(PROJECT_ID)) {
-    errors.push('BUGBEAR_PROJECT_ID must be a valid UUID');
+  if (!currentProjectId) {
+    console.error('BugBear MCP Server: No BUGBEAR_currentProjectId set. Use list_projects + switch_project to select one.');
   }
+}
 
-  if (errors.length > 0) {
-    console.error('BugBear MCP Server configuration errors:');
-    errors.forEach(e => console.error(`  - ${e}`));
-    process.exit(1);
+/** Guard for tools that require a project to be selected */
+function requireProject(): string {
+  if (!currentProjectId) {
+    throw new Error('No project selected. Use list_projects to see available projects, then switch_project to select one.');
   }
+  return currentProjectId;
 }
 
 function initSupabase() {
@@ -141,7 +145,7 @@ const tools = [
         },
         status: {
           type: 'string',
-          enum: ['new', 'triaging', 'confirmed', 'in_progress', 'fixed', 'resolved', 'verified', 'wont_fix', 'duplicate'],
+          enum: ['new', 'triaging', 'confirmed', 'in_progress', 'fixed', 'ready_to_test', 'verified', 'resolved', 'reviewed', 'closed', 'wont_fix', 'duplicate'],
           description: 'The new status for the report',
         },
         resolution_notes: {
@@ -154,7 +158,47 @@ const tools = [
   },
   {
     name: 'get_report_context',
-    description: 'Get the full debugging context for a report including console logs, network requests, and navigation history',
+    description: 'Get the full debugging context for a report including console logs, network requests, and navigation history. Use compact=true for app_context summary only (no console/network/navigation).',
+    inputSchema: {
+      type: 'object' as const,
+      properties: {
+        report_id: {
+          type: 'string',
+          description: 'The UUID of the report',
+        },
+        compact: {
+          type: 'boolean',
+          description: 'Compact mode: returns app_context only, skips console logs, network requests, and navigation history. (default: false)',
+        },
+      },
+      required: ['report_id'],
+    },
+  },
+  {
+    name: 'add_report_comment',
+    description: 'Add a comment/note to a bug report thread without changing its status. Use this for follow-up questions, investigation notes, or developer-tester communication.',
+    inputSchema: {
+      type: 'object' as const,
+      properties: {
+        report_id: {
+          type: 'string',
+          description: 'The UUID of the report to comment on',
+        },
+        message: {
+          type: 'string',
+          description: 'The comment/note content',
+        },
+        author: {
+          type: 'string',
+          description: 'Optional author name (defaults to "Claude Code")',
+        },
+      },
+      required: ['report_id', 'message'],
+    },
+  },
+  {
+    name: 'get_report_comments',
+    description: 'Get all comments/notes on a bug report in chronological order. Returns the full discussion thread.',
     inputSchema: {
       type: 'object' as const,
       properties: {
@@ -321,7 +365,7 @@ const tools = [
   },
   {
     name: 'list_test_cases',
-    description: 'List all test cases in the project. Returns test_key, title, target_route, and other metadata. Use this to see existing tests before updating them.',
+    description: 'List all test cases in the project. Returns test_key, title, target_route, and other metadata. Use this to see existing tests before updating them. Use compact=true for id, test_key, title, and priority only (saves tokens).',
     inputSchema: {
       type: 'object' as const,
       properties: {
@@ -346,6 +390,10 @@ const tools = [
           type: 'number',
           description: 'Offset for pagination (default 0)',
         },
+        compact: {
+          type: 'boolean',
+          description: 'Compact mode: returns id, test_key, title, and priority only. (default: false)',
+        },
       },
     },
   },
@@ -454,7 +502,7 @@ const tools = [
         },
         notify_tester: {
           type: 'boolean',
-          description: 'If true, notify the original tester about the fix with a message and verification task. Default: false (silent resolve).',
+          description: 'Notify the original tester about the fix with a message and verification task. Default: true. Set to false for silent resolve.',
         },
       },
       required: ['report_id', 'commit_sha'],
@@ -696,17 +744,17 @@ const tools = [
   },
   {
     name: 'get_coverage_matrix',
-    description: 'Get a comprehensive Route × Track coverage matrix showing test counts, pass rates, and execution data. Use this for a complete view of test coverage.',
+    description: 'Get a comprehensive Route × Track coverage matrix showing test counts, pass rates, and execution data. Use this for a complete view of test coverage. Execution data and bug counts are opt-in to save tokens.',
     inputSchema: {
       type: 'object' as const,
       properties: {
         include_execution_data: {
           type: 'boolean',
-          description: 'Include pass/fail rates and last execution times (default: true)',
+          description: 'Include pass/fail rates and last execution times (default: false). Set true when you need execution history.',
         },
         include_bug_counts: {
           type: 'boolean',
-          description: 'Include open/critical bug counts per route (default: true)',
+          description: 'Include open/critical bug counts per route (default: false). Set true when you need bug context.',
         },
       },
     },
@@ -940,6 +988,11 @@ const tools = [
           enum: ['ios', 'android', 'web'],
           description: 'Filter by platform support',
         },
+        role: {
+          type: 'string',
+          enum: ['tester', 'feedback'],
+          description: 'Filter by role: "tester" for QA testers, "feedback" for feedback-only users (default: all)',
+        },
       },
     },
   },
@@ -1028,6 +1081,21 @@ const tools = [
       required: ['tester_id', 'test_case_ids'],
     },
   },
+  {
+    name: 'unassign_tests',
+    description: 'Remove one or more test assignments by assignment ID. Preserves the test case and its history — only the assignment link is deleted. Use list_test_assignments first to find assignment IDs. Max 50 per call.',
+    inputSchema: {
+      type: 'object' as const,
+      properties: {
+        assignment_ids: {
+          type: 'array',
+          items: { type: 'string' },
+          description: 'Array of test assignment UUIDs to remove (required, max 50)',
+        },
+      },
+      required: ['assignment_ids'],
+    },
+  },
   {
     name: 'get_tester_workload',
     description: 'View a specific tester\'s current workload — assignment counts by status and recent assignments.',
@@ -1042,215 +1110,1208 @@ const tools = [
       required: ['tester_id'],
     },
   },
-];
-
-// Tool handlers
-async function listReports(args: {
-  limit?: number;
-  status?: string;
-  severity?: string;
-  type?: string;
-}) {
-  let query = supabase
-    .from('reports')
-    .select('id, report_type, severity, status, description, app_context, created_at, reporter_name, tester:testers(name)')
-    .eq('project_id', PROJECT_ID)
-    .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 as any)?.currentRoute,
-      reporter: (r.tester as any)?.name || (r as any).reporter_name || 'Anonymous',
-      created_at: r.created_at,
-    })),
-    total: data?.length || 0,
-  };
-}
-
-async function getReport(args: { report_id: string }) {
-  // Validate UUID format to prevent injection
-  if (!args.report_id || !/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(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', PROJECT_ID) // Security: ensure report belongs to this project
-    .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(args: { query?: string; route?: string }) {
-  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', PROJECT_ID)
-    .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 };
-  }
-
-  // Filter by route if provided
-  let results = data || [];
-  if (sanitizedRoute) {
-    results = results.filter(r => {
-      const route = (r.app_context as any)?.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 as any)?.currentRoute,
-      created_at: r.created_at,
-    })),
-    total: results.length,
-  };
-}
-
-async function updateReportStatus(args: {
-  report_id: string;
-  status: string;
-  resolution_notes?: string;
-}) {
-  if (!isValidUUID(args.report_id)) {
-    return { error: 'Invalid report_id format' };
-  }
-
-  const updates: Record<string, unknown> = { 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', PROJECT_ID); // Security: ensure report belongs to this project
-
-  if (error) {
-    return { error: error.message };
-  }
-
-  return { success: true, message: `Report status updated to ${args.status}` };
-}
-
-async function getReportContext(args: { report_id: string }) {
-  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', PROJECT_ID) // Security: ensure report belongs to this project
-    .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 || {},
+  // === NEW TESTER & ANALYTICS TOOLS ===
+  {
+    name: 'create_tester',
+    description: 'Add a new QA tester to the project without opening the dashboard.',
+    inputSchema: {
+      type: 'object' as const,
+      properties: {
+        name: {
+          type: 'string',
+          description: 'Full name of the tester (required)',
+        },
+        email: {
+          type: 'string',
+          description: 'Email address of the tester (required, must be unique per project)',
+        },
+        platforms: {
+          type: 'array',
+          items: { type: 'string', enum: ['ios', 'android', 'web'] },
+          description: 'Platforms the tester can test on (default: ["ios", "web"])',
+        },
+        tier: {
+          type: 'number',
+          description: 'Tester tier 1-3 (default: 1)',
+        },
+        notes: {
+          type: 'string',
+          description: 'Optional notes about the tester',
+        },
+        role: {
+          type: 'string',
+          enum: ['tester', 'feedback'],
+          description: 'Role: "tester" for QA testers (default), "feedback" for feedback-only users',
+        },
+      },
+      required: ['name', 'email'],
     },
-  };
-}
-
-async function getProjectInfo() {
-  // Get project details
-  const { data: project, error: projectError } = await supabase
-    .from('projects')
-    .select('id, name, slug, is_qa_enabled')
-    .eq('id', PROJECT_ID)
-    .single();
-
-  if (projectError) {
-    return { error: projectError.message };
-  }
-
-  // Get track counts
-  const { data: tracks } = await supabase
-    .from('qa_tracks')
-    .select('id, name, icon, test_template')
-    .eq('project_id', PROJECT_ID);
-
-  // Get test case count
-  const { count: testCaseCount } = await supabase
+  },
+  {
+    name: 'update_tester',
+    description: 'Update an existing tester\'s status, platforms, tier, or notes.',
+    inputSchema: {
+      type: 'object' as const,
+      properties: {
+        tester_id: {
+          type: 'string',
+          description: 'UUID of the tester to update (required)',
+        },
+        status: {
+          type: 'string',
+          enum: ['active', 'inactive', 'invited'],
+          description: 'New status for the tester',
+        },
+        platforms: {
+          type: 'array',
+          items: { type: 'string', enum: ['ios', 'android', 'web'] },
+          description: 'Updated platforms array',
+        },
+        tier: {
+          type: 'number',
+          description: 'Updated tier (1-3)',
+        },
+        notes: {
+          type: 'string',
+          description: 'Updated notes',
+        },
+        name: {
+          type: 'string',
+          description: 'Updated name',
+        },
+      },
+      required: ['tester_id'],
+    },
+  },
+  {
+    name: 'bulk_update_reports',
+    description: 'Update the status of multiple bug reports at once. Useful after a fix session to close many bugs.',
+    inputSchema: {
+      type: 'object' as const,
+      properties: {
+        report_ids: {
+          type: 'array',
+          items: { type: 'string' },
+          description: 'Array of report UUIDs to update (required, max 50)',
+        },
+        status: {
+          type: 'string',
+          enum: ['new', 'triaging', 'confirmed', 'in_progress', 'fixed', 'resolved', 'verified', 'wont_fix', 'duplicate', 'closed'],
+          description: 'New status for all reports (required)',
+        },
+        resolution_notes: {
+          type: 'string',
+          description: 'Optional resolution notes applied to all reports',
+        },
+      },
+      required: ['report_ids', 'status'],
+    },
+  },
+  {
+    name: 'get_bug_trends',
+    description: 'Get bug report trends over time — grouped by week, severity, category, or status. Useful for spotting patterns.',
+    inputSchema: {
+      type: 'object' as const,
+      properties: {
+        group_by: {
+          type: 'string',
+          enum: ['week', 'severity', 'category', 'status'],
+          description: 'How to group the trends (default: week)',
+        },
+        days: {
+          type: 'number',
+          description: 'Number of days to look back (default: 30, max: 180)',
+        },
+      },
+    },
+  },
+  {
+    name: 'get_tester_leaderboard',
+    description: 'Rank testers by testing activity — bugs found, tests completed, pass rate, and average test duration.',
+    inputSchema: {
+      type: 'object' as const,
+      properties: {
+        days: {
+          type: 'number',
+          description: 'Number of days to look back (default: 30, max: 180)',
+        },
+        sort_by: {
+          type: 'string',
+          enum: ['bugs_found', 'tests_completed', 'pass_rate'],
+          description: 'Sort metric (default: tests_completed)',
+        },
+      },
+    },
+  },
+  {
+    name: 'export_test_results',
+    description: 'Export test results for a specific test run as structured JSON — includes every assignment, tester, result, and duration. Use compact=true for summary only (no assignments array). Use limit to cap assignments returned.',
+    inputSchema: {
+      type: 'object' as const,
+      properties: {
+        test_run_id: {
+          type: 'string',
+          description: 'UUID of the test run to export (required)',
+        },
+        compact: {
+          type: 'boolean',
+          description: 'Compact mode: returns test run info + summary only, no assignments array. (default: false)',
+        },
+        limit: {
+          type: 'number',
+          description: 'Max assignments to return in full mode (default: 100, max: 500). Ignored when compact=true.',
+        },
+      },
+      required: ['test_run_id'],
+    },
+  },
+  {
+    name: 'get_testing_velocity',
+    description: 'Get a rolling average of test completions per day over the specified window. Shows daily completion counts and trend direction.',
+    inputSchema: {
+      type: 'object' as const,
+      properties: {
+        days: {
+          type: 'number',
+          description: 'Number of days to analyze (default: 14, max: 90)',
+        },
+      },
+    },
+  },
+  // === PROJECT MANAGEMENT TOOLS ===
+  {
+    name: 'list_projects',
+    description: 'List all BugBear projects accessible with the current credentials. Use this to find project IDs for switch_project.',
+    inputSchema: {
+      type: 'object' as const,
+      properties: {},
+    },
+  },
+  {
+    name: 'switch_project',
+    description: 'Switch the active project. All subsequent tool calls will use this project. Use list_projects first to find the project ID.',
+    inputSchema: {
+      type: 'object' as const,
+      properties: {
+        project_id: {
+          type: 'string',
+          description: 'UUID of the project to switch to (required)',
+        },
+      },
+      required: ['project_id'],
+    },
+  },
+  {
+    name: 'get_current_project',
+    description: 'Show which project is currently active.',
+    inputSchema: {
+      type: 'object' as const,
+      properties: {},
+    },
+  },
+  // === TEST EXECUTION INTELLIGENCE ===
+  {
+    name: 'get_test_impact',
+    description: 'Given changed files, identify which test cases are affected by mapping file paths to test case target routes.',
+    inputSchema: {
+      type: 'object' as const,
+      properties: {
+        changed_files: {
+          type: 'array',
+          items: { type: 'string' },
+          description: 'List of changed file paths (relative to project root)',
+        },
+      },
+      required: ['changed_files'],
+    },
+  },
+  {
+    name: 'get_flaky_tests',
+    description: 'Analyze test run history to identify tests with intermittent failure rates above a threshold.',
+    inputSchema: {
+      type: 'object' as const,
+      properties: {
+        threshold: {
+          type: 'number',
+          description: 'Minimum flakiness rate to report (0-100, default: 5)',
+        },
+        limit: {
+          type: 'number',
+          description: 'Maximum results to return (default: 20)',
+        },
+      },
+    },
+  },
+  {
+    name: 'assess_test_quality',
+    description: 'Analyze test case steps for weak patterns: vague assertions, missing edge cases, no negative testing, generic descriptions.',
+    inputSchema: {
+      type: 'object' as const,
+      properties: {
+        test_case_ids: {
+          type: 'array',
+          items: { type: 'string' },
+          description: 'Specific test case IDs to assess. If omitted, assesses recent test cases.',
+        },
+        limit: {
+          type: 'number',
+          description: 'Maximum test cases to assess (default: 20)',
+        },
+      },
+    },
+  },
+  {
+    name: 'get_test_execution_summary',
+    description: 'Aggregate test execution metrics: pass rate, completion rate, most-failed tests, fastest/slowest tests.',
+    inputSchema: {
+      type: 'object' as const,
+      properties: {
+        days: {
+          type: 'number',
+          description: 'Number of days to analyze (default: 30)',
+        },
+      },
+    },
+  },
+  {
+    name: 'check_test_freshness',
+    description: 'Identify test cases that have not been updated since their target code was modified.',
+    inputSchema: {
+      type: 'object' as const,
+      properties: {
+        limit: {
+          type: 'number',
+          description: 'Maximum results to return (default: 20)',
+        },
+      },
+    },
+  },
+  {
+    name: 'get_untested_changes',
+    description: 'Given recent commits or changed files, find code changes with no corresponding test coverage in BugBear.',
+    inputSchema: {
+      type: 'object' as const,
+      properties: {
+        changed_files: {
+          type: 'array',
+          items: { type: 'string' },
+          description: 'List of changed file paths. If omitted, uses git diff against main.',
+        },
+      },
+    },
+  },
+  // === AUTO-MONITORING TOOLS ===
+  {
+    name: 'get_auto_detected_issues',
+    description: 'Get auto-detected monitoring issues grouped by error fingerprint. Shows recurring crashes, API failures, and rage clicks with frequency and user impact.',
+    inputSchema: {
+      type: 'object' as const,
+      properties: {
+        source: {
+          type: 'string',
+          enum: ['auto_crash', 'auto_api', 'auto_rage_click'],
+          description: 'Filter by source type',
+        },
+        min_occurrences: {
+          type: 'number',
+          description: 'Min occurrence count (default: 1)',
+        },
+        since: {
+          type: 'string',
+          description: 'ISO date — only issues after this date (default: 7 days ago)',
+        },
+        limit: {
+          type: 'number',
+          description: 'Max results (default: 20)',
+        },
+        compact: {
+          type: 'boolean',
+          description: 'Compact mode: fingerprint, source, count only',
+        },
+      },
+    },
+  },
+  {
+    name: 'generate_tests_from_errors',
+    description: 'Suggest QA test cases from auto-detected error patterns. Returns structured suggestions — does NOT auto-create test cases.',
+    inputSchema: {
+      type: 'object' as const,
+      properties: {
+        report_ids: {
+          type: 'array',
+          items: { type: 'string' },
+          description: 'Specific report IDs. If omitted, uses top uncovered errors.',
+        },
+        limit: {
+          type: 'number',
+          description: 'Max suggestions (default: 5)',
+        },
+      },
+    },
+  },
+];
+
+// === TEST EXECUTION INTELLIGENCE ===
+
+async function getTestImpact(args: { changed_files: string[] }) {
+  const projectId = requireProject();
+  const changedFiles = args.changed_files || [];
+
+  if (changedFiles.length === 0) {
+    return { affectedTests: [], message: 'No changed files provided.' };
+  }
+
+  // Get all test cases for the project with their target routes
+  const { data: testCases, error } = await supabase
+    .from('test_cases')
+    .select('id, title, target_route, qa_track, priority')
+    .eq('project_id', projectId);
+
+  if (error) return { error: error.message };
+  if (!testCases || testCases.length === 0) {
+    return { affectedTests: [], message: 'No test cases found for this project.' };
+  }
+
+  // Map changed files to affected test cases
+  const affected: Array<{ testId: string; title: string; targetRoute: string; matchedFiles: string[]; qaTrack: string }> = [];
+
+  for (const tc of testCases) {
+    const route = tc.target_route || '';
+    const matchedFiles = changedFiles.filter(f => {
+      // Match file path to route (e.g., src/app/api/tasks/route.ts -> /api/tasks)
+      const normalized = f.replace(/\\/g, '/');
+      const routeParts = route.split('/').filter(Boolean);
+      return routeParts.some((part: string) => normalized.includes(part)) || normalized.includes(route.replace(/\//g, '/'));
+    });
+
+    if (matchedFiles.length > 0) {
+      affected.push({
+        testId: tc.id,
+        title: tc.title,
+        targetRoute: route,
+        matchedFiles,
+        qaTrack: tc.qa_track,
+      });
+    }
+  }
+
+  return {
+    affectedTests: affected,
+    totalTestCases: testCases.length,
+    affectedCount: affected.length,
+    changedFileCount: changedFiles.length,
+  };
+}
+
+async function getFlakyTests(args: { threshold?: number; limit?: number }) {
+  const projectId = requireProject();
+  const threshold = args.threshold || 5;
+  const limit = args.limit || 20;
+
+  // Get test results grouped by test case
+  const { data: results, error } = await supabase
+    .from('test_results')
+    .select('test_case_id, status, test_cases!inner(title, target_route, qa_track)')
+    .eq('test_cases.project_id', projectId)
+    .order('created_at', { ascending: false })
+    .limit(5000);
+
+  if (error) return { error: error.message };
+  if (!results || results.length === 0) {
+    return { flakyTests: [], message: 'No test results found.' };
+  }
+
+  // Group by test case and calculate flakiness
+  const testStats: Record<string, { passes: number; fails: number; total: number; title: string; route: string; track: string }> = {};
+
+  for (const r of results) {
+    const id = r.test_case_id;
+    if (!testStats[id]) {
+      const tc = r.test_cases as any;
+      testStats[id] = { passes: 0, fails: 0, total: 0, title: tc?.title || '', route: tc?.target_route || '', track: tc?.qa_track || '' };
+    }
+    testStats[id].total++;
+    if (r.status === 'pass') testStats[id].passes++;
+    else if (r.status === 'fail') testStats[id].fails++;
+  }
+
+  // Find flaky tests (have both passes and fails, with fail rate above threshold)
+  const flaky = Object.entries(testStats)
+    .filter(([, stats]) => {
+      if (stats.total < 3) return false; // Need enough data
+      const failRate = (stats.fails / stats.total) * 100;
+      const passRate = (stats.passes / stats.total) * 100;
+      return failRate >= threshold && passRate > 0; // Has both passes and fails
+    })
+    .map(([id, stats]) => ({
+      testCaseId: id,
+      title: stats.title,
+      targetRoute: stats.route,
+      qaTrack: stats.track,
+      totalRuns: stats.total,
+      failRate: Math.round((stats.fails / stats.total) * 100),
+      passRate: Math.round((stats.passes / stats.total) * 100),
+    }))
+    .sort((a, b) => b.failRate - a.failRate)
+    .slice(0, limit);
+
+  return {
+    flakyTests: flaky,
+    totalAnalyzed: Object.keys(testStats).length,
+    flakyCount: flaky.length,
+    threshold,
+  };
+}
+
+async function assessTestQuality(args: { test_case_ids?: string[]; limit?: number }) {
+  const projectId = requireProject();
+  const limit = args.limit || 20;
+
+  let query = supabase
+    .from('test_cases')
+    .select('id, title, steps, target_route, qa_track, priority')
+    .eq('project_id', projectId)
+    .limit(limit);
+
+  if (args.test_case_ids && args.test_case_ids.length > 0) {
+    query = query.in('id', args.test_case_ids);
+  }
+
+  const { data: testCases, error } = await query;
+  if (error) return { error: error.message };
+  if (!testCases || testCases.length === 0) {
+    return { assessments: [], message: 'No test cases found.' };
+  }
+
+  const assessments = testCases.map(tc => {
+    const issues: string[] = [];
+    const steps = tc.steps || [];
+
+    // Check for weak patterns
+    if (steps.length < 2) {
+      issues.push('Too few steps — test may not cover the full flow');
+    }
+
+    const allStepsText = steps.map((s: any) => (typeof s === 'string' ? s : s.action || s.description || '')).join(' ');
+
+    // Vague assertions
+    if (/should work|looks good|is correct|verify it works/i.test(allStepsText)) {
+      issues.push('Vague assertions detected — use specific expected outcomes');
+    }
+
+    // Missing edge cases
+    if (!/error|invalid|empty|missing|unauthorized|forbidden|404|500/i.test(allStepsText)) {
+      issues.push('No negative/error test cases — add edge case testing');
+    }
+
+    // Generic descriptions
+    if (/test the|check the|verify the/i.test(tc.title) && tc.title.length < 30) {
+      issues.push('Generic test title — be more specific about what is being tested');
+    }
+
+    // No specific UI elements referenced
+    if (!/button|input|form|modal|dropdown|select|click|type|enter|submit/i.test(allStepsText)) {
+      issues.push('No specific UI elements referenced — steps may be too abstract');
+    }
+
+    const quality = issues.length === 0 ? 'good' : issues.length <= 2 ? 'needs-improvement' : 'poor';
+
+    return {
+      testCaseId: tc.id,
+      title: tc.title,
+      targetRoute: tc.target_route,
+      stepCount: steps.length,
+      quality,
+      issues,
+    };
+  });
+
+  const qualityCounts = {
+    good: assessments.filter(a => a.quality === 'good').length,
+    needsImprovement: assessments.filter(a => a.quality === 'needs-improvement').length,
+    poor: assessments.filter(a => a.quality === 'poor').length,
+  };
+
+  return {
+    assessments,
+    summary: qualityCounts,
+    totalAssessed: assessments.length,
+  };
+}
+
+async function getTestExecutionSummary(args: { days?: number }) {
+  const projectId = requireProject();
+  const days = args.days || 30;
+  const since = new Date(Date.now() - days * 24 * 60 * 60 * 1000).toISOString();
+
+  // Get test results
+  const { data: results, error } = await supabase
+    .from('test_results')
+    .select('test_case_id, status, duration_ms, created_at, test_cases!inner(title, target_route)')
+    .eq('test_cases.project_id', projectId)
+    .gte('created_at', since)
+    .order('created_at', { ascending: false });
+
+  if (error) return { error: error.message };
+  if (!results || results.length === 0) {
+    return { message: `No test results found in the last ${days} days.` };
+  }
+
+  const totalRuns = results.length;
+  const passed = results.filter(r => r.status === 'pass').length;
+  const failed = results.filter(r => r.status === 'fail').length;
+  const blocked = results.filter(r => r.status === 'blocked').length;
+
+  // Most failed tests
+  const failCounts: Record<string, { count: number; title: string; route: string }> = {};
+  for (const r of results.filter(r => r.status === 'fail')) {
+    const id = r.test_case_id;
+    const tc = r.test_cases as any;
+    if (!failCounts[id]) {
+      failCounts[id] = { count: 0, title: tc?.title || '', route: tc?.target_route || '' };
+    }
+    failCounts[id].count++;
+  }
+  const mostFailed = Object.entries(failCounts)
+    .sort((a, b) => b[1].count - a[1].count)
+    .slice(0, 5)
+    .map(([id, data]) => ({ testCaseId: id, ...data }));
+
+  // Duration stats
+  const durations = results.filter(r => r.duration_ms).map(r => r.duration_ms as number);
+  const avgDuration = durations.length > 0 ? Math.round(durations.reduce((a, b) => a + b, 0) / durations.length) : 0;
+  const maxDuration = durations.length > 0 ? Math.max(...durations) : 0;
+
+  return {
+    period: `${days} days`,
+    totalRuns,
+    passRate: Math.round((passed / totalRuns) * 100),
+    failRate: Math.round((failed / totalRuns) * 100),
+    blockedCount: blocked,
+    averageDurationMs: avgDuration,
+    maxDurationMs: maxDuration,
+    mostFailed,
+    uniqueTestsCovered: new Set(results.map(r => r.test_case_id)).size,
+  };
+}
+
+async function checkTestFreshness(args: { limit?: number }) {
+  const projectId = requireProject();
+  const limit = args.limit || 20;
+
+  // Get test cases with their last update and last result
+  const { data: testCases, error } = await supabase
+    .from('test_cases')
+    .select('id, title, target_route, updated_at, created_at')
+    .eq('project_id', projectId)
+    .order('updated_at', { ascending: true })
+    .limit(limit);
+
+  if (error) return { error: error.message };
+  if (!testCases || testCases.length === 0) {
+    return { staleTests: [], message: 'No test cases found.' };
+  }
+
+  const thirtyDaysAgo = new Date(Date.now() - 30 * 24 * 60 * 60 * 1000).toISOString();
+
+  const stale = testCases
+    .filter(tc => tc.updated_at < thirtyDaysAgo)
+    .map(tc => ({
+      testCaseId: tc.id,
+      title: tc.title,
+      targetRoute: tc.target_route,
+      lastUpdated: tc.updated_at,
+      daysSinceUpdate: Math.round((Date.now() - new Date(tc.updated_at).getTime()) / (24 * 60 * 60 * 1000)),
+    }));
+
+  return {
+    staleTests: stale,
+    totalTestCases: testCases.length,
+    staleCount: stale.length,
+    stalenessThreshold: '30 days',
+  };
+}
+
+async function getUntestedChanges(args: { changed_files?: string[] }) {
+  const projectId = requireProject();
+
+  // Get all test cases to understand what's covered
+  const { data: testCases, error } = await supabase
+    .from('test_cases')
+    .select('id, title, target_route')
+    .eq('project_id', projectId);
+
+  if (error) return { error: error.message };
+
+  const coveredRoutes = new Set((testCases || []).map(tc => tc.target_route).filter(Boolean));
+
+  // If changed_files provided, check coverage
+  const changedFiles = args.changed_files || [];
+
+  if (changedFiles.length === 0) {
+    return {
+      message: 'No changed files provided. Pass changed_files to check coverage.',
+      totalCoveredRoutes: coveredRoutes.size,
+    };
+  }
+
+  // Map changed files to routes and check coverage
+  const untested: Array<{ file: string; inferredRoute: string; reason: string }> = [];
+
+  for (const file of changedFiles) {
+    const normalized = file.replace(/\\/g, '/');
+
+    // Extract route-like path from file
+    let inferredRoute = '';
+
+    // Next.js app router: app/api/tasks/route.ts -> /api/tasks
+    const appRouterMatch = normalized.match(/app\/(api\/[^/]+(?:\/[^/]+)*?)\/route\.\w+$/);
+    if (appRouterMatch) {
+      inferredRoute = '/' + appRouterMatch[1];
+    }
+
+    // Pages router: pages/api/tasks.ts -> /api/tasks
+    const pagesMatch = normalized.match(/pages\/(api\/[^.]+)\.\w+$/);
+    if (!inferredRoute && pagesMatch) {
+      inferredRoute = '/' + pagesMatch[1];
+    }
+
+    // Component files
+    const componentMatch = normalized.match(/(?:components|screens|pages)\/([^.]+)\.\w+$/);
+    if (!inferredRoute && componentMatch) {
+      inferredRoute = '/' + componentMatch[1].replace(/\\/g, '/');
+    }
+
+    if (inferredRoute && !coveredRoutes.has(inferredRoute)) {
+      untested.push({
+        file,
+        inferredRoute,
+        reason: 'No test cases cover this route',
+      });
+    } else if (!inferredRoute) {
+      // Can't map to a route — flag as potentially untested
+      untested.push({
+        file,
+        inferredRoute: 'unknown',
+        reason: 'Could not map file to a testable route',
+      });
+    }
+  }
+
+  return {
+    untestedChanges: untested,
+    changedFileCount: changedFiles.length,
+    untestedCount: untested.length,
+    coveredRoutes: coveredRoutes.size,
+  };
+}
+
+// === AUTO-MONITORING HANDLERS ===
+
+async function getAutoDetectedIssues(args: {
+  source?: string;
+  min_occurrences?: number;
+  since?: string;
+  limit?: number;
+  compact?: boolean;
+}) {
+  const projectId = requireProject();
+  const since = args.since || new Date(Date.now() - 7 * 24 * 60 * 60 * 1000).toISOString();
+  const limit = args.limit || 20;
+
+  let query = supabase
+    .from('reports')
+    .select('id, error_fingerprint, report_source, title, severity, reporter_id, sentry_event_id, created_at, app_context')
+    .eq('project_id', projectId)
+    .neq('report_source', 'manual')
+    .not('error_fingerprint', 'is', null)
+    .gte('created_at', since)
+    .order('created_at', { ascending: false });
+
+  if (args.source) {
+    query = query.eq('report_source', args.source);
+  }
+
+  const { data, error } = await query;
+  if (error) return { error: error.message };
+  if (!data || data.length === 0) return { issues: [], total: 0 };
+
+  // Group by fingerprint
+  const grouped = new Map<string, typeof data>();
+  for (const report of data) {
+    const fp = report.error_fingerprint!;
+    if (!grouped.has(fp)) grouped.set(fp, []);
+    grouped.get(fp)!.push(report);
+  }
+
+  // Build issue summaries
+  const issues = Array.from(grouped.entries())
+    .map(([fingerprint, reports]) => {
+      const uniqueReporters = new Set(reports.map(r => r.reporter_id));
+      const sorted = reports.sort((a, b) => new Date(a.created_at).getTime() - new Date(b.created_at).getTime());
+      const first = sorted[0];
+      const last = sorted[sorted.length - 1];
+      const route = (first.app_context as any)?.currentRoute || 'unknown';
+
+      return {
+        fingerprint,
+        source: first.report_source,
+        message: first.title,
+        route,
+        occurrence_count: reports.length,
+        affected_users: uniqueReporters.size,
+        first_seen: first.created_at,
+        last_seen: last.created_at,
+        severity: first.severity,
+        has_sentry_link: reports.some(r => r.sentry_event_id != null),
+        sample_report_id: first.id,
+      };
+    })
+    .filter(issue => issue.occurrence_count >= (args.min_occurrences || 1))
+    .sort((a, b) => b.occurrence_count - a.occurrence_count)
+    .slice(0, limit);
+
+  if (args.compact) {
+    return {
+      issues: issues.map(i => ({
+        fingerprint: i.fingerprint,
+        source: i.source,
+        count: i.occurrence_count,
+        users: i.affected_users,
+        severity: i.severity,
+      })),
+      total: issues.length,
+    };
+  }
+
+  return { issues, total: issues.length };
+}
+
+async function generateTestsFromErrors(args: {
+  report_ids?: string[];
+  limit?: number;
+}) {
+  const projectId = requireProject();
+  const limit = args.limit || 5;
+
+  let reports;
+  if (args.report_ids?.length) {
+    // Validate all UUIDs
+    for (const id of args.report_ids) {
+      if (!isValidUUID(id)) {
+        return { error: `Invalid report_id format: ${id}` };
+      }
+    }
+
+    const { data, error } = await supabase
+      .from('reports')
+      .select('id, title, report_source, severity, app_context, error_fingerprint, description')
+      .eq('project_id', projectId)
+      .in('id', args.report_ids);
+    if (error) return { error: error.message };
+    reports = data;
+  } else {
+    // Get top uncovered auto-detected errors
+    const { data, error } = await supabase
+      .from('reports')
+      .select('id, title, report_source, severity, app_context, error_fingerprint, description')
+      .eq('project_id', projectId)
+      .neq('report_source', 'manual')
+      .not('error_fingerprint', 'is', null)
+      .order('created_at', { ascending: false })
+      .limit(50);
+    if (error) return { error: error.message };
+
+    // Deduplicate by fingerprint, keep first occurrence
+    const seen = new Set<string>();
+    reports = (data || []).filter(r => {
+      if (!r.error_fingerprint || seen.has(r.error_fingerprint)) return false;
+      seen.add(r.error_fingerprint);
+      return true;
+    }).slice(0, limit);
+  }
+
+  if (!reports?.length) return { suggestions: [] };
+
+  const suggestions = reports.map(report => {
+    const route = (report.app_context as any)?.currentRoute || '/unknown';
+    const source = report.report_source;
+    const priority = report.severity === 'critical' ? 'P1' : report.severity === 'high' ? 'P1' : 'P2';
+
+    let suggestedSteps: string[];
+    if (source === 'auto_crash') {
+      suggestedSteps = [
+        `Navigate to ${route}`,
+        'Reproduce the action that triggered the crash',
+        'Verify the page does not throw an unhandled error',
+        'Verify error boundary displays a user-friendly message if error occurs',
+      ];
+    } else if (source === 'auto_api') {
+      const statusCode = (report.app_context as any)?.custom?.statusCode || 'error';
+      const method = (report.app_context as any)?.custom?.requestMethod || 'API';
+      suggestedSteps = [
+        `Navigate to ${route}`,
+        `Trigger the ${method} request that returned ${statusCode}`,
+        'Verify the request succeeds or displays an appropriate error message',
+        'Verify no data corruption occurs on failure',
+      ];
+    } else {
+      // rage_click or sentry_sync
+      const target = (report.app_context as any)?.custom?.targetSelector || 'the element';
+      suggestedSteps = [
+        `Navigate to ${route}`,
+        `Click on ${target}`,
+        'Verify the element responds to interaction',
+        'Verify loading state is shown if action takes time',
+      ];
+    }
+
+    return {
+      title: `Test: ${report.title?.replace('[Auto] ', '') || 'Auto-detected issue'}`,
+      track: source === 'auto_crash' ? 'Stability' : source === 'auto_api' ? 'API' : 'UX',
+      priority,
+      rationale: `Auto-detected ${source?.replace('auto_', '')} on ${route}`,
+      suggested_steps: suggestedSteps,
+      source_report_id: report.id,
+      route,
+    };
+  });
+
+  return { suggestions };
+}
+
+// === Project management handlers ===
+
+async function listProjects() {
+  const { data, error } = await supabase
+    .from('projects')
+    .select('id, name, slug, is_qa_enabled, created_at')
+    .order('name');
+
+  if (error) {
+    return { error: error.message };
+  }
+
+  return {
+    currentProjectId: currentProjectId || null,
+    projects: data?.map(p => ({
+      id: p.id,
+      name: p.name,
+      slug: p.slug,
+      isQAEnabled: p.is_qa_enabled,
+      isActive: p.id === currentProjectId,
+      createdAt: p.created_at,
+    })) || [],
+  };
+}
+
+async function switchProject(args: { project_id: string }) {
+  if (!isValidUUID(args.project_id)) {
+    return { error: 'Invalid project_id format — must be a UUID' };
+  }
+
+  // Verify the project exists and is accessible
+  const { data, error } = await supabase
+    .from('projects')
+    .select('id, name, slug')
+    .eq('id', args.project_id)
+    .single();
+
+  if (error || !data) {
+    return { error: 'Project not found or not accessible' };
+  }
+
+  currentProjectId = data.id;
+
+  return {
+    success: true,
+    message: `Switched to project "${data.name}" (${data.slug})`,
+    projectId: data.id,
+    projectName: data.name,
+  };
+}
+
+function getCurrentProject() {
+  if (!currentProjectId) {
+    return { message: 'No project selected. Use list_projects to see available projects, then switch_project to select one.' };
+  }
+  return { projectId: currentProjectId };
+}
+
+// Tool handlers
+async function listReports(args: {
+  limit?: number;
+  status?: string;
+  severity?: string;
+  type?: string;
+}) {
+  let query = supabase
+    .from('reports')
+    .select('id, report_type, severity, status, description, app_context, created_at, reporter_name, tester:testers(name)')
+    .eq('project_id', currentProjectId)
+    .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 as any)?.currentRoute,
+      reporter: (r.tester as any)?.name || (r as any).reporter_name || 'Anonymous',
+      created_at: r.created_at,
+    })),
+    total: data?.length || 0,
+  };
+}
+
+async function getReport(args: { report_id: string }) {
+  // Validate UUID format to prevent injection
+  if (!args.report_id || !/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(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', currentProjectId) // Security: ensure report belongs to this project
+    .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,
+      screenshot_urls: data.screenshot_urls,
+      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(args: { query?: string; route?: string }) {
+  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', currentProjectId)
+    .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 };
+  }
+
+  // Filter by route if provided
+  let results = data || [];
+  if (sanitizedRoute) {
+    results = results.filter(r => {
+      const route = (r.app_context as any)?.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 as any)?.currentRoute,
+      created_at: r.created_at,
+    })),
+    total: results.length,
+  };
+}
+
+async function updateReportStatus(args: {
+  report_id: string;
+  status: string;
+  resolution_notes?: string;
+}) {
+  if (!isValidUUID(args.report_id)) {
+    return { error: 'Invalid report_id format' };
+  }
+
+  const updates: Record<string, unknown> = { 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', currentProjectId); // Security: ensure report belongs to this project
+
+  if (error) {
+    return { error: error.message };
+  }
+
+  return { success: true, message: `Report status updated to ${args.status}` };
+}
+
+async function getReportContext(args: { report_id: string; compact?: boolean }) {
+  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, screenshot_urls')
+    .eq('id', args.report_id)
+    .eq('project_id', currentProjectId) // Security: ensure report belongs to this project
+    .single();
+
+  if (error) {
+    return { error: error.message };
+  }
+
+  // Compact: return app_context only (skip console/network/navigation)
+  if (args.compact === true) {
+    return {
+      context: {
+        app_context: data.app_context,
+        screenshot_urls: data.screenshot_urls,
+      },
+    };
+  }
+
+  return {
+    context: {
+      app_context: data.app_context,
+      device_info: data.device_info,
+      navigation_history: data.navigation_history,
+      enhanced_context: data.enhanced_context || {},
+      screenshot_urls: data.screenshot_urls,
+    },
+  };
+}
+
+async function addReportComment(args: { report_id: string; message: string; author?: string }) {
+  if (!isValidUUID(args.report_id)) return { error: 'Invalid report_id format' };
+  if (!args.message?.trim()) return { error: 'Message is required' };
+
+  // Verify report exists
+  const { data: report } = await supabase
+    .from('reports').select('id').eq('id', args.report_id).eq('project_id', currentProjectId).single();
+  if (!report) return { error: 'Report not found' };
+
+  // Find or create a discussion thread for this report
+  const { data: existingThread } = await supabase
+    .from('discussion_threads').select('id')
+    .eq('project_id', currentProjectId).eq('report_id', args.report_id).eq('thread_type', 'report')
+    .limit(1).single();
+
+  let threadId: string;
+  if (existingThread) {
+    threadId = existingThread.id;
+  } else {
+    const newId = crypto.randomUUID();
+    const { error: threadErr } = await supabase
+      .from('discussion_threads').insert({
+        id: newId, project_id: currentProjectId, report_id: args.report_id,
+        thread_type: 'report', subject: 'Bug Report Discussion', audience: 'all',
+        priority: 'normal', created_by_admin: true, last_message_at: new Date().toISOString(),
+      });
+    if (threadErr) return { error: `Failed to create thread: ${threadErr.message}` };
+    threadId = newId;
+  }
+
+  const { data: msg, error: msgErr } = await supabase
+    .from('discussion_messages').insert({
+      thread_id: threadId, sender_type: 'admin', sender_name: args.author || 'Claude Code', content: args.message.trim(), content_type: 'text',
+    }).select('id, content, created_at').single();
+
+  if (msgErr) return { error: `Failed to add comment: ${msgErr.message}` };
+  return { success: true, comment: { id: msg.id, thread_id: threadId, content: msg.content, author: args.author || 'Claude Code', created_at: msg.created_at }, message: 'Comment added to report' };
+}
+
+async function getReportComments(args: { report_id: string }) {
+  if (!isValidUUID(args.report_id)) return { error: 'Invalid report_id format' };
+
+  const { data: threads } = await supabase
+    .from('discussion_threads').select('id')
+    .eq('project_id', currentProjectId).eq('report_id', args.report_id).order('created_at', { ascending: true });
+
+  if (!threads || threads.length === 0) return { comments: [], total: 0, message: 'No comments on this report' };
+
+  const { data: messages, error } = await supabase
+    .from('discussion_messages').select('id, thread_id, sender_type, content, content_type, created_at, attachments')
+    .in('thread_id', threads.map(t => t.id)).order('created_at', { ascending: true });
+
+  if (error) return { error: error.message };
+  return { comments: (messages || []).map(m => ({ id: m.id, sender_type: m.sender_type, content: m.content, created_at: m.created_at, attachments: m.attachments })), total: (messages || []).length };
+}
+
+async function getProjectInfo() {
+  // Get project details
+  const { data: project, error: projectError } = await supabase
+    .from('projects')
+    .select('id, name, slug, is_qa_enabled')
+    .eq('id', currentProjectId)
+    .single();
+
+  if (projectError) {
+    return { error: projectError.message };
+  }
+
+  // Get track counts
+  const { data: tracks } = await supabase
+    .from('qa_tracks')
+    .select('id, name, icon, test_template')
+    .eq('project_id', currentProjectId);
+
+  // Get test case count
+  const { count: testCaseCount } = await supabase
     .from('test_cases')
     .select('id', { count: 'exact', head: true })
-    .eq('project_id', PROJECT_ID);
+    .eq('project_id', currentProjectId);
 
   // Get open bug count
   const { count: openBugCount } = await supabase
     .from('reports')
     .select('id', { count: 'exact', head: true })
-    .eq('project_id', PROJECT_ID)
+    .eq('project_id', currentProjectId)
     .eq('report_type', 'bug')
     .in('status', ['new', 'confirmed', 'in_progress']);
 
@@ -1279,7 +2340,7 @@ async function getQaTracks() {
   const { data, error } = await supabase
     .from('qa_tracks')
     .select('*')
-    .eq('project_id', PROJECT_ID)
+    .eq('project_id', currentProjectId)
     .order('sort_order');
 
   if (error) {
@@ -1320,7 +2381,7 @@ async function createTestCase(args: {
       const { data: trackData } = await supabase
         .from('qa_tracks')
         .select('id')
-        .eq('project_id', PROJECT_ID)
+        .eq('project_id', currentProjectId)
         .ilike('name', `%${sanitizedTrack}%`)
         .single();
       trackId = trackData?.id || null;
@@ -1328,7 +2389,7 @@ async function createTestCase(args: {
   }
 
   const testCase = {
-    project_id: PROJECT_ID,
+    project_id: currentProjectId,
     test_key: args.test_key,
     title: args.title,
     description: args.description || '',
@@ -1383,7 +2444,7 @@ async function updateTestCase(args: {
     const { data: existing } = await supabase
       .from('test_cases')
       .select('id')
-      .eq('project_id', PROJECT_ID)
+      .eq('project_id', currentProjectId)
       .eq('test_key', args.test_key)
       .single();
 
@@ -1411,7 +2472,7 @@ async function updateTestCase(args: {
     .from('test_cases')
     .update(updates)
     .eq('id', testCaseId)
-    .eq('project_id', PROJECT_ID)
+    .eq('project_id', currentProjectId)
     .select('id, test_key, title, target_route')
     .single();
 
@@ -1468,7 +2529,7 @@ async function deleteTestCases(args: {
     const { data: existing } = await supabase
       .from('test_cases')
       .select('id')
-      .eq('project_id', PROJECT_ID)
+      .eq('project_id', currentProjectId)
       .eq('test_key', args.test_key)
       .single();
 
@@ -1504,7 +2565,7 @@ async function deleteTestCases(args: {
     const { data: existing, error: lookupError } = await supabase
       .from('test_cases')
       .select('id, test_key')
-      .eq('project_id', PROJECT_ID)
+      .eq('project_id', currentProjectId)
       .in('test_key', args.test_keys);
 
     if (lookupError) {
@@ -1523,7 +2584,7 @@ async function deleteTestCases(args: {
   const { data: toDelete } = await supabase
     .from('test_cases')
     .select('id, test_key, title')
-    .eq('project_id', PROJECT_ID)
+    .eq('project_id', currentProjectId)
     .in('id', idsToDelete);
 
   if (!toDelete || toDelete.length === 0) {
@@ -1534,7 +2595,7 @@ async function deleteTestCases(args: {
   const { error: deleteError } = await supabase
     .from('test_cases')
     .delete()
-    .eq('project_id', PROJECT_ID)
+    .eq('project_id', currentProjectId)
     .in('id', idsToDelete);
 
   if (deleteError) {
@@ -1562,6 +2623,7 @@ async function listTestCases(args: {
   missing_target_route?: boolean;
   limit?: number;
   offset?: number;
+  compact?: boolean;
 }) {
   let query = supabase
     .from('test_cases')
@@ -1577,7 +2639,7 @@ async function listTestCases(args: {
       steps,
       track:qa_tracks(id, name, icon, color)
     `)
-    .eq('project_id', PROJECT_ID)
+    .eq('project_id', currentProjectId)
     .order('test_key', { ascending: true });
 
   // Apply filters
@@ -1608,6 +2670,20 @@ async function listTestCases(args: {
     );
   }
 
+  // Compact: return minimal fields only
+  if (args.compact === true) {
+    return {
+      count: testCases.length,
+      testCases: testCases.map((tc: any) => ({
+        id: tc.id,
+        testKey: tc.test_key,
+        title: tc.title,
+        priority: tc.priority,
+      })),
+      pagination: { limit, offset, hasMore: testCases.length === limit },
+    };
+  }
+
   return {
     count: testCases.length,
     testCases: testCases.map((tc: any) => ({
@@ -1634,7 +2710,7 @@ async function getBugPatterns(args: { route?: string }) {
   let query = supabase
     .from('reports')
     .select('app_context, severity, status, created_at')
-    .eq('project_id', PROJECT_ID)
+    .eq('project_id', currentProjectId)
     .eq('report_type', 'bug')
     .order('created_at', { ascending: false })
     .limit(100);
@@ -1704,7 +2780,7 @@ async function suggestTestCases(args: {
   const { data: existingTests } = await supabase
     .from('test_cases')
     .select('test_key, title')
-    .eq('project_id', PROJECT_ID)
+    .eq('project_id', currentProjectId)
     .order('test_key', { ascending: false })
     .limit(1);
 
@@ -1755,7 +2831,7 @@ async function suggestTestCases(args: {
   const { data: relatedBugs } = await supabase
     .from('reports')
     .select('id, description, severity')
-    .eq('project_id', PROJECT_ID)
+    .eq('project_id', currentProjectId)
     .eq('report_type', 'bug')
     .limit(10);
 
@@ -1798,7 +2874,7 @@ async function getTestPriorities(args: {
   const includeFactors = args.include_factors !== false;
 
   // First, refresh the route stats
-  const { error: refreshError } = await supabase.rpc('refresh_route_test_stats', { p_project_id: PROJECT_ID });
+  const { error: refreshError } = await supabase.rpc('refresh_route_test_stats', { p_project_id: currentProjectId });
   if (refreshError) {
     // Non-fatal: proceed with potentially stale data but warn
     console.warn('Failed to refresh route stats:', refreshError.message);
@@ -1808,7 +2884,7 @@ async function getTestPriorities(args: {
   const { data: routes, error } = await supabase
     .from('route_test_stats')
     .select('*')
-    .eq('project_id', PROJECT_ID)
+    .eq('project_id', currentProjectId)
     .gte('priority_score', minScore)
     .order('priority_score', { ascending: false })
     .limit(limit);
@@ -1942,7 +3018,7 @@ async function getCoverageGaps(args: {
   const { data: routesFromReports } = await supabase
     .from('reports')
     .select('app_context')
-    .eq('project_id', PROJECT_ID)
+    .eq('project_id', currentProjectId)
     .not('app_context->currentRoute', 'is', null);
 
   const allRoutes = new Set<string>();
@@ -1955,7 +3031,7 @@ async function getCoverageGaps(args: {
   const { data: testCases } = await supabase
     .from('test_cases')
     .select('target_route, category, track_id')
-    .eq('project_id', PROJECT_ID);
+    .eq('project_id', currentProjectId);
 
   const coveredRoutes = new Set<string>();
   const routeTrackCoverage: Record<string, Set<string>> = {};
@@ -1973,7 +3049,7 @@ async function getCoverageGaps(args: {
   const { data: tracks } = await supabase
     .from('qa_tracks')
     .select('id, name')
-    .eq('project_id', PROJECT_ID);
+    .eq('project_id', currentProjectId);
 
   const trackMap = new Map((tracks || []).map(t => [t.id, t.name]));
 
@@ -1981,7 +3057,7 @@ async function getCoverageGaps(args: {
   const { data: routeStats } = await supabase
     .from('route_test_stats')
     .select('route, last_tested_at, open_bugs, critical_bugs')
-    .eq('project_id', PROJECT_ID);
+    .eq('project_id', currentProjectId);
 
   const routeStatsMap = new Map((routeStats || []).map(r => [r.route, r]));
 
@@ -2092,7 +3168,7 @@ async function getRegressions(args: {
   const { data: resolvedBugs } = await supabase
     .from('reports')
     .select('id, description, severity, app_context, resolved_at')
-    .eq('project_id', PROJECT_ID)
+    .eq('project_id', currentProjectId)
     .eq('report_type', 'bug')
     .in('status', ['resolved', 'fixed', 'verified', 'closed'])
     .gte('resolved_at', new Date(Date.now() - days * 24 * 60 * 60 * 1000).toISOString());
@@ -2100,7 +3176,7 @@ async function getRegressions(args: {
   const { data: newBugs } = await supabase
     .from('reports')
     .select('id, description, severity, app_context, created_at')
-    .eq('project_id', PROJECT_ID)
+    .eq('project_id', currentProjectId)
     .eq('report_type', 'bug')
     .in('status', ['new', 'triaging', 'confirmed', 'in_progress', 'reviewed'])
     .gte('created_at', new Date(Date.now() - days * 24 * 60 * 60 * 1000).toISOString());
@@ -2219,21 +3295,21 @@ async function getCoverageMatrix(args: {
   include_execution_data?: boolean;
   include_bug_counts?: boolean;
 }) {
-  const includeExecution = args.include_execution_data !== false;
-  const includeBugs = args.include_bug_counts !== false;
+  const includeExecution = args.include_execution_data === true;
+  const includeBugs = args.include_bug_counts === true;
 
   // Get tracks
   const { data: tracks } = await supabase
     .from('qa_tracks')
     .select('id, name, icon, color')
-    .eq('project_id', PROJECT_ID)
+    .eq('project_id', currentProjectId)
     .order('sort_order');
 
   // Get test cases with track info
   const { data: testCases } = await supabase
     .from('test_cases')
     .select('id, target_route, category, track_id')
-    .eq('project_id', PROJECT_ID);
+    .eq('project_id', currentProjectId);
 
   // Get test assignments for execution data
   let assignments: any[] = [];
@@ -2241,7 +3317,7 @@ async function getCoverageMatrix(args: {
     const { data } = await supabase
       .from('test_assignments')
       .select('test_case_id, status, completed_at')
-      .eq('project_id', PROJECT_ID)
+      .eq('project_id', currentProjectId)
       .in('status', ['passed', 'failed'])
       .order('completed_at', { ascending: false })
       .limit(2000);
@@ -2254,7 +3330,7 @@ async function getCoverageMatrix(args: {
     const { data } = await supabase
       .from('route_test_stats')
       .select('route, open_bugs, critical_bugs')
-      .eq('project_id', PROJECT_ID);
+      .eq('project_id', currentProjectId);
     routeStats = data || [];
   }
   const routeStatsMap = new Map(routeStats.map(r => [r.route, r]));
@@ -2416,7 +3492,7 @@ async function getStaleCoverage(args: {
   const limit = args.limit || 20;
 
   // Refresh stats first
-  const { error: refreshError } = await supabase.rpc('refresh_route_test_stats', { p_project_id: PROJECT_ID });
+  const { error: refreshError } = await supabase.rpc('refresh_route_test_stats', { p_project_id: currentProjectId });
   if (refreshError) {
     // Non-fatal: proceed with potentially stale data but warn
     console.warn('Failed to refresh route stats:', refreshError.message);
@@ -2426,7 +3502,7 @@ async function getStaleCoverage(args: {
   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', PROJECT_ID)
+    .eq('project_id', currentProjectId)
     .order('last_tested_at', { ascending: true, nullsFirst: true })
     .limit(limit * 2);  // Get extra to filter
 
@@ -2524,12 +3600,12 @@ async function generateDeployChecklist(args: {
     supabase
       .from('test_cases')
       .select('id, test_key, title, target_route, category, priority, track:qa_tracks(name)')
-      .eq('project_id', PROJECT_ID)
+      .eq('project_id', currentProjectId)
       .in('target_route', safeRoutes),
     supabase
       .from('test_cases')
       .select('id, test_key, title, target_route, category, priority, track:qa_tracks(name)')
-      .eq('project_id', PROJECT_ID)
+      .eq('project_id', currentProjectId)
       .in('category', safeRoutes),
   ]);
 
@@ -2545,7 +3621,7 @@ async function generateDeployChecklist(args: {
   const { data: routeStats } = await supabase
     .from('route_test_stats')
     .select('*')
-    .eq('project_id', PROJECT_ID)
+    .eq('project_id', currentProjectId)
     .in('route', Array.from(allRoutes));
 
   const routeStatsMap = new Map((routeStats || []).map(r => [r.route, r]));
@@ -2661,21 +3737,21 @@ async function getQAHealth(args: {
   const { data: currentTests } = await supabase
     .from('test_assignments')
     .select('id, status, completed_at')
-    .eq('project_id', PROJECT_ID)
+    .eq('project_id', currentProjectId)
     .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', PROJECT_ID)
+    .eq('project_id', currentProjectId)
     .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', PROJECT_ID)
+    .eq('project_id', currentProjectId)
     .eq('report_type', 'bug')
     .in('status', ['resolved', 'fixed', 'verified', 'closed'])
     .gte('resolved_at', periodStart.toISOString());
@@ -2683,12 +3759,12 @@ async function getQAHealth(args: {
   const { data: testers } = await supabase
     .from('testers')
     .select('id, status')
-    .eq('project_id', PROJECT_ID);
+    .eq('project_id', currentProjectId);
 
   const { data: routeStats } = await supabase
     .from('route_test_stats')
     .select('route, test_case_count')
-    .eq('project_id', PROJECT_ID);
+    .eq('project_id', currentProjectId);
 
   // Get previous period data for comparison
   let previousTests: any[] = [];
@@ -2699,7 +3775,7 @@ async function getQAHealth(args: {
     const { data: pt } = await supabase
       .from('test_assignments')
       .select('id, status')
-      .eq('project_id', PROJECT_ID)
+      .eq('project_id', currentProjectId)
       .gte('completed_at', previousStart.toISOString())
       .lt('completed_at', periodStart.toISOString())
       .in('status', ['passed', 'failed']);
@@ -2708,7 +3784,7 @@ async function getQAHealth(args: {
     const { data: pb } = await supabase
       .from('reports')
       .select('id, severity')
-      .eq('project_id', PROJECT_ID)
+      .eq('project_id', currentProjectId)
       .eq('report_type', 'bug')
       .gte('created_at', previousStart.toISOString())
       .lt('created_at', periodStart.toISOString());
@@ -2717,7 +3793,7 @@ async function getQAHealth(args: {
     const { data: pr } = await supabase
       .from('reports')
       .select('id')
-      .eq('project_id', PROJECT_ID)
+      .eq('project_id', currentProjectId)
       .in('status', ['resolved', 'fixed', 'verified', 'closed'])
       .gte('resolved_at', previousStart.toISOString())
       .lt('resolved_at', periodStart.toISOString());
@@ -2888,7 +3964,7 @@ async function getQASessions(args: {
       findings_count, bugs_filed, created_at,
       tester:testers(id, name, email)
     `)
-    .eq('project_id', PROJECT_ID)
+    .eq('project_id', currentProjectId)
     .order('started_at', { ascending: false })
     .limit(limit);
 
@@ -2954,13 +4030,13 @@ async function getQAAlerts(args: {
 
   // Optionally refresh alerts
   if (args.refresh) {
-    await supabase.rpc('detect_all_alerts', { p_project_id: PROJECT_ID });
+    await supabase.rpc('detect_all_alerts', { p_project_id: currentProjectId });
   }
 
   let query = supabase
     .from('qa_alerts')
     .select('*')
-    .eq('project_id', PROJECT_ID)
+    .eq('project_id', currentProjectId)
     .order('severity', { ascending: true }) // critical first
     .order('created_at', { ascending: false });
 
@@ -3025,7 +4101,7 @@ async function getDeploymentAnalysis(args: {
       .from('deployments')
       .select('*')
       .eq('id', args.deployment_id)
-      .eq('project_id', PROJECT_ID)
+      .eq('project_id', currentProjectId)
       .single();
 
     if (error) {
@@ -3039,7 +4115,7 @@ async function getDeploymentAnalysis(args: {
   let query = supabase
     .from('deployments')
     .select('*')
-    .eq('project_id', PROJECT_ID)
+    .eq('project_id', currentProjectId)
     .order('deployed_at', { ascending: false })
     .limit(limit);
 
@@ -3134,7 +4210,7 @@ async function analyzeCommitForTesting(args: {
   const { data: mappings } = await supabase
     .from('file_route_mapping')
     .select('file_pattern, route, feature, confidence')
-    .eq('project_id', PROJECT_ID);
+    .eq('project_id', currentProjectId);
 
   const affectedRoutes: Array<{ route: string; feature?: string; confidence: number; matched_files: string[] }> = [];
 
@@ -3171,7 +4247,7 @@ async function analyzeCommitForTesting(args: {
     const { data: bugs } = await supabase
       .from('reports')
       .select('id, severity, description, route, created_at')
-      .eq('project_id', PROJECT_ID)
+      .eq('project_id', currentProjectId)
       .eq('report_type', 'bug')
       .in('route', routes)
       .gte('created_at', new Date(Date.now() - 30 * 24 * 60 * 60 * 1000).toISOString());
@@ -3208,7 +4284,7 @@ async function analyzeCommitForTesting(args: {
   // Optionally record as deployment
   if (args.record_deployment) {
     await supabase.rpc('record_deployment', {
-      p_project_id: PROJECT_ID,
+      p_project_id: currentProjectId,
       p_environment: 'production',
       p_commit_sha: args.commit_sha || null,
       p_commit_message: args.commit_message || null,
@@ -3308,13 +4384,13 @@ async function analyzeChangesForTests(args: {
   const { data: existingTests } = await supabase
     .from('test_cases')
     .select('test_key, title, target_route, description')
-    .eq('project_id', PROJECT_ID);
+    .eq('project_id', currentProjectId);
 
   // Get next test key
   const { data: lastTest } = await supabase
     .from('test_cases')
     .select('test_key')
-    .eq('project_id', PROJECT_ID)
+    .eq('project_id', currentProjectId)
     .order('test_key', { ascending: false })
     .limit(1);
 
@@ -3329,7 +4405,7 @@ async function analyzeChangesForTests(args: {
     const { data: bugs } = await supabase
       .from('reports')
       .select('id, description, severity, app_context')
-      .eq('project_id', PROJECT_ID)
+      .eq('project_id', currentProjectId)
       .eq('report_type', 'bug')
       .limit(50);
 
@@ -3731,7 +4807,7 @@ async function createBugReport(args: {
   const { data: project } = await supabase
     .from('projects')
     .select('owner_id')
-    .eq('id', PROJECT_ID)
+    .eq('id', currentProjectId)
     .single();
   if (project?.owner_id) {
     reporterId = project.owner_id;
@@ -3740,7 +4816,7 @@ async function createBugReport(args: {
     const { data: testers } = await supabase
       .from('testers')
       .select('id')
-      .eq('project_id', PROJECT_ID)
+      .eq('project_id', currentProjectId)
       .limit(1);
     if (testers && testers.length > 0) {
       reporterId = testers[0].id;
@@ -3748,7 +4824,7 @@ async function createBugReport(args: {
   }
 
   const report: Record<string, unknown> = {
-    project_id: PROJECT_ID,
+    project_id: currentProjectId,
     report_type: 'bug',
     title: args.title,
     description: args.description,
@@ -3823,7 +4899,7 @@ async function getBugsForFile(args: {
   let query = supabase
     .from('reports')
     .select('id, title, description, severity, status, created_at, code_context')
-    .eq('project_id', PROJECT_ID)
+    .eq('project_id', currentProjectId)
     .eq('report_type', 'bug');
 
   if (!args.include_resolved) {
@@ -3906,7 +4982,7 @@ async function markFixedWithCommit(args: {
     .from('reports')
     .select('code_context')
     .eq('id', args.report_id)
-    .eq('project_id', PROJECT_ID) // Security: ensure report belongs to this project
+    .eq('project_id', currentProjectId) // Security: ensure report belongs to this project
     .single();
 
   if (fetchError) {
@@ -3919,7 +4995,7 @@ async function markFixedWithCommit(args: {
     status: 'resolved',
     resolved_at: new Date().toISOString(),
     resolution_notes: args.resolution_notes || `Fixed in commit ${args.commit_sha.slice(0, 7)}`,
-    notify_tester: args.notify_tester === true, // Opt-in: only notify if explicitly requested
+    notify_tester: args.notify_tester !== false, // Default: notify tester. Pass false to silently resolve.
     code_context: {
       ...existingContext,
       fix: {
@@ -3936,13 +5012,14 @@ async function markFixedWithCommit(args: {
     .from('reports')
     .update(updates)
     .eq('id', args.report_id)
-    .eq('project_id', PROJECT_ID); // Security: ensure report belongs to this project
+    .eq('project_id', currentProjectId); // Security: ensure report belongs to this project
 
   if (error) {
     return { error: error.message };
   }
 
-  const notificationStatus = args.notify_tester
+  const notifyTester = args.notify_tester !== false;
+  const notificationStatus = notifyTester
     ? 'The original tester will be notified and assigned a verification task.'
     : 'No notification sent (silent resolve). A verification task was created.';
 
@@ -3951,7 +5028,7 @@ async function markFixedWithCommit(args: {
     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,
+    tester_notified: notifyTester,
     next_steps: [
       'Consider running create_regression_test to prevent this bug from recurring',
       'Push your changes to trigger CI/CD',
@@ -3968,7 +5045,7 @@ async function getBugsAffectingCode(args: {
   const { data, error } = await supabase
     .from('reports')
     .select('id, title, description, severity, status, code_context, app_context')
-    .eq('project_id', PROJECT_ID)
+    .eq('project_id', currentProjectId)
     .eq('report_type', 'bug')
     .in('status', ['new', 'confirmed', 'in_progress', 'reviewed'])
     .order('severity', { ascending: true });
@@ -4099,7 +5176,7 @@ async function linkBugToCode(args: {
     .from('reports')
     .select('code_context')
     .eq('id', args.report_id)
-    .eq('project_id', PROJECT_ID) // Security: ensure report belongs to this project
+    .eq('project_id', currentProjectId) // Security: ensure report belongs to this project
     .single();
 
   if (fetchError) {
@@ -4124,7 +5201,7 @@ async function linkBugToCode(args: {
     .from('reports')
     .update(updates)
     .eq('id', args.report_id)
-    .eq('project_id', PROJECT_ID); // Security: ensure report belongs to this project
+    .eq('project_id', currentProjectId); // Security: ensure report belongs to this project
 
   if (error) {
     return { error: error.message };
@@ -4150,7 +5227,7 @@ async function createRegressionTest(args: {
     .from('reports')
     .select('*')
     .eq('id', args.report_id)
-    .eq('project_id', PROJECT_ID) // Security: ensure report belongs to this project
+    .eq('project_id', currentProjectId) // Security: ensure report belongs to this project
     .single();
 
   if (fetchError) {
@@ -4171,7 +5248,7 @@ async function createRegressionTest(args: {
   const { data: existingTests } = await supabase
     .from('test_cases')
     .select('test_key')
-    .eq('project_id', PROJECT_ID)
+    .eq('project_id', currentProjectId)
     .order('test_key', { ascending: false })
     .limit(1);
 
@@ -4185,7 +5262,7 @@ async function createRegressionTest(args: {
 
   // Generate test case from bug
   const testCase = {
-    project_id: PROJECT_ID,
+    project_id: currentProjectId,
     test_key: newKey,
     title: `Regression: ${report.title}`,
     description: `Regression test to prevent recurrence of bug #${args.report_id.slice(0, 8)}\n\nOriginal bug: ${report.description}`,
@@ -4270,7 +5347,7 @@ async function getPendingFixes(args: {
       created_at,
       report:reports(id, title, severity, description)
     `)
-    .eq('project_id', PROJECT_ID)
+    .eq('project_id', currentProjectId)
     .order('created_at', { ascending: true })
     .limit(limit);
 
@@ -4329,7 +5406,7 @@ async function claimFixRequest(args: {
     .from('fix_requests')
     .select('id, status, claimed_by, prompt, title')
     .eq('id', args.fix_request_id)
-    .eq('project_id', PROJECT_ID) // Security: ensure fix request belongs to this project
+    .eq('project_id', currentProjectId) // Security: ensure fix request belongs to this project
     .single();
 
   if (checkError) {
@@ -4360,7 +5437,7 @@ async function claimFixRequest(args: {
       claimed_by: claimedBy,
     })
     .eq('id', args.fix_request_id)
-    .eq('project_id', PROJECT_ID) // Security: ensure fix request belongs to this project
+    .eq('project_id', currentProjectId) // Security: ensure fix request belongs to this project
     .eq('status', 'pending'); // Only claim if still pending (race condition protection)
 
   if (updateError) {
@@ -4405,7 +5482,7 @@ async function completeFixRequest(args: {
     .from('fix_requests')
     .update(updates)
     .eq('id', args.fix_request_id)
-    .eq('project_id', PROJECT_ID); // Security: ensure fix request belongs to this project
+    .eq('project_id', currentProjectId); // Security: ensure fix request belongs to this project
 
   if (error) {
     return { error: error.message };
@@ -4493,7 +5570,7 @@ async function generatePromptContent(name: string, args: Record<string, string>)
           created_at,
           report:reports(id, title, severity)
         `)
-        .eq('project_id', PROJECT_ID)
+        .eq('project_id', currentProjectId)
         .eq('status', 'pending')
         .order('created_at', { ascending: true })
         .limit(5);
@@ -4502,7 +5579,7 @@ async function generatePromptContent(name: string, args: Record<string, string>)
       let query = supabase
         .from('reports')
         .select('id, title, description, severity, status, code_context, created_at')
-        .eq('project_id', PROJECT_ID)
+        .eq('project_id', currentProjectId)
         .eq('report_type', 'bug')
         .in('status', ['new', 'confirmed', 'in_progress']);
 
@@ -4667,542 +5744,1159 @@ Would you like me to generate test cases for these files?`;
       const { data: resolvedBugs } = await supabase
         .from('reports')
         .select('id, title, description, severity, resolved_at, code_context')
-        .eq('project_id', PROJECT_ID)
+        .eq('project_id', currentProjectId)
         .eq('report_type', 'bug')
         .eq('status', 'resolved')
         .order('resolved_at', { ascending: false })
         .limit(limit);
 
-      if (!resolvedBugs || resolvedBugs.length === 0) {
-        return `# Regression Test Generation
+      if (!resolvedBugs || resolvedBugs.length === 0) {
+        return `# Regression Test Generation
+
+No recently resolved bugs found.
+
+To create regression tests:
+1. First fix some bugs and mark them as resolved using \`mark_fixed_with_commit\`
+2. Then come back here to generate regression tests
+
+Alternatively, use \`suggest_test_cases\` to generate general test cases.`;
+      }
+
+      // Check which ones already have regression tests
+      const bugList = resolvedBugs.map((b, i) => {
+        const ctx = b.code_context as Record<string, unknown> | null;
+        const hasCommit = ctx?.fix && (ctx.fix as any).commit_sha;
+
+        return `
+## ${i + 1}. ${b.title}
+- **Bug ID:** \`${b.id}\`
+- **Severity:** ${b.severity}
+- **Resolved:** ${b.resolved_at ? new Date(b.resolved_at).toLocaleDateString() : 'Unknown'}
+- **Commit:** ${hasCommit ? (ctx!.fix as any).commit_sha.slice(0, 7) : 'Not linked'}
+`;
+      }).join('\n');
+
+      return `# Regression Test Generation
+
+Found **${resolvedBugs.length}** recently resolved bug(s) that need regression tests:
+
+${bugList}
+
+---
+
+## Generate Tests
+
+For each bug, I can create a regression test to prevent it from recurring.
+
+Use \`create_regression_test\` with the bug ID to generate a test case.
+
+Example:
+\`\`\`
+create_regression_test(report_id: "${resolvedBugs[0]?.id}", test_type: "integration")
+\`\`\`
+
+Would you like me to generate regression tests for all of these bugs?`;
+    }
+
+    case 'bug_hunt': {
+      const focus = args.focus || 'general';
+
+      const focusDescriptions: Record<string, string> = {
+        error_handling: 'missing try/catch blocks, unhandled promise rejections, missing error boundaries',
+        null_checks: 'potential null/undefined access, optional chaining opportunities, nullish coalescing',
+        async_issues: 'race conditions, missing await, unhandled async errors, memory leaks',
+        type_safety: 'type assertions, any types, missing type guards, unsafe casts',
+        security: 'XSS vulnerabilities, injection risks, exposed secrets, insecure data handling',
+        general: 'common patterns that have caused bugs in this project',
+      };
+
+      // Get bug patterns for context
+      const patterns = await getBugPatterns({});
+
+      return `# Bug Hunt Mode: ${focus.charAt(0).toUpperCase() + focus.slice(1)}
+
+I'm looking for: **${focusDescriptions[focus] || focusDescriptions.general}**
+
+## Historical Bug Hotspots
+
+${(patterns as any).hotspots?.slice(0, 5).map((h: any) =>
+  `- **${h.route}**: ${h.total} bugs (${h.open} open, ${h.critical} critical)`
+).join('\n') || 'No bug patterns found yet.'}
+
+## Bug Hunt Checklist
+
+Based on past bugs in this project, here's what to look for:
+
+${focus === 'error_handling' || focus === 'general' ? `
+### Error Handling
+- [ ] All async functions have try/catch or .catch()
+- [ ] API calls handle network errors
+- [ ] User-facing error messages are helpful
+- [ ] Errors are logged appropriately
+` : ''}
+
+${focus === 'null_checks' || focus === 'general' ? `
+### Null Safety
+- [ ] Optional chaining (?.) used for potentially undefined values
+- [ ] Nullish coalescing (??) for default values
+- [ ] Array/object access is guarded
+- [ ] Props have appropriate defaults
+` : ''}
+
+${focus === 'async_issues' || focus === 'general' ? `
+### Async Issues
+- [ ] All Promises are awaited or have .then()
+- [ ] Cleanup functions in useEffect
+- [ ] Race conditions prevented with AbortController
+- [ ] Loading states are handled
+` : ''}
+
+---
+
+**To report bugs you find:** Use \`create_bug_report\` with the file, line number, and code snippet.
+
+Which files or areas would you like me to analyze?`;
+    }
+
+    default:
+      return 'Unknown prompt';
+  }
+}
+
+// === TESTER & ASSIGNMENT MANAGEMENT HANDLERS ===
+
+async function listTesters(args: {
+  status?: string;
+  platform?: string;
+  role?: string;
+}) {
+  let query = supabase
+    .from('testers')
+    .select('id, name, email, status, platforms, tier, assigned_count, completed_count, notes, role, created_at')
+    .eq('project_id', currentProjectId)
+    .order('name', { ascending: true });
+
+  if (args.status) {
+    query = query.eq('status', args.status);
+  }
+  if (args.role) {
+    query = query.eq('role', args.role);
+  }
+
+  const { data, error } = await query;
+
+  if (error) {
+    return { error: error.message };
+  }
+
+  let testers = data || [];
+
+  // Filter by platform if specified (platforms is an array column)
+  if (args.platform) {
+    testers = testers.filter((t: any) =>
+      t.platforms && t.platforms.includes(args.platform)
+    );
+  }
+
+  return {
+    count: testers.length,
+    testers: testers.map((t: any) => ({
+      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,
+      role: t.role,
+    })),
+  };
+}
+
+async function listTestRuns(args: {
+  status?: string;
+  limit?: number;
+}) {
+  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', currentProjectId)
+    .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: any) => ({
+      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(args: {
+  name: string;
+  description?: string;
+}) {
+  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: currentProjectId,
+      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(args: {
+  tester_id?: string;
+  test_run_id?: string;
+  status?: string;
+  limit?: number;
+}) {
+  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' };
+  }
 
-No recently resolved bugs found.
+  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', currentProjectId)
+    .order('assigned_at', { ascending: false })
+    .limit(limit);
 
-To create regression tests:
-1. First fix some bugs and mark them as resolved using \`mark_fixed_with_commit\`
-2. Then come back here to generate regression tests
+  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);
+  }
 
-Alternatively, use \`suggest_test_cases\` to generate general test cases.`;
-      }
+  const { data, error } = await query;
 
-      // Check which ones already have regression tests
-      const bugList = resolvedBugs.map((b, i) => {
-        const ctx = b.code_context as Record<string, unknown> | null;
-        const hasCommit = ctx?.fix && (ctx.fix as any).commit_sha;
+  if (error) {
+    return { error: error.message };
+  }
 
-        return `
-## ${i + 1}. ${b.title}
-- **Bug ID:** \`${b.id}\`
-- **Severity:** ${b.severity}
-- **Resolved:** ${b.resolved_at ? new Date(b.resolved_at).toLocaleDateString() : 'Unknown'}
-- **Commit:** ${hasCommit ? (ctx!.fix as any).commit_sha.slice(0, 7) : 'Not linked'}
-`;
-      }).join('\n');
+  return {
+    count: (data || []).length,
+    assignments: (data || []).map((a: any) => ({
+      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,
+    })),
+  };
+}
 
-      return `# Regression Test Generation
+async function assignTests(args: {
+  tester_id: string;
+  test_case_ids: string[];
+  test_run_id?: string;
+}) {
+  // Validate inputs
+  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' };
+  }
 
-Found **${resolvedBugs.length}** recently resolved bug(s) that need regression tests:
+  // Verify tester exists and is active
+  const { data: tester, error: testerErr } = await supabase
+    .from('testers')
+    .select('id, name, email, status')
+    .eq('id', args.tester_id)
+    .eq('project_id', currentProjectId)
+    .single();
 
-${bugList}
+  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` };
+  }
 
----
+  // Verify test cases exist for this project
+  const { data: testCases, error: tcErr } = await supabase
+    .from('test_cases')
+    .select('id, test_key, title')
+    .eq('project_id', currentProjectId)
+    .in('id', args.test_case_ids);
 
-## Generate Tests
+  if (tcErr) {
+    return { error: tcErr.message };
+  }
 
-For each bug, I can create a regression test to prevent it from recurring.
+  const foundIds = new Set((testCases || []).map((tc: any) => tc.id));
+  const missingIds = args.test_case_ids.filter(id => !foundIds.has(id));
 
-Use \`create_regression_test\` with the bug ID to generate a test case.
+  if (missingIds.length > 0) {
+    return {
+      error: `Test cases not found in this project: ${missingIds.join(', ')}`,
+    };
+  }
 
-Example:
-\`\`\`
-create_regression_test(report_id: "${resolvedBugs[0]?.id}", test_type: "integration")
-\`\`\`
+  // Verify test run exists if provided
+  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', currentProjectId)
+      .single();
 
-Would you like me to generate regression tests for all of these bugs?`;
+    if (runErr || !run) {
+      return { error: 'Test run not found in this project' };
     }
+  }
 
-    case 'bug_hunt': {
-      const focus = args.focus || 'general';
-
-      const focusDescriptions: Record<string, string> = {
-        error_handling: 'missing try/catch blocks, unhandled promise rejections, missing error boundaries',
-        null_checks: 'potential null/undefined access, optional chaining opportunities, nullish coalescing',
-        async_issues: 'race conditions, missing await, unhandled async errors, memory leaks',
-        type_safety: 'type assertions, any types, missing type guards, unsafe casts',
-        security: 'XSS vulnerabilities, injection risks, exposed secrets, insecure data handling',
-        general: 'common patterns that have caused bugs in this project',
-      };
-
-      // Get bug patterns for context
-      const patterns = await getBugPatterns({});
+  // Build assignment rows
+  const rows = args.test_case_ids.map(tcId => ({
+    project_id: currentProjectId,
+    test_case_id: tcId,
+    tester_id: args.tester_id,
+    test_run_id: args.test_run_id || null,
+    status: 'pending',
+  }));
 
-      return `# Bug Hunt Mode: ${focus.charAt(0).toUpperCase() + focus.slice(1)}
+  // Helper: after assignments change, sync the test run's total_tests counter
+  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', currentProjectId);
+    if (count !== null) {
+      await supabase
+        .from('test_runs')
+        .update({ total_tests: count })
+        .eq('id', args.test_run_id);
+    }
+  }
 
-I'm looking for: **${focusDescriptions[focus] || focusDescriptions.general}**
+  // Insert — use upsert-like approach: insert and handle conflicts
+  const { data: inserted, error: insertErr } = await supabase
+    .from('test_assignments')
+    .insert(rows)
+    .select('id, test_case_id');
 
-## Historical Bug Hotspots
+  if (insertErr) {
+    // Check if it's a unique constraint violation
+    if (insertErr.message.includes('duplicate') || insertErr.message.includes('unique')) {
+      // Try inserting one by one to find duplicates
+      const created: any[] = [];
+      const skipped: string[] = [];
 
-${(patterns as any).hotspots?.slice(0, 5).map((h: any) =>
-  `- **${h.route}**: ${h.total} bugs (${h.open} open, ${h.critical} critical)`
-).join('\n') || 'No bug patterns found yet.'}
+      for (const row of rows) {
+        const { data: single, error: singleErr } = await supabase
+          .from('test_assignments')
+          .insert(row)
+          .select('id, test_case_id')
+          .single();
 
-## Bug Hunt Checklist
+        if (singleErr) {
+          const tc = testCases?.find((t: any) => t.id === row.test_case_id);
+          skipped.push(tc?.test_key || row.test_case_id);
+        } else if (single) {
+          created.push(single);
+        }
+      }
 
-Based on past bugs in this project, here's what to look for:
+      await syncRunCounter();
 
-${focus === 'error_handling' || focus === 'general' ? `
-### Error Handling
-- [ ] All async functions have try/catch or .catch()
-- [ ] API calls handle network errors
-- [ ] User-facing error messages are helpful
-- [ ] Errors are logged appropriately
-` : ''}
+      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 };
+  }
 
-${focus === 'null_checks' || focus === 'general' ? `
-### Null Safety
-- [ ] Optional chaining (?.) used for potentially undefined values
-- [ ] Nullish coalescing (??) for default values
-- [ ] Array/object access is guarded
-- [ ] Props have appropriate defaults
-` : ''}
+  await syncRunCounter();
 
-${focus === 'async_issues' || focus === 'general' ? `
-### Async Issues
-- [ ] All Promises are awaited or have .then()
-- [ ] Cleanup functions in useEffect
-- [ ] Race conditions prevented with AbortController
-- [ ] Loading states are handled
-` : ''}
+  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}.`,
+  };
+}
 
----
+async function unassignTests(args: {
+  assignment_ids: string[];
+}) {
+  if (!args.assignment_ids || args.assignment_ids.length === 0) {
+    return { error: 'At least one assignment_id is required' };
+  }
+  if (args.assignment_ids.length > 50) {
+    return { error: 'Maximum 50 assignments per unassign batch' };
+  }
+  const invalidIds = args.assignment_ids.filter(id => !isValidUUID(id));
+  if (invalidIds.length > 0) {
+    return { error: `Invalid UUID(s): ${invalidIds.join(', ')}` };
+  }
 
-**To report bugs you find:** Use \`create_bug_report\` with the file, line number, and code snippet.
+  // Verify assignments exist and belong to this project
+  const { data: existing, error: lookupErr } = await supabase
+    .from('test_assignments')
+    .select('id, test_run_id, test_case:test_cases(test_key, title), tester:testers(name)')
+    .eq('project_id', currentProjectId)
+    .in('id', args.assignment_ids);
 
-Which files or areas would you like me to analyze?`;
-    }
+  if (lookupErr) return { error: lookupErr.message };
 
-    default:
-      return 'Unknown prompt';
+  if (!existing || existing.length === 0) {
+    return { error: 'No matching assignments found in this project' };
   }
-}
-
-// === TESTER & ASSIGNMENT MANAGEMENT HANDLERS ===
 
-async function listTesters(args: {
-  status?: string;
-  platform?: string;
-}) {
-  let query = supabase
-    .from('testers')
-    .select('id, name, email, status, platforms, tier, assigned_count, completed_count, notes, created_at')
-    .eq('project_id', PROJECT_ID)
-    .order('name', { ascending: true });
+  const foundIds = new Set(existing.map((a: any) => a.id));
+  const notFound = args.assignment_ids.filter(id => !foundIds.has(id));
 
-  if (args.status) {
-    query = query.eq('status', args.status);
-  }
+  // Delete the assignments
+  const { error: deleteErr } = await supabase
+    .from('test_assignments')
+    .delete()
+    .eq('project_id', currentProjectId)
+    .in('id', args.assignment_ids);
 
-  const { data, error } = await query;
+  if (deleteErr) return { error: deleteErr.message };
 
-  if (error) {
-    return { error: error.message };
+  // Sync run counters for any affected test runs
+  const affectedRunIds = [...new Set(existing.filter((a: any) => a.test_run_id).map((a: any) => a.test_run_id))];
+  for (const runId of affectedRunIds) {
+    const { count } = await supabase
+      .from('test_assignments')
+      .select('id', { count: 'exact', head: true })
+      .eq('test_run_id', runId)
+      .eq('project_id', currentProjectId);
+    if (count !== null) {
+      await supabase.from('test_runs').update({ total_tests: count }).eq('id', runId);
+    }
   }
 
-  let testers = data || [];
+  const deleted = existing.map((a: Record<string, unknown>) => {
+    const tc = a.test_case as Record<string, string> | null;
+    const tester = a.tester as Record<string, string> | null;
+    return {
+      id: a.id as string,
+      testKey: tc?.test_key || null,
+      testTitle: tc?.title || null,
+      testerName: tester?.name || null,
+    };
+  });
 
-  // Filter by platform if specified (platforms is an array column)
-  if (args.platform) {
-    testers = testers.filter((t: any) =>
-      t.platforms && t.platforms.includes(args.platform)
-    );
-  }
+  const firstKey = deleted[0]?.testKey;
 
   return {
-    count: testers.length,
-    testers: testers.map((t: any) => ({
-      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,
-    })),
+    success: true,
+    deletedCount: existing.length,
+    deleted,
+    notFound: notFound.length > 0 ? notFound : undefined,
+    message: existing.length === 1
+      ? `Removed 1 assignment${firstKey ? ` (${firstKey})` : ''}`
+      : `Removed ${existing.length} assignment(s)`,
   };
 }
 
-async function listTestRuns(args: {
-  status?: string;
-  limit?: number;
+async function getTesterWorkload(args: {
+  tester_id: string;
 }) {
-  const limit = Math.min(args.limit || 20, 50);
+  if (!isValidUUID(args.tester_id)) {
+    return { error: 'Invalid tester_id format' };
+  }
 
-  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', PROJECT_ID)
-    .order('created_at', { ascending: false })
-    .limit(limit);
+  // Get tester info
+  const { data: tester, error: testerErr } = await supabase
+    .from('testers')
+    .select('id, name, email, status, platforms, tier')
+    .eq('id', args.tester_id)
+    .eq('project_id', currentProjectId)
+    .single();
 
-  if (args.status) {
-    query = query.eq('status', args.status);
+  if (testerErr || !tester) {
+    return { error: 'Tester not found in this project' };
   }
 
-  const { data, error } = await query;
+  // Get all assignments for this tester 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', currentProjectId)
+    .eq('tester_id', args.tester_id)
+    .order('assigned_at', { ascending: false });
 
-  if (error) {
-    return { error: error.message };
+  if (assignErr) {
+    return { error: assignErr.message };
+  }
+
+  const all = assignments || [];
+
+  // Count by status
+  const counts: Record<string, number> = {
+    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 {
-    count: (data || []).length,
-    testRuns: (data || []).map((r: any) => ({
-      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,
+    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: any) => ({
+      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,
     })),
   };
 }
 
-async function createTestRun(args: {
+// === NEW TESTER & ANALYTICS HANDLERS ===
+
+async function createTester(args: {
   name: string;
-  description?: string;
+  email: string;
+  platforms?: string[];
+  tier?: number;
+  notes?: string;
+  role?: string;
 }) {
   if (!args.name || args.name.trim().length === 0) {
-    return { error: 'Test run name is required' };
+    return { error: 'Tester name is required' };
+  }
+  if (!args.email || !args.email.includes('@')) {
+    return { error: 'A valid email address is required' };
+  }
+  if (args.tier !== undefined && (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('test_runs')
+    .from('testers')
     .insert({
-      project_id: PROJECT_ID,
+      project_id: currentProjectId,
       name: args.name.trim(),
-      description: args.description?.trim() || null,
-      status: 'draft',
+      email: args.email.trim().toLowerCase(),
+      platforms: args.platforms || ['ios', 'web'],
+      tier: args.tier ?? 1,
+      notes: args.notes?.trim() || null,
+      status: 'active',
+      role: args.role || 'tester',
     })
-    .select('id, name, description, status, created_at')
+    .select('id, name, email, status, platforms, tier, notes, role, 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,
-    testRun: {
+    tester: {
       id: data.id,
       name: data.name,
-      description: data.description,
+      email: data.email,
       status: data.status,
+      platforms: data.platforms,
+      tier: data.tier,
+      notes: data.notes,
+      role: data.role,
       createdAt: data.created_at,
     },
-    message: `Test run "${data.name}" created. Use assign_tests to add test assignments.`,
+    message: `Tester "${data.name}" added to the project. Use assign_tests to give them test cases.`,
   };
 }
 
-async function listTestAssignments(args: {
-  tester_id?: string;
-  test_run_id?: string;
+async function updateTester(args: {
+  tester_id: string;
   status?: string;
-  limit?: number;
+  platforms?: string[];
+  tier?: number;
+  notes?: string;
+  name?: string;
 }) {
-  const limit = Math.min(args.limit || 50, 200);
-
-  if (args.tester_id && !isValidUUID(args.tester_id)) {
+  if (!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', PROJECT_ID)
-    .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);
+  const updates: Record<string, unknown> = {};
+  if (args.status) updates.status = args.status;
+  if (args.platforms) updates.platforms = args.platforms;
+  if (args.tier !== undefined) {
+    if (args.tier < 1 || args.tier > 3) {
+      return { error: 'Tier must be 1, 2, or 3' };
+    }
+    updates.tier = args.tier;
   }
-  if (args.status) {
-    query = query.eq('status', args.status);
+  if (args.notes !== undefined) 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 query;
+  const { data, error } = await supabase
+    .from('testers')
+    .update(updates)
+    .eq('id', args.tester_id)
+    .eq('project_id', currentProjectId)
+    .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 {
-    count: (data || []).length,
-    assignments: (data || []).map((a: any) => ({
-      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,
-    })),
+    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 assignTests(args: {
-  tester_id: string;
-  test_case_ids: string[];
-  test_run_id?: string;
+async function bulkUpdateReports(args: {
+  report_ids: string[];
+  status: string;
+  resolution_notes?: string;
 }) {
-  // Validate inputs
-  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.report_ids || args.report_ids.length === 0) {
+    return { error: 'At least one report_id is required' };
   }
-  if (args.test_case_ids.length > 50) {
-    return { error: 'Maximum 50 test cases per assignment batch' };
+  if (args.report_ids.length > 50) {
+    return { error: 'Maximum 50 reports per bulk update' };
   }
-  for (const id of args.test_case_ids) {
+  for (const id of args.report_ids) {
     if (!isValidUUID(id)) {
-      return { error: `Invalid test_case_id format: ${id}` };
+      return { error: `Invalid report_id format: ${id}` };
     }
   }
-  if (args.test_run_id && !isValidUUID(args.test_run_id)) {
-    return { error: 'Invalid test_run_id format' };
-  }
-
-  // Verify tester exists and is active
-  const { data: tester, error: testerErr } = await supabase
-    .from('testers')
-    .select('id, name, email, status')
-    .eq('id', args.tester_id)
-    .eq('project_id', PROJECT_ID)
-    .single();
 
-  if (testerErr || !tester) {
-    return { error: 'Tester not found in this project' };
+  const updates: Record<string, unknown> = { status: args.status };
+  if (args.resolution_notes) {
+    updates.resolution_notes = args.resolution_notes;
   }
-  if (tester.status !== 'active') {
-    return { error: `Tester "${tester.name}" is ${tester.status}, not active` };
+  // Set resolved_at timestamp for terminal statuses
+  if (['fixed', 'resolved', 'verified', 'wont_fix', 'duplicate', 'closed'].includes(args.status)) {
+    updates.resolved_at = new Date().toISOString();
   }
 
-  // Verify test cases exist for this project
-  const { data: testCases, error: tcErr } = await supabase
-    .from('test_cases')
-    .select('id, test_key, title')
-    .eq('project_id', PROJECT_ID)
-    .in('id', args.test_case_ids);
+  const { data, error } = await supabase
+    .from('reports')
+    .update(updates)
+    .eq('project_id', currentProjectId)
+    .in('id', args.report_ids)
+    .select('id, status, description');
 
-  if (tcErr) {
-    return { error: tcErr.message };
+  if (error) {
+    return { error: error.message };
   }
 
-  const foundIds = new Set((testCases || []).map((tc: any) => tc.id));
-  const missingIds = args.test_case_ids.filter(id => !foundIds.has(id));
+  const updated = data || [];
+  const updatedIds = new Set(updated.map((r: any) => r.id));
+  const notFound = args.report_ids.filter(id => !updatedIds.has(id));
 
-  if (missingIds.length > 0) {
+  return {
+    success: true,
+    updatedCount: updated.length,
+    requestedCount: args.report_ids.length,
+    notFound: notFound.length > 0 ? notFound : undefined,
+    status: args.status,
+    reports: updated.map((r: any) => ({
+      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.` : ''}`,
+  };
+}
+
+async function getBugTrends(args: {
+  group_by?: string;
+  days?: number;
+}) {
+  const days = Math.min(args.days || 30, 180);
+  const groupBy = args.group_by || 'week';
+  const since = new Date(Date.now() - days * 86400000).toISOString();
+
+  const { data, error } = await supabase
+    .from('reports')
+    .select('id, severity, category, status, report_type, created_at')
+    .eq('project_id', currentProjectId)
+    .gte('created_at', since)
+    .order('created_at', { ascending: true });
+
+  if (error) {
+    return { error: error.message };
+  }
+
+  const reports = data || [];
+
+  if (groupBy === 'week') {
+    const weeks: Record<string, { count: number; critical: number; high: number; medium: number; low: number }> = {};
+    for (const r of reports) {
+      const d = new Date(r.created_at);
+      // Get Monday of that week
+      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') as 'critical' | 'high' | 'medium' | 'low';
+      weeks[weekKey][sev]++;
+    }
     return {
-      error: `Test cases not found in this project: ${missingIds.join(', ')}`,
+      period: `${days} days`,
+      groupBy: 'week',
+      totalReports: reports.length,
+      weeks: Object.entries(weeks).map(([week, data]) => ({ week, ...data })),
     };
   }
 
-  // Verify test run exists if provided
-  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', PROJECT_ID)
-      .single();
+  if (groupBy === 'severity') {
+    const groups: Record<string, number> = { 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 (runErr || !run) {
-      return { error: 'Test run not found in this project' };
+  if (groupBy === 'category') {
+    const groups: Record<string, number> = {};
+    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 };
   }
 
-  // Build assignment rows
-  const rows = args.test_case_ids.map(tcId => ({
-    project_id: PROJECT_ID,
-    test_case_id: tcId,
-    tester_id: args.tester_id,
-    test_run_id: args.test_run_id || null,
-    status: 'pending',
-  }));
+  if (groupBy === 'status') {
+    const groups: Record<string, number> = {};
+    for (const r of reports) {
+      groups[r.status] = (groups[r.status] || 0) + 1;
+    }
+    return { period: `${days} days`, groupBy: 'status', totalReports: reports.length, breakdown: groups };
+  }
 
-  // Insert — use upsert-like approach: insert and handle conflicts
-  const { data: inserted, error: insertErr } = await supabase
+  return { error: `Invalid group_by: ${groupBy}. Must be one of: week, severity, category, status` };
+}
+
+async function getTesterLeaderboard(args: {
+  days?: number;
+  sort_by?: string;
+}) {
+  const days = Math.min(args.days || 30, 180);
+  const sortBy = args.sort_by || 'tests_completed';
+  const since = new Date(Date.now() - days * 86400000).toISOString();
+
+  // Get all testers for the project
+  const { data: testers, error: testerErr } = await supabase
+    .from('testers')
+    .select('id, name, email, status, platforms, tier')
+    .eq('project_id', currentProjectId)
+    .eq('status', 'active');
+
+  if (testerErr) return { error: testerErr.message };
+
+  // Get completed assignments in the period
+  const { data: assignments, error: assignErr } = await supabase
     .from('test_assignments')
-    .insert(rows)
-    .select('id, test_case_id');
+    .select('tester_id, status, completed_at, duration_seconds')
+    .eq('project_id', currentProjectId)
+    .gte('completed_at', since)
+    .in('status', ['passed', 'failed']);
 
-  if (insertErr) {
-    // Check if it's a unique constraint violation
-    if (insertErr.message.includes('duplicate') || insertErr.message.includes('unique')) {
-      // Try inserting one by one to find duplicates
-      const created: any[] = [];
-      const skipped: string[] = [];
+  if (assignErr) return { error: assignErr.message };
 
-      for (const row of rows) {
-        const { data: single, error: singleErr } = await supabase
-          .from('test_assignments')
-          .insert(row)
-          .select('id, test_case_id')
-          .single();
+  // Get bugs filed in the period
+  const { data: bugs, error: bugErr } = await supabase
+    .from('reports')
+    .select('tester_id, severity')
+    .eq('project_id', currentProjectId)
+    .gte('created_at', since)
+    .not('tester_id', 'is', null);
 
-        if (singleErr) {
-          const tc = testCases?.find((t: any) => t.id === row.test_case_id);
-          skipped.push(tc?.test_key || row.test_case_id);
-        } else if (single) {
-          created.push(single);
-        }
-      }
+  if (bugErr) return { error: bugErr.message };
 
-      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 };
+  // Aggregate per tester
+  const testerMap = new Map<string, any>();
+  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: undefined,
+  }));
+
+  // Sort
+  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 {
-    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}.`,
+    period: `${days} days`,
+    sortedBy: sortBy,
+    leaderboard,
   };
 }
 
-async function getTesterWorkload(args: {
-  tester_id: string;
+async function exportTestResults(args: {
+  test_run_id: string;
+  compact?: boolean;
+  limit?: number;
 }) {
-  if (!isValidUUID(args.tester_id)) {
-    return { error: 'Invalid tester_id format' };
+  if (!isValidUUID(args.test_run_id)) {
+    return { error: 'Invalid test_run_id format' };
   }
 
-  // Get tester info
-  const { data: tester, error: testerErr } = await supabase
-    .from('testers')
-    .select('id, name, email, status, platforms, tier')
-    .eq('id', args.tester_id)
-    .eq('project_id', PROJECT_ID)
+  // Get the test run
+  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', currentProjectId)
     .single();
 
-  if (testerErr || !tester) {
-    return { error: 'Tester not found in this project' };
+  if (runErr || !run) {
+    return { error: 'Test run not found in this project' };
   }
 
-  // Get all assignments for this tester in this project
+  // Get all assignments for this run
   const { data: assignments, error: assignErr } = await supabase
     .from('test_assignments')
     .select(`
       id,
       status,
       assigned_at,
+      started_at,
       completed_at,
-      test_case:test_cases(test_key, title, priority),
-      test_run:test_runs(name)
+      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('project_id', PROJECT_ID)
-    .eq('tester_id', args.tester_id)
-    .order('assigned_at', { ascending: false });
+    .eq('test_run_id', args.test_run_id)
+    .eq('project_id', currentProjectId)
+    .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;
+
+  const testRunInfo = {
+    id: run.id,
+    name: run.name,
+    description: run.description,
+    status: run.status,
+    startedAt: run.started_at,
+    completedAt: run.completed_at,
+    createdAt: run.created_at,
+  };
 
-  // Count by status
-  const counts: Record<string, number> = {
-    pending: 0,
-    in_progress: 0,
-    passed: 0,
-    failed: 0,
-    blocked: 0,
-    skipped: 0,
+  const summaryInfo = {
+    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,
   };
-  for (const a of all) {
-    counts[a.status] = (counts[a.status] || 0) + 1;
+
+  // Compact: return test run info + summary only, no assignments array
+  if (args.compact === true) {
+    return { testRun: testRunInfo, summary: summaryInfo };
   }
 
+  // Apply limit (default: 100, max: 500)
+  const assignmentLimit = Math.min(Math.max(args.limit ?? 100, 1), 500);
+  const limitedAssignments = all.slice(0, assignmentLimit);
+
   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: any) => ({
+    testRun: testRunInfo,
+    summary: summaryInfo,
+    assignmentsReturned: limitedAssignments.length,
+    assignmentsTotal: all.length,
+    assignments: limitedAssignments.map((a: any) => ({
       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,
-      testRun: a.test_run?.name || null,
     })),
   };
 }
 
+async function getTestingVelocity(args: {
+  days?: number;
+}) {
+  const days = Math.min(args.days || 14, 90);
+  const since = new Date(Date.now() - days * 86400000).toISOString();
+
+  const { data, error } = await supabase
+    .from('test_assignments')
+    .select('completed_at, status')
+    .eq('project_id', currentProjectId)
+    .gte('completed_at', since)
+    .in('status', ['passed', 'failed'])
+    .order('completed_at', { ascending: true });
+
+  if (error) {
+    return { error: error.message };
+  }
+
+  const completions = data || [];
+
+  // Group by day
+  const dailyCounts: Record<string, number> = {};
+  for (let i = 0; i < days; i++) {
+    const d = new Date(Date.now() - (days - 1 - i) * 86400000);
+    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] !== undefined) {
+      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;
+
+  // Trend: compare first half to second half
+  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,
+  };
+}
+
 // Main server setup
 async function main() {
   initSupabase();
@@ -5233,6 +6927,12 @@ async function main() {
     try {
       let result: unknown;
 
+      // Project management tools don't require a project to be selected
+      const projectFreeTools = ['list_projects', 'switch_project', 'get_current_project'];
+      if (!projectFreeTools.includes(name)) {
+        requireProject();
+      }
+
       switch (name) {
         case 'list_reports':
           result = await listReports(args as any);
@@ -5249,6 +6949,12 @@ async function main() {
         case 'get_report_context':
           result = await getReportContext(args as any);
           break;
+        case 'add_report_comment':
+          result = await addReportComment(args as any);
+          break;
+        case 'get_report_comments':
+          result = await getReportComments(args as any);
+          break;
         case 'get_project_info':
           result = await getProjectInfo();
           break;
@@ -5362,9 +7068,70 @@ async function main() {
         case 'assign_tests':
           result = await assignTests(args as any);
           break;
+        case 'unassign_tests':
+          result = await unassignTests(args as any);
+          break;
         case 'get_tester_workload':
           result = await getTesterWorkload(args as any);
           break;
+        // === NEW TESTER & ANALYTICS TOOLS ===
+        case 'create_tester':
+          result = await createTester(args as any);
+          break;
+        case 'update_tester':
+          result = await updateTester(args as any);
+          break;
+        case 'bulk_update_reports':
+          result = await bulkUpdateReports(args as any);
+          break;
+        case 'get_bug_trends':
+          result = await getBugTrends(args as any);
+          break;
+        case 'get_tester_leaderboard':
+          result = await getTesterLeaderboard(args as any);
+          break;
+        case 'export_test_results':
+          result = await exportTestResults(args as any);
+          break;
+        case 'get_testing_velocity':
+          result = await getTestingVelocity(args as any);
+          break;
+        // === PROJECT MANAGEMENT ===
+        case 'list_projects':
+          result = await listProjects();
+          break;
+        case 'switch_project':
+          result = await switchProject(args as any);
+          break;
+        case 'get_current_project':
+          result = getCurrentProject();
+          break;
+        // === TEST EXECUTION INTELLIGENCE ===
+        case 'get_test_impact':
+          result = await getTestImpact(args as any);
+          break;
+        case 'get_flaky_tests':
+          result = await getFlakyTests(args as any);
+          break;
+        case 'assess_test_quality':
+          result = await assessTestQuality(args as any);
+          break;
+        case 'get_test_execution_summary':
+          result = await getTestExecutionSummary(args as any);
+          break;
+        case 'check_test_freshness':
+          result = await checkTestFreshness(args as any);
+          break;
+        case 'get_untested_changes':
+          result = await getUntestedChanges(args as any);
+          break;
+        // === AUTO-MONITORING TOOLS ===
+        case 'get_auto_detected_issues':
+          result = await getAutoDetectedIssues(args as any);
+          break;
+        case 'generate_tests_from_errors':
+          result = await generateTestsFromErrors(args as any);
+          break;
         default:
           return {
             content: [{ type: 'text', text: `Unknown tool: ${name}` }],
@@ -5388,7 +7155,7 @@ async function main() {
     const { data, error } = await supabase
       .from('reports')
       .select('id, description, report_type, severity')
-      .eq('project_id', PROJECT_ID)
+      .eq('project_id', currentProjectId)
       .eq('status', 'new')
       .order('created_at', { ascending: false })
       .limit(10);