@bbearai/mcp-server 0.3.0

package/dist/index.js

@@ -0,0 +1,3577 @@
+#!/usr/bin/env node
+"use strict";
+/**
+ * BugBear MCP Server
+ * Allows Claude Code to query and manage bug reports via Model Context Protocol
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_js_1 = require("@modelcontextprotocol/sdk/server/index.js");
+const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
+const types_js_1 = require("@modelcontextprotocol/sdk/types.js");
+const supabase_js_1 = require("@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 || '';
+// Initialize Supabase client
+let supabase;
+function validateConfig() {
+    const errors = [];
+    if (!SUPABASE_ANON_KEY) {
+        errors.push('SUPABASE_ANON_KEY environment variable is required');
+    }
+    if (!PROJECT_ID) {
+        errors.push('BUGBEAR_PROJECT_ID environment variable is required');
+    }
+    // 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 (errors.length > 0) {
+        console.error('BugBear MCP Server configuration errors:');
+        errors.forEach(e => console.error(`  - ${e}`));
+        process.exit(1);
+    }
+}
+function initSupabase() {
+    validateConfig();
+    supabase = (0, supabase_js_1.createClient)(SUPABASE_URL, SUPABASE_ANON_KEY);
+}
+// Security helpers
+const UUID_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+function isValidUUID(str) {
+    return typeof str === 'string' && UUID_REGEX.test(str);
+}
+function sanitizeSearchQuery(query) {
+    if (!query)
+        return undefined;
+    // Remove characters that could cause issues in LIKE queries
+    // Supabase escapes properly but we add an extra layer
+    return query
+        .replace(/[%_\\]/g, '') // Remove LIKE wildcards and escape char
+        .slice(0, 500); // Limit length
+}
+// Tool definitions
+const tools = [
+    {
+        name: 'list_reports',
+        description: 'List recent bug reports for the project. Returns the most recent reports with their details.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                limit: {
+                    type: 'number',
+                    description: 'Maximum number of reports to return (default: 10, max: 50)',
+                },
+                status: {
+                    type: 'string',
+                    enum: ['new', 'triaging', 'confirmed', 'in_progress', 'fixed', 'resolved', 'verified', 'wont_fix', 'duplicate'],
+                    description: 'Filter by report status',
+                },
+                severity: {
+                    type: 'string',
+                    enum: ['critical', 'high', 'medium', 'low'],
+                    description: 'Filter by severity',
+                },
+                type: {
+                    type: 'string',
+                    enum: ['bug', 'test_fail', 'feedback', 'suggestion'],
+                    description: 'Filter by report type',
+                },
+            },
+        },
+    },
+    {
+        name: 'get_report',
+        description: 'Get detailed information about a specific bug report by ID',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                report_id: {
+                    type: 'string',
+                    description: 'The UUID of the report to retrieve',
+                },
+            },
+            required: ['report_id'],
+        },
+    },
+    {
+        name: 'search_reports',
+        description: 'Search bug reports by route, description, or other criteria',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                query: {
+                    type: 'string',
+                    description: 'Search query to match against report descriptions',
+                },
+                route: {
+                    type: 'string',
+                    description: 'Filter by specific route/path where the bug occurred',
+                },
+            },
+        },
+    },
+    {
+        name: 'update_report_status',
+        description: 'Update the status of a bug report',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                report_id: {
+                    type: 'string',
+                    description: 'The UUID of the report to update',
+                },
+                status: {
+                    type: 'string',
+                    enum: ['new', 'triaging', 'confirmed', 'in_progress', 'fixed', 'resolved', 'verified', 'wont_fix', 'duplicate'],
+                    description: 'The new status for the report',
+                },
+                resolution: {
+                    type: 'string',
+                    description: 'Optional resolution notes when marking as resolved',
+                },
+            },
+            required: ['report_id', 'status'],
+        },
+    },
+    {
+        name: 'get_report_context',
+        description: 'Get the full debugging context for a report including console logs, network requests, and navigation history',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                report_id: {
+                    type: 'string',
+                    description: 'The UUID of the report',
+                },
+            },
+            required: ['report_id'],
+        },
+    },
+    {
+        name: 'get_project_info',
+        description: 'Get project information including QA tracks, test case counts, and common bug patterns',
+        inputSchema: {
+            type: 'object',
+            properties: {},
+        },
+    },
+    {
+        name: 'get_qa_tracks',
+        description: 'Get all QA tracks for the project with their test templates and requirements',
+        inputSchema: {
+            type: 'object',
+            properties: {},
+        },
+    },
+    {
+        name: 'create_test_case',
+        description: 'Create a new test case in BugBear. Use this after generating test case suggestions.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                test_key: {
+                    type: 'string',
+                    description: 'Unique test case identifier (e.g., TC-001)',
+                },
+                title: {
+                    type: 'string',
+                    description: 'Brief title describing what is being tested',
+                },
+                description: {
+                    type: 'string',
+                    description: 'Detailed description of the test case',
+                },
+                track: {
+                    type: 'string',
+                    enum: ['functional', 'design', 'accessibility', 'performance', 'content', 'ux'],
+                    description: 'QA track this test belongs to',
+                },
+                priority: {
+                    type: 'string',
+                    enum: ['P0', 'P1', 'P2', 'P3'],
+                    description: 'Priority level (P0=critical, P3=low)',
+                },
+                steps: {
+                    type: 'array',
+                    description: 'Array of test steps',
+                    items: {
+                        type: 'object',
+                        properties: {
+                            stepNumber: { type: 'number' },
+                            action: { type: 'string' },
+                            expectedResult: { type: 'string' },
+                        },
+                    },
+                },
+                expected_result: {
+                    type: 'string',
+                    description: 'Overall expected outcome of the test',
+                },
+                preconditions: {
+                    type: 'string',
+                    description: 'Any setup required before running the test',
+                },
+                target_route: {
+                    type: 'string',
+                    description: 'Route/path to navigate to when starting this test (e.g., /settings/profile). This enables deep linking so testers can jump directly to the screen being tested.',
+                },
+            },
+            required: ['test_key', 'title', 'steps', 'expected_result'],
+        },
+    },
+    {
+        name: 'update_test_case',
+        description: 'Update an existing test case in BugBear. Use this to add target_route for deep linking or modify other fields.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                test_case_id: {
+                    type: 'string',
+                    description: 'The UUID of the test case to update',
+                },
+                test_key: {
+                    type: 'string',
+                    description: 'Look up test case by test_key instead of ID (e.g., TC-001)',
+                },
+                title: {
+                    type: 'string',
+                    description: 'New title for the test case',
+                },
+                description: {
+                    type: 'string',
+                    description: 'New description for the test case',
+                },
+                priority: {
+                    type: 'string',
+                    enum: ['P0', 'P1', 'P2', 'P3'],
+                    description: 'New priority level',
+                },
+                steps: {
+                    type: 'array',
+                    description: 'New array of test steps (replaces existing steps)',
+                    items: {
+                        type: 'object',
+                        properties: {
+                            stepNumber: { type: 'number' },
+                            action: { type: 'string' },
+                            expectedResult: { type: 'string' },
+                        },
+                    },
+                },
+                expected_result: {
+                    type: 'string',
+                    description: 'New expected outcome',
+                },
+                preconditions: {
+                    type: 'string',
+                    description: 'New preconditions',
+                },
+                target_route: {
+                    type: 'string',
+                    description: 'Route/path for deep linking (e.g., /settings/profile)',
+                },
+            },
+        },
+    },
+    {
+        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.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                track: {
+                    type: 'string',
+                    description: 'Optional: filter by QA track name',
+                },
+                priority: {
+                    type: 'string',
+                    enum: ['P0', 'P1', 'P2', 'P3'],
+                    description: 'Optional: filter by priority',
+                },
+                missing_target_route: {
+                    type: 'boolean',
+                    description: 'If true, only return test cases that do NOT have a target_route set (useful for backfilling)',
+                },
+                limit: {
+                    type: 'number',
+                    description: 'Max number of test cases to return (default 100)',
+                },
+                offset: {
+                    type: 'number',
+                    description: 'Offset for pagination (default 0)',
+                },
+            },
+        },
+    },
+    {
+        name: 'get_bug_patterns',
+        description: 'Get common bug patterns and hotspots for the project to help prioritize testing',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                route: {
+                    type: 'string',
+                    description: 'Optional: filter by specific route',
+                },
+            },
+        },
+    },
+    // === WRITE-BACK TOOLS FOR VIBE CODERS ===
+    {
+        name: 'create_bug_report',
+        description: 'Create a bug report directly from Claude Code. Use this when you notice issues while coding - broken functionality, potential bugs, or problems you discover during development.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                title: {
+                    type: 'string',
+                    description: 'Brief title describing the bug',
+                },
+                description: {
+                    type: 'string',
+                    description: 'Detailed description of the bug, including what you observed',
+                },
+                severity: {
+                    type: 'string',
+                    enum: ['critical', 'high', 'medium', 'low'],
+                    description: 'Bug severity level',
+                },
+                file_path: {
+                    type: 'string',
+                    description: 'File path where the bug was found (e.g., src/components/Auth.tsx)',
+                },
+                line_number: {
+                    type: 'number',
+                    description: 'Line number in the file where the issue occurs',
+                },
+                code_snippet: {
+                    type: 'string',
+                    description: 'Relevant code snippet showing the problematic code',
+                },
+                suggested_fix: {
+                    type: 'string',
+                    description: 'Your suggested fix or approach to resolve this bug',
+                },
+                related_files: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: 'Other files that may be affected or related to this bug',
+                },
+            },
+            required: ['title', 'description', 'severity'],
+        },
+    },
+    {
+        name: 'get_bugs_for_file',
+        description: 'Get all known bugs related to a specific file. Use this BEFORE editing a file to check for existing issues you should be aware of or might want to fix.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                file_path: {
+                    type: 'string',
+                    description: 'File path to check for bugs (e.g., src/components/Auth.tsx)',
+                },
+                include_resolved: {
+                    type: 'boolean',
+                    description: 'Include resolved bugs for context (default: false)',
+                },
+            },
+            required: ['file_path'],
+        },
+    },
+    {
+        name: 'mark_fixed_with_commit',
+        description: 'Mark a bug as fixed and link it to the commit that resolved it. Use this after you fix a bug to close the loop.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                report_id: {
+                    type: 'string',
+                    description: 'The UUID of the bug report to mark as fixed',
+                },
+                commit_sha: {
+                    type: 'string',
+                    description: 'Git commit SHA that contains the fix',
+                },
+                commit_message: {
+                    type: 'string',
+                    description: 'The commit message',
+                },
+                resolution_notes: {
+                    type: 'string',
+                    description: 'Notes explaining how the bug was fixed',
+                },
+                files_changed: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: 'List of files that were modified to fix this bug',
+                },
+            },
+            required: ['report_id', 'commit_sha'],
+        },
+    },
+    {
+        name: 'get_bugs_affecting_code',
+        description: 'Get bugs that might be affected by changes to specific files. Use this before pushing to understand the impact of your changes.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                file_paths: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: 'List of file paths that were changed',
+                },
+                include_related: {
+                    type: 'boolean',
+                    description: 'Include bugs in related/imported files (default: true)',
+                },
+            },
+            required: ['file_paths'],
+        },
+    },
+    {
+        name: 'link_bug_to_code',
+        description: 'Add code location information to an existing bug report. Use this to help track exactly where bugs occur.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                report_id: {
+                    type: 'string',
+                    description: 'The UUID of the bug report',
+                },
+                file_path: {
+                    type: 'string',
+                    description: 'File path where the bug occurs',
+                },
+                line_number: {
+                    type: 'number',
+                    description: 'Line number in the file',
+                },
+                code_snippet: {
+                    type: 'string',
+                    description: 'Relevant code snippet',
+                },
+                function_name: {
+                    type: 'string',
+                    description: 'Function or component name where the bug occurs',
+                },
+            },
+            required: ['report_id', 'file_path'],
+        },
+    },
+    {
+        name: 'create_regression_test',
+        description: 'Generate a regression test case from a fixed bug to prevent it from recurring. Use this after fixing a bug.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                report_id: {
+                    type: 'string',
+                    description: 'The UUID of the fixed bug report to create a test from',
+                },
+                test_type: {
+                    type: 'string',
+                    enum: ['unit', 'integration', 'e2e'],
+                    description: 'Type of test to generate',
+                },
+            },
+            required: ['report_id'],
+        },
+    },
+    // === FIX QUEUE TOOLS ===
+    {
+        name: 'get_pending_fixes',
+        description: 'Get fix requests queued from the BugBear dashboard. These are bugs that users have requested to be fixed. Check this periodically to see if there are fixes waiting for you.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                limit: {
+                    type: 'number',
+                    description: 'Maximum number of fix requests to return (default: 10)',
+                },
+                include_claimed: {
+                    type: 'boolean',
+                    description: 'Include already-claimed fix requests (default: false)',
+                },
+            },
+        },
+    },
+    {
+        name: 'claim_fix_request',
+        description: 'Claim a fix request from the queue. This marks it as being worked on so other Claude Code instances know not to pick it up.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                fix_request_id: {
+                    type: 'string',
+                    description: 'The UUID of the fix request to claim',
+                },
+                claimed_by: {
+                    type: 'string',
+                    description: 'Identifier for this Claude Code instance (e.g., hostname or session ID)',
+                },
+            },
+            required: ['fix_request_id'],
+        },
+    },
+    {
+        name: 'complete_fix_request',
+        description: 'Mark a fix request as completed after you have fixed the bug.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                fix_request_id: {
+                    type: 'string',
+                    description: 'The UUID of the fix request to complete',
+                },
+                completion_notes: {
+                    type: 'string',
+                    description: 'Notes about how the fix was implemented (e.g., commit SHA, files changed)',
+                },
+                success: {
+                    type: 'boolean',
+                    description: 'Whether the fix was successful (default: true). Set to false if you could not fix the issue.',
+                },
+            },
+            required: ['fix_request_id'],
+        },
+    },
+    {
+        name: 'analyze_changes_for_tests',
+        description: 'Analyze code changes and intelligently suggest QA tests that should be created. Call this after implementing features, fixing bugs, or making significant changes. Returns prioritized test suggestions with rationale.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                changed_files: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: 'List of files that were changed (paths)',
+                },
+                change_type: {
+                    type: 'string',
+                    enum: ['feature', 'bugfix', 'refactor', 'ui_change', 'api_change', 'config'],
+                    description: 'Type of change made',
+                },
+                change_summary: {
+                    type: 'string',
+                    description: 'Brief description of what was changed (1-2 sentences)',
+                },
+                affected_routes: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: 'Routes/screens affected by this change (e.g., /settings, /profile)',
+                },
+            },
+            required: ['changed_files', 'change_type', 'change_summary'],
+        },
+    },
+    {
+        name: 'suggest_test_cases',
+        description: 'Get AI-generated test case suggestions based on bug history and routes. Returns formatted suggestions that can be reviewed and created.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                route: {
+                    type: 'string',
+                    description: 'Route/feature to generate tests for',
+                },
+                track: {
+                    type: 'string',
+                    enum: ['functional', 'design', 'accessibility', 'performance'],
+                    description: 'QA track to focus on',
+                },
+                count: {
+                    type: 'number',
+                    description: 'Number of test cases to suggest (default: 5)',
+                },
+            },
+        },
+    },
+    // === QA INTELLIGENCE TOOLS ===
+    {
+        name: 'get_test_priorities',
+        description: 'Get routes ranked by test priority score. Returns the most urgent routes that need testing based on bug frequency, critical issues, staleness, coverage gaps, and regression risk. Use this to know WHERE to focus testing efforts.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                limit: {
+                    type: 'number',
+                    description: 'Maximum number of routes to return (default: 10)',
+                },
+                min_score: {
+                    type: 'number',
+                    description: 'Minimum priority score threshold (0-100, default: 0)',
+                },
+                include_factors: {
+                    type: 'boolean',
+                    description: 'Include detailed breakdown of priority factors (default: true)',
+                },
+            },
+        },
+    },
+    {
+        name: 'get_coverage_gaps',
+        description: 'Identify coverage gaps in QA testing. Finds untested routes, routes missing track coverage, and stale test coverage. Use this to understand what areas lack adequate testing.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                gap_type: {
+                    type: 'string',
+                    enum: ['untested_routes', 'missing_tracks', 'stale_coverage', 'all'],
+                    description: 'Type of gap to look for (default: all)',
+                },
+                stale_days: {
+                    type: 'number',
+                    description: 'Days threshold for stale coverage (default: 14)',
+                },
+            },
+        },
+    },
+    {
+        name: 'get_regressions',
+        description: 'Detect potential regressions - bugs that reappear after being resolved. Identifies routes with recurring issues and patterns. Use this to find areas prone to regression.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                days: {
+                    type: 'number',
+                    description: 'Look back period in days (default: 30)',
+                },
+                include_history: {
+                    type: 'boolean',
+                    description: 'Include full regression history (default: false)',
+                },
+            },
+        },
+    },
+    {
+        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.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                include_execution_data: {
+                    type: 'boolean',
+                    description: 'Include pass/fail rates and last execution times (default: true)',
+                },
+                include_bug_counts: {
+                    type: 'boolean',
+                    description: 'Include open/critical bug counts per route (default: true)',
+                },
+            },
+        },
+    },
+    {
+        name: 'get_stale_coverage',
+        description: 'Get routes that have not been tested within a threshold, ordered by risk (open bugs, critical bugs). Use this to find areas that need fresh testing.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                days_threshold: {
+                    type: 'number',
+                    description: 'Days without testing to consider stale (default: 14)',
+                },
+                limit: {
+                    type: 'number',
+                    description: 'Maximum routes to return (default: 20)',
+                },
+            },
+        },
+    },
+    {
+        name: 'generate_deploy_checklist',
+        description: 'Generate a pre-deployment testing checklist based on changed routes. Returns prioritized tests to run before deploying, including critical tests, recommended tests, and coverage gaps.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                routes: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: 'Routes that will be affected by the deployment',
+                },
+                changed_files: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: 'Optional: files changed to infer affected routes',
+                },
+                deployment_type: {
+                    type: 'string',
+                    enum: ['hotfix', 'feature', 'release'],
+                    description: 'Type of deployment (affects checklist thoroughness, default: feature)',
+                },
+            },
+            required: ['routes'],
+        },
+    },
+    {
+        name: 'get_qa_health',
+        description: 'Get comprehensive QA health metrics including testing velocity, bug discovery rate, resolution time, coverage, and tester activity. Returns a health score (0-100) with grade.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                period_days: {
+                    type: 'number',
+                    description: 'Analysis period in days (default: 30)',
+                },
+                compare_previous: {
+                    type: 'boolean',
+                    description: 'Include comparison with previous period (default: true)',
+                },
+            },
+        },
+    },
+];
+// Tool handlers
+async function listReports(args) {
+    let query = supabase
+        .from('reports')
+        .select('id, report_type, severity, status, description, app_context, created_at, tester:testers(name, email)')
+        .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?.currentRoute,
+            reporter: r.tester?.name || 'Anonymous',
+            created_at: r.created_at,
+        })),
+        total: data?.length || 0,
+    };
+}
+async function getReport(args) {
+    // 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,
+                email: data.tester.email,
+            } : null,
+            track: data.track ? {
+                name: data.track.name,
+                icon: data.track.icon,
+            } : null,
+        },
+    };
+}
+async function searchReports(args) {
+    const sanitizedQuery = sanitizeSearchQuery(args.query);
+    const sanitizedRoute = sanitizeSearchQuery(args.route);
+    let query = supabase
+        .from('reports')
+        .select('id, report_type, severity, status, description, app_context, created_at')
+        .eq('project_id', 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?.currentRoute;
+            return route && route.includes(sanitizedRoute);
+        });
+    }
+    return {
+        reports: results.map(r => ({
+            id: r.id,
+            type: r.report_type,
+            severity: r.severity,
+            status: r.status,
+            description: r.description,
+            route: r.app_context?.currentRoute,
+            created_at: r.created_at,
+        })),
+        total: results.length,
+    };
+}
+async function updateReportStatus(args) {
+    if (!isValidUUID(args.report_id)) {
+        return { error: 'Invalid report_id format' };
+    }
+    const updates = { status: args.status };
+    if (args.resolution) {
+        updates.resolution = args.resolution;
+    }
+    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) {
+    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 || {},
+        },
+    };
+}
+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
+        .from('test_cases')
+        .select('id', { count: 'exact', head: true })
+        .eq('project_id', PROJECT_ID);
+    // Get open bug count
+    const { count: openBugCount } = await supabase
+        .from('reports')
+        .select('id', { count: 'exact', head: true })
+        .eq('project_id', PROJECT_ID)
+        .eq('report_type', 'bug')
+        .in('status', ['new', 'confirmed', 'in_progress']);
+    return {
+        project: {
+            id: project.id,
+            name: project.name,
+            slug: project.slug,
+            qaEnabled: project.is_qa_enabled,
+        },
+        stats: {
+            tracks: tracks?.length || 0,
+            testCases: testCaseCount || 0,
+            openBugs: openBugCount || 0,
+        },
+        tracks: tracks?.map(t => ({
+            id: t.id,
+            name: t.name,
+            icon: t.icon,
+            template: t.test_template,
+        })) || [],
+    };
+}
+async function getQaTracks() {
+    const { data, error } = await supabase
+        .from('qa_tracks')
+        .select('*')
+        .eq('project_id', PROJECT_ID)
+        .order('sort_order');
+    if (error) {
+        return { error: error.message };
+    }
+    return {
+        tracks: data?.map(t => ({
+            id: t.id,
+            name: t.name,
+            slug: t.slug,
+            icon: t.icon,
+            color: t.color,
+            testTemplate: t.test_template,
+            description: t.description,
+            requiresCertification: t.requires_certification,
+            evaluationCriteria: t.evaluation_criteria,
+        })) || [],
+    };
+}
+async function createTestCase(args) {
+    // Find track ID if track name provided
+    let trackId = null;
+    if (args.track) {
+        const { data: trackData } = await supabase
+            .from('qa_tracks')
+            .select('id')
+            .eq('project_id', PROJECT_ID)
+            .ilike('name', `%${args.track}%`)
+            .single();
+        trackId = trackData?.id || null;
+    }
+    const testCase = {
+        project_id: PROJECT_ID,
+        test_key: args.test_key,
+        title: args.title,
+        description: args.description || '',
+        track_id: trackId,
+        priority: args.priority || 'P2',
+        steps: args.steps,
+        expected_result: args.expected_result,
+        preconditions: args.preconditions || '',
+        target_route: args.target_route || null,
+    };
+    const { data, error } = await supabase
+        .from('test_cases')
+        .insert(testCase)
+        .select('id, test_key, title')
+        .single();
+    if (error) {
+        return { error: error.message };
+    }
+    return {
+        success: true,
+        testCase: {
+            id: data.id,
+            testKey: data.test_key,
+            title: data.title,
+        },
+        message: `Test case ${data.test_key} created successfully`,
+    };
+}
+async function updateTestCase(args) {
+    // Need either test_case_id or test_key
+    if (!args.test_case_id && !args.test_key) {
+        return { error: 'Must provide either test_case_id or test_key to identify the test case' };
+    }
+    // Find the test case
+    let testCaseId = args.test_case_id;
+    if (!testCaseId && args.test_key) {
+        const { data: existing } = await supabase
+            .from('test_cases')
+            .select('id')
+            .eq('project_id', PROJECT_ID)
+            .eq('test_key', args.test_key)
+            .single();
+        if (!existing) {
+            return { error: `Test case with key ${args.test_key} not found` };
+        }
+        testCaseId = existing.id;
+    }
+    // Build update object with only provided fields
+    const updates = {};
+    if (args.title !== undefined)
+        updates.title = args.title;
+    if (args.description !== undefined)
+        updates.description = args.description;
+    if (args.priority !== undefined)
+        updates.priority = args.priority;
+    if (args.steps !== undefined)
+        updates.steps = args.steps;
+    if (args.expected_result !== undefined)
+        updates.expected_result = args.expected_result;
+    if (args.preconditions !== undefined)
+        updates.preconditions = args.preconditions;
+    if (args.target_route !== undefined)
+        updates.target_route = args.target_route;
+    if (Object.keys(updates).length === 0) {
+        return { error: 'No fields to update' };
+    }
+    const { data, error } = await supabase
+        .from('test_cases')
+        .update(updates)
+        .eq('id', testCaseId)
+        .eq('project_id', PROJECT_ID)
+        .select('id, test_key, title, target_route')
+        .single();
+    if (error) {
+        return { error: error.message };
+    }
+    return {
+        success: true,
+        testCase: {
+            id: data.id,
+            testKey: data.test_key,
+            title: data.title,
+            targetRoute: data.target_route,
+        },
+        message: `Test case ${data.test_key} updated successfully`,
+        updatedFields: Object.keys(updates),
+    };
+}
+async function listTestCases(args) {
+    let query = supabase
+        .from('test_cases')
+        .select(`
+      id,
+      test_key,
+      title,
+      description,
+      priority,
+      target_route,
+      preconditions,
+      expected_result,
+      steps,
+      track:qa_tracks(id, name, icon, color)
+    `)
+        .eq('project_id', PROJECT_ID)
+        .order('test_key', { ascending: true });
+    // Apply filters
+    if (args.priority) {
+        query = query.eq('priority', args.priority);
+    }
+    if (args.missing_target_route) {
+        query = query.is('target_route', null);
+    }
+    // Pagination
+    const limit = args.limit || 100;
+    const offset = args.offset || 0;
+    query = query.range(offset, offset + limit - 1);
+    const { data, error } = await query;
+    if (error) {
+        return { error: error.message };
+    }
+    // Filter by track name if provided (post-query since it's a joined field)
+    let testCases = data || [];
+    if (args.track) {
+        testCases = testCases.filter((tc) => tc.track?.name?.toLowerCase().includes(args.track.toLowerCase()));
+    }
+    return {
+        count: testCases.length,
+        testCases: testCases.map((tc) => ({
+            id: tc.id,
+            testKey: tc.test_key,
+            title: tc.title,
+            description: tc.description,
+            priority: tc.priority,
+            targetRoute: tc.target_route,
+            hasTargetRoute: !!tc.target_route,
+            track: tc.track?.name || null,
+            stepsCount: tc.steps?.length || 0,
+        })),
+        pagination: {
+            limit,
+            offset,
+            hasMore: testCases.length === limit,
+        },
+    };
+}
+async function getBugPatterns(args) {
+    // Get bugs grouped by route
+    let query = supabase
+        .from('reports')
+        .select('app_context, severity, status, created_at')
+        .eq('project_id', PROJECT_ID)
+        .eq('report_type', 'bug')
+        .order('created_at', { ascending: false })
+        .limit(100);
+    const { data: bugs, error } = await query;
+    if (error) {
+        return { error: error.message };
+    }
+    // Analyze patterns
+    const routePatterns = {};
+    for (const bug of bugs || []) {
+        const route = bug.app_context?.currentRoute || 'unknown';
+        // Filter by route if specified
+        if (args.route && !route.includes(args.route))
+            continue;
+        if (!routePatterns[route]) {
+            routePatterns[route] = { total: 0, critical: 0, open: 0, resolved: 0 };
+        }
+        routePatterns[route].total++;
+        if (bug.severity === 'critical' || bug.severity === 'high') {
+            routePatterns[route].critical++;
+        }
+        if (['new', 'confirmed', 'in_progress'].includes(bug.status)) {
+            routePatterns[route].open++;
+        }
+        else {
+            routePatterns[route].resolved++;
+        }
+    }
+    // Sort by total bugs descending
+    const hotspots = Object.entries(routePatterns)
+        .map(([route, stats]) => ({ route, ...stats }))
+        .sort((a, b) => b.total - a.total)
+        .slice(0, 10);
+    return {
+        hotspots,
+        summary: {
+            totalRoutes: Object.keys(routePatterns).length,
+            totalBugs: bugs?.length || 0,
+            criticalRoutes: hotspots.filter(h => h.critical > 0).length,
+        },
+        recommendations: hotspots
+            .filter(h => h.open > 0)
+            .map(h => `Route "${h.route}" has ${h.open} open bugs - prioritize testing here`),
+    };
+}
+async function suggestTestCases(args) {
+    const count = args.count || 5;
+    // Get existing test cases to avoid duplicates
+    const { data: existingTests } = await supabase
+        .from('test_cases')
+        .select('test_key, title')
+        .eq('project_id', PROJECT_ID)
+        .order('test_key', { ascending: false })
+        .limit(1);
+    // Calculate next test key number
+    const lastKey = existingTests?.[0]?.test_key || 'TC-000';
+    const lastNum = parseInt(lastKey.replace('TC-', '')) || 0;
+    // Get bug patterns for context
+    const patterns = await getBugPatterns({ route: args.route });
+    // Generate suggestions based on track
+    const suggestions = [];
+    const track = args.track || 'functional';
+    const route = args.route || '/';
+    // Template suggestions based on track type
+    const templates = getTrackTemplates(track);
+    for (let i = 0; i < count; i++) {
+        const keyNum = lastNum + i + 1;
+        const template = templates[i % templates.length];
+        suggestions.push({
+            test_key: `TC-${String(keyNum).padStart(3, '0')}`,
+            title: template.title.replace('{route}', route),
+            description: template.description.replace('{route}', route),
+            track,
+            priority: i === 0 ? 'P1' : 'P2',
+            steps: template.steps.map((s, idx) => ({
+                stepNumber: idx + 1,
+                action: s.action.replace('{route}', route),
+                expectedResult: s.expectedResult.replace('{route}', route),
+            })),
+            expected_result: template.expected_result.replace('{route}', route),
+        });
+    }
+    // Get related bugs for historical context
+    const { data: relatedBugs } = await supabase
+        .from('reports')
+        .select('id, description, severity')
+        .eq('project_id', PROJECT_ID)
+        .eq('report_type', 'bug')
+        .limit(10);
+    const routeBugs = (relatedBugs || []).filter(bug => {
+        // In a real impl, would filter by route match
+        return true;
+    }).slice(0, 5);
+    return {
+        suggestions,
+        context: {
+            route: args.route || 'all',
+            track,
+            bugHotspots: patterns.hotspots?.slice(0, 3) || [],
+        },
+        historicalContext: {
+            relatedBugs: routeBugs.map(b => ({
+                id: b.id,
+                description: b.description.slice(0, 100),
+                severity: b.severity,
+            })),
+            recommendation: routeBugs.length > 0
+                ? `These test suggestions are informed by ${routeBugs.length} historical bug(s) in this area.`
+                : 'No historical bugs found for this route.',
+        },
+        instructions: `Review these suggestions and use create_test_case to add them to BugBear.
+You can modify the suggestions before creating them.`,
+    };
+}
+// === QA INTELLIGENCE TOOL HANDLERS ===
+async function getTestPriorities(args) {
+    const limit = args.limit || 10;
+    const minScore = args.min_score || 0;
+    const includeFactors = args.include_factors !== false;
+    // First, refresh the route stats
+    await supabase.rpc('refresh_route_test_stats', { p_project_id: PROJECT_ID });
+    // Get prioritized routes
+    const { data: routes, error } = await supabase
+        .from('route_test_stats')
+        .select('*')
+        .eq('project_id', PROJECT_ID)
+        .gte('priority_score', minScore)
+        .order('priority_score', { ascending: false })
+        .limit(limit);
+    if (error) {
+        return { error: error.message };
+    }
+    if (!routes || routes.length === 0) {
+        return {
+            priorities: [],
+            summary: { totalRoutes: 0, criticalCount: 0, highCount: 0, mediumCount: 0 },
+            guidance: 'No routes found with test data. Start by creating test cases and running tests.',
+        };
+    }
+    // Calculate urgency levels
+    const getUrgency = (score) => {
+        if (score >= 70)
+            return 'critical';
+        if (score >= 50)
+            return 'high';
+        if (score >= 30)
+            return 'medium';
+        return 'low';
+    };
+    const getRecommendation = (route) => {
+        if (route.critical_bugs > 0) {
+            return `Critical bugs exist - prioritize immediate testing and bug fixes`;
+        }
+        if (route.open_bugs >= 3) {
+            return `Multiple open bugs (${route.open_bugs}) - comprehensive testing needed`;
+        }
+        if (route.last_tested_at === null) {
+            return `Never tested - establish baseline coverage`;
+        }
+        const daysSinceTest = route.last_tested_at
+            ? Math.floor((Date.now() - new Date(route.last_tested_at).getTime()) / (1000 * 60 * 60 * 24))
+            : null;
+        if (daysSinceTest && daysSinceTest > 14) {
+            return `Stale coverage (${daysSinceTest} days) - refresh testing`;
+        }
+        if (route.regression_count > 0) {
+            return `Regression risk (${route.regression_count} past regressions) - add regression tests`;
+        }
+        if (route.test_case_count < 3) {
+            return `Low test coverage (${route.test_case_count} tests) - add more test cases`;
+        }
+        return 'Maintain current testing cadence';
+    };
+    const priorities = routes.map((route, idx) => {
+        const daysSinceTest = route.last_tested_at
+            ? Math.floor((Date.now() - new Date(route.last_tested_at).getTime()) / (1000 * 60 * 60 * 24))
+            : null;
+        const priority = {
+            rank: idx + 1,
+            route: route.route,
+            priorityScore: route.priority_score,
+            urgency: getUrgency(route.priority_score),
+            stats: {
+                openBugs: route.open_bugs,
+                criticalBugs: route.critical_bugs,
+                highBugs: route.high_bugs,
+                testCases: route.test_case_count,
+                daysSinceTest,
+                regressions: route.regression_count,
+                recentBugs: route.bugs_last_7_days,
+            },
+            recommendation: getRecommendation(route),
+        };
+        if (includeFactors) {
+            // Calculate factor breakdown
+            const bugFreqScore = Math.min(route.open_bugs * 5, 30);
+            const criticalScore = Math.min(route.critical_bugs * 25 + route.high_bugs * 10, 25);
+            const stalenessScore = daysSinceTest === null ? 20 : Math.min(daysSinceTest, 20);
+            const coverageScore = Math.max(15 - route.test_case_count * 5, 0);
+            const regressionScore = Math.min(route.regression_count * 10, 10);
+            priority.factors = {
+                bugFrequency: { score: bugFreqScore, openBugs: route.open_bugs, bugs7d: route.bugs_last_7_days },
+                criticalSeverity: { score: criticalScore, critical: route.critical_bugs, high: route.high_bugs },
+                staleness: { score: stalenessScore, daysSinceTest },
+                coverageGap: { score: coverageScore, testCount: route.test_case_count },
+                regressionRisk: { score: regressionScore, regressionCount: route.regression_count },
+            };
+        }
+        return priority;
+    });
+    const criticalCount = priorities.filter(p => p.urgency === 'critical').length;
+    const highCount = priorities.filter(p => p.urgency === 'high').length;
+    const mediumCount = priorities.filter(p => p.urgency === 'medium').length;
+    let guidance = '';
+    if (criticalCount > 0) {
+        guidance = `URGENT: ${criticalCount} route(s) need immediate attention. Focus on critical bugs and untested areas first.`;
+    }
+    else if (highCount > 0) {
+        guidance = `${highCount} route(s) have high priority. Schedule testing sessions to address coverage gaps.`;
+    }
+    else {
+        guidance = 'QA coverage is in good shape. Maintain regular testing cadence.';
+    }
+    return {
+        priorities,
+        summary: {
+            totalRoutes: routes.length,
+            criticalCount,
+            highCount,
+            mediumCount,
+        },
+        guidance,
+    };
+}
+async function getCoverageGaps(args) {
+    const gapType = args.gap_type || 'all';
+    const staleDays = args.stale_days || 14;
+    const gaps = { untested: [], missingTracks: [], stale: [] };
+    // Get all routes from reports
+    const { data: routesFromReports } = await supabase
+        .from('reports')
+        .select('app_context')
+        .eq('project_id', PROJECT_ID)
+        .not('app_context->currentRoute', 'is', null);
+    const allRoutes = new Set();
+    (routesFromReports || []).forEach(r => {
+        const route = r.app_context?.currentRoute;
+        if (route)
+            allRoutes.add(route);
+    });
+    // Get test coverage data
+    const { data: testCases } = await supabase
+        .from('test_cases')
+        .select('target_route, category, track_id')
+        .eq('project_id', PROJECT_ID);
+    const coveredRoutes = new Set();
+    const routeTrackCoverage = {};
+    (testCases || []).forEach(tc => {
+        const route = tc.target_route || tc.category;
+        if (route) {
+            coveredRoutes.add(route);
+            if (!routeTrackCoverage[route])
+                routeTrackCoverage[route] = new Set();
+            if (tc.track_id)
+                routeTrackCoverage[route].add(tc.track_id);
+        }
+    });
+    // Get all tracks
+    const { data: tracks } = await supabase
+        .from('qa_tracks')
+        .select('id, name')
+        .eq('project_id', PROJECT_ID);
+    const trackMap = new Map((tracks || []).map(t => [t.id, t.name]));
+    // Get route stats for staleness
+    const { data: routeStats } = await supabase
+        .from('route_test_stats')
+        .select('route, last_tested_at, open_bugs, critical_bugs')
+        .eq('project_id', PROJECT_ID);
+    const routeStatsMap = new Map((routeStats || []).map(r => [r.route, r]));
+    // Find untested routes
+    if (gapType === 'all' || gapType === 'untested_routes') {
+        allRoutes.forEach(route => {
+            if (!coveredRoutes.has(route)) {
+                const stats = routeStatsMap.get(route);
+                const severity = (stats?.critical_bugs || 0) > 0 ? 'critical' :
+                    (stats?.open_bugs || 0) > 2 ? 'high' : 'medium';
+                gaps.untested.push({
+                    route,
+                    severity,
+                    type: 'untested',
+                    details: {
+                        openBugs: stats?.open_bugs || 0,
+                        criticalBugs: stats?.critical_bugs || 0,
+                    },
+                    recommendation: `Create test cases for ${route} - this route has bugs but no test coverage.`,
+                });
+            }
+        });
+        gaps.untested.sort((a, b) => {
+            const severityOrder = { critical: 0, high: 1, medium: 2 };
+            return severityOrder[a.severity] - severityOrder[b.severity];
+        });
+    }
+    // Find missing track coverage
+    if (gapType === 'all' || gapType === 'missing_tracks') {
+        coveredRoutes.forEach(route => {
+            const coveredTracks = routeTrackCoverage[route] || new Set();
+            const missingTracks = [];
+            trackMap.forEach((name, id) => {
+                if (!coveredTracks.has(id)) {
+                    missingTracks.push(name);
+                }
+            });
+            if (missingTracks.length > 0 && missingTracks.length < trackMap.size) {
+                const stats = routeStatsMap.get(route);
+                gaps.missingTracks.push({
+                    route,
+                    severity: missingTracks.length > trackMap.size / 2 ? 'high' : 'medium',
+                    type: 'missing_tracks',
+                    details: { missingTracks },
+                    recommendation: `Add tests for tracks: ${missingTracks.join(', ')}`,
+                });
+            }
+        });
+    }
+    // Find stale coverage
+    if (gapType === 'all' || gapType === 'stale_coverage') {
+        (routeStats || []).forEach(stat => {
+            if (stat.last_tested_at) {
+                const daysSince = Math.floor((Date.now() - new Date(stat.last_tested_at).getTime()) / (1000 * 60 * 60 * 24));
+                if (daysSince >= staleDays) {
+                    gaps.stale.push({
+                        route: stat.route,
+                        severity: daysSince >= staleDays * 2 ? 'high' : 'medium',
+                        type: 'stale',
+                        details: {
+                            daysSinceTest: daysSince,
+                            openBugs: stat.open_bugs,
+                            criticalBugs: stat.critical_bugs,
+                        },
+                        recommendation: `Re-run tests for ${stat.route} - last tested ${daysSince} days ago`,
+                    });
+                }
+            }
+        });
+        gaps.stale.sort((a, b) => (b.details.daysSinceTest || 0) - (a.details.daysSinceTest || 0));
+    }
+    const recommendations = [];
+    if (gaps.untested.length > 0) {
+        recommendations.push(`${gaps.untested.length} route(s) have bugs but no test coverage - create tests immediately`);
+    }
+    if (gaps.missingTracks.length > 0) {
+        recommendations.push(`${gaps.missingTracks.length} route(s) are missing track-specific tests`);
+    }
+    if (gaps.stale.length > 0) {
+        recommendations.push(`${gaps.stale.length} route(s) have stale coverage (>${staleDays} days) - refresh testing`);
+    }
+    return {
+        gaps,
+        summary: {
+            untestedRoutes: gaps.untested.length,
+            routesMissingTracks: gaps.missingTracks.length,
+            staleRoutes: gaps.stale.length,
+        },
+        recommendations,
+    };
+}
+async function getRegressions(args) {
+    const days = args.days || 30;
+    const includeHistory = args.include_history || false;
+    // Find potential regressions: routes with resolved bugs that have new bugs
+    const { data: resolvedBugs } = await supabase
+        .from('reports')
+        .select('id, description, severity, app_context, resolved_at')
+        .eq('project_id', PROJECT_ID)
+        .eq('report_type', 'bug')
+        .in('status', ['resolved', 'fixed', 'verified', 'closed'])
+        .gte('resolved_at', new Date(Date.now() - days * 24 * 60 * 60 * 1000).toISOString());
+    const { data: newBugs } = await supabase
+        .from('reports')
+        .select('id, description, severity, app_context, created_at')
+        .eq('project_id', PROJECT_ID)
+        .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());
+    // Group by route
+    const routeData = {};
+    (resolvedBugs || []).forEach(bug => {
+        const route = bug.app_context?.currentRoute;
+        if (route) {
+            if (!routeData[route])
+                routeData[route] = { resolved: [], new: [] };
+            routeData[route].resolved.push(bug);
+        }
+    });
+    (newBugs || []).forEach(bug => {
+        const route = bug.app_context?.currentRoute;
+        if (route) {
+            if (!routeData[route])
+                routeData[route] = { resolved: [], new: [] };
+            routeData[route].new.push(bug);
+        }
+    });
+    // Find routes with both resolved and new bugs (potential regressions)
+    const regressions = [];
+    let criticalCount = 0;
+    const recurringPatterns = [];
+    Object.entries(routeData).forEach(([route, data]) => {
+        if (data.resolved.length > 0 && data.new.length > 0) {
+            // This is a potential regression
+            const latestResolved = data.resolved.sort((a, b) => new Date(b.resolved_at).getTime() - new Date(a.resolved_at).getTime())[0];
+            const daysSinceResolution = latestResolved.resolved_at
+                ? Math.floor((Date.now() - new Date(latestResolved.resolved_at).getTime()) / (1000 * 60 * 60 * 24))
+                : null;
+            const severity = data.new.some(b => b.severity === 'critical') ? 'critical' :
+                data.new.some(b => b.severity === 'high') ? 'high' : 'medium';
+            if (severity === 'critical')
+                criticalCount++;
+            if (data.resolved.length >= 2 && data.new.length >= 2) {
+                recurringPatterns.push(route);
+            }
+            const regression = {
+                route,
+                severity,
+                originalBug: {
+                    id: latestResolved.id,
+                    description: latestResolved.description?.slice(0, 100) || '',
+                    resolvedAt: latestResolved.resolved_at,
+                },
+                newBugs: data.new.map(b => ({
+                    id: b.id,
+                    description: b.description?.slice(0, 100) || '',
+                    severity: b.severity,
+                    createdAt: b.created_at,
+                })),
+                daysSinceResolution,
+                regressionCount: data.resolved.length,
+            };
+            if (includeHistory) {
+                regression.history = {
+                    totalResolved: data.resolved.length,
+                    totalNew: data.new.length,
+                    resolvedBugs: data.resolved.map(b => ({
+                        id: b.id,
+                        severity: b.severity,
+                        resolvedAt: b.resolved_at,
+                    })),
+                };
+            }
+            regressions.push(regression);
+        }
+    });
+    // Sort by severity and count
+    regressions.sort((a, b) => {
+        const severityOrder = { critical: 0, high: 1, medium: 2 };
+        return (severityOrder[a.severity] - severityOrder[b.severity]) ||
+            (b.newBugs.length - a.newBugs.length);
+    });
+    const recommendations = [];
+    if (criticalCount > 0) {
+        recommendations.push(`URGENT: ${criticalCount} regression(s) involve critical bugs - investigate immediately`);
+    }
+    if (recurringPatterns.length > 0) {
+        recommendations.push(`Recurring patterns in ${recurringPatterns.length} route(s): ${recurringPatterns.slice(0, 3).join(', ')} - consider architectural review`);
+    }
+    if (regressions.length > 0) {
+        recommendations.push('Add regression tests to prevent recurrence - use create_regression_test');
+    }
+    return {
+        regressions,
+        summary: {
+            totalRegressions: regressions.length,
+            criticalRegressions: criticalCount,
+            recurringPatterns: recurringPatterns.length,
+        },
+        recommendations,
+    };
+}
+async function getCoverageMatrix(args) {
+    const includeExecution = args.include_execution_data !== false;
+    const includeBugs = args.include_bug_counts !== false;
+    // Get tracks
+    const { data: tracks } = await supabase
+        .from('qa_tracks')
+        .select('id, name, icon, color')
+        .eq('project_id', PROJECT_ID)
+        .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);
+    // Get test assignments for execution data
+    let assignments = [];
+    if (includeExecution) {
+        const { data } = await supabase
+            .from('test_assignments')
+            .select('test_case_id, status, completed_at')
+            .eq('project_id', PROJECT_ID)
+            .in('status', ['passed', 'failed']);
+        assignments = data || [];
+    }
+    // Get route stats for bug counts
+    let routeStats = [];
+    if (includeBugs) {
+        const { data } = await supabase
+            .from('route_test_stats')
+            .select('route, open_bugs, critical_bugs')
+            .eq('project_id', PROJECT_ID);
+        routeStats = data || [];
+    }
+    const routeStatsMap = new Map(routeStats.map(r => [r.route, r]));
+    // Build assignment map
+    const assignmentsByTestCase = {};
+    assignments.forEach(a => {
+        if (!assignmentsByTestCase[a.test_case_id]) {
+            assignmentsByTestCase[a.test_case_id] = { passed: 0, failed: 0, lastTested: null };
+        }
+        if (a.status === 'passed')
+            assignmentsByTestCase[a.test_case_id].passed++;
+        if (a.status === 'failed')
+            assignmentsByTestCase[a.test_case_id].failed++;
+        if (a.completed_at) {
+            const current = assignmentsByTestCase[a.test_case_id].lastTested;
+            if (!current || new Date(a.completed_at) > new Date(current)) {
+                assignmentsByTestCase[a.test_case_id].lastTested = a.completed_at;
+            }
+        }
+    });
+    // Group test cases by route
+    const routeMap = {};
+    (testCases || []).forEach(tc => {
+        const route = tc.target_route || tc.category || 'Uncategorized';
+        if (!routeMap[route]) {
+            routeMap[route] = { testCases: [], trackCoverage: {} };
+        }
+        routeMap[route].testCases.push(tc);
+        const trackId = tc.track_id || 'none';
+        if (!routeMap[route].trackCoverage[trackId]) {
+            routeMap[route].trackCoverage[trackId] = [];
+        }
+        routeMap[route].trackCoverage[trackId].push(tc);
+    });
+    // Build matrix
+    const matrix = [];
+    const now = Date.now();
+    Object.entries(routeMap).forEach(([route, data]) => {
+        const row = {
+            route,
+            totalTests: data.testCases.length,
+            tracks: {},
+        };
+        if (includeBugs) {
+            const stats = routeStatsMap.get(route);
+            row.openBugs = stats?.open_bugs || 0;
+            row.criticalBugs = stats?.critical_bugs || 0;
+        }
+        // Calculate overall last tested
+        let latestTest = null;
+        data.testCases.forEach(tc => {
+            const execData = assignmentsByTestCase[tc.id];
+            if (execData?.lastTested) {
+                if (!latestTest || new Date(execData.lastTested) > new Date(latestTest)) {
+                    latestTest = execData.lastTested;
+                }
+            }
+        });
+        row.lastTestedAt = latestTest;
+        // Build track cells
+        (tracks || []).forEach(track => {
+            const trackTests = data.trackCoverage[track.id] || [];
+            const cell = {
+                testCount: trackTests.length,
+            };
+            if (includeExecution && trackTests.length > 0) {
+                let passCount = 0;
+                let failCount = 0;
+                let trackLastTested = null;
+                trackTests.forEach(tc => {
+                    const execData = assignmentsByTestCase[tc.id];
+                    if (execData) {
+                        passCount += execData.passed;
+                        failCount += execData.failed;
+                        if (execData.lastTested) {
+                            if (!trackLastTested || new Date(execData.lastTested) > new Date(trackLastTested)) {
+                                trackLastTested = execData.lastTested;
+                            }
+                        }
+                    }
+                });
+                cell.passCount = passCount;
+                cell.failCount = failCount;
+                cell.passRate = passCount + failCount > 0
+                    ? Math.round((passCount / (passCount + failCount)) * 100)
+                    : null;
+                cell.lastTestedAt = trackLastTested;
+                cell.staleDays = trackLastTested
+                    ? Math.floor((now - new Date(trackLastTested).getTime()) / (1000 * 60 * 60 * 24))
+                    : null;
+            }
+            row.tracks[track.id] = cell;
+        });
+        // Add "none" track for unassigned tests
+        const unassignedTests = data.trackCoverage['none'] || [];
+        if (unassignedTests.length > 0) {
+            const cell = { testCount: unassignedTests.length };
+            if (includeExecution) {
+                let passCount = 0;
+                let failCount = 0;
+                unassignedTests.forEach(tc => {
+                    const execData = assignmentsByTestCase[tc.id];
+                    if (execData) {
+                        passCount += execData.passed;
+                        failCount += execData.failed;
+                    }
+                });
+                cell.passCount = passCount;
+                cell.failCount = failCount;
+                cell.passRate = passCount + failCount > 0
+                    ? Math.round((passCount / (passCount + failCount)) * 100)
+                    : null;
+            }
+            row.tracks['none'] = cell;
+        }
+        matrix.push(row);
+    });
+    // Sort by route name
+    matrix.sort((a, b) => a.route.localeCompare(b.route));
+    return {
+        matrix,
+        tracks: (tracks || []).map(t => ({
+            id: t.id,
+            name: t.name,
+            icon: t.icon,
+            color: t.color,
+        })),
+        summary: {
+            totalRoutes: matrix.length,
+            totalTests: matrix.reduce((sum, r) => sum + r.totalTests, 0),
+            routesWithCriticalBugs: includeBugs ? matrix.filter(r => r.criticalBugs > 0).length : undefined,
+        },
+    };
+}
+async function getStaleCoverage(args) {
+    const daysThreshold = args.days_threshold || 14;
+    const limit = args.limit || 20;
+    // Refresh stats first
+    await supabase.rpc('refresh_route_test_stats', { p_project_id: PROJECT_ID });
+    // Get routes ordered by staleness and risk
+    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)
+        .order('last_tested_at', { ascending: true, nullsFirst: true })
+        .limit(limit * 2); // Get extra to filter
+    if (error) {
+        return { error: error.message };
+    }
+    const now = Date.now();
+    const staleRoutes = [];
+    (routes || []).forEach(route => {
+        let daysSinceTest = null;
+        if (route.last_tested_at) {
+            daysSinceTest = Math.floor((now - new Date(route.last_tested_at).getTime()) / (1000 * 60 * 60 * 24));
+            if (daysSinceTest < daysThreshold)
+                return; // Not stale
+        }
+        const riskLevel = route.critical_bugs > 0 ? 'critical' :
+            route.open_bugs > 2 ? 'high' :
+                daysSinceTest === null ? 'high' : 'medium';
+        staleRoutes.push({
+            route: route.route,
+            daysSinceTest,
+            neverTested: route.last_tested_at === null,
+            lastTestedAt: route.last_tested_at,
+            openBugs: route.open_bugs,
+            criticalBugs: route.critical_bugs,
+            testCaseCount: route.test_case_count,
+            riskLevel,
+            priorityScore: route.priority_score,
+            recommendation: route.last_tested_at === null
+                ? 'Never tested - establish baseline coverage immediately'
+                : `Last tested ${daysSinceTest} days ago - refresh testing`,
+        });
+    });
+    // Sort by risk then staleness
+    staleRoutes.sort((a, b) => {
+        const riskOrder = { critical: 0, high: 1, medium: 2 };
+        const riskDiff = riskOrder[a.riskLevel] - riskOrder[b.riskLevel];
+        if (riskDiff !== 0)
+            return riskDiff;
+        if (a.neverTested && !b.neverTested)
+            return -1;
+        if (!a.neverTested && b.neverTested)
+            return 1;
+        return (b.daysSinceTest || 999) - (a.daysSinceTest || 999);
+    });
+    return {
+        staleRoutes: staleRoutes.slice(0, limit),
+        summary: {
+            totalStale: staleRoutes.length,
+            neverTested: staleRoutes.filter(r => r.neverTested).length,
+            withCriticalBugs: staleRoutes.filter(r => r.criticalBugs > 0).length,
+            threshold: daysThreshold,
+        },
+        guidance: staleRoutes.length > 0
+            ? `${staleRoutes.length} route(s) have stale or missing test coverage. Prioritize routes with critical bugs first.`
+            : 'All routes have been tested within the threshold period.',
+    };
+}
+async function generateDeployChecklist(args) {
+    const routes = args.routes;
+    const deploymentType = args.deployment_type || 'feature';
+    // Infer additional routes from changed files
+    const allRoutes = new Set(routes);
+    if (args.changed_files) {
+        args.changed_files.forEach(file => {
+            // Extract route from common patterns
+            const matches = [
+                /\/app\/(.+?)\/page\./,
+                /\/pages\/(.+?)\./,
+                /\/routes\/(.+?)\./,
+                /\/screens\/(.+?)\./,
+            ];
+            for (const pattern of matches) {
+                const match = file.match(pattern);
+                if (match) {
+                    allRoutes.add('/' + match[1].replace(/\[.*?\]/g, ':id'));
+                }
+            }
+        });
+    }
+    // Get test cases for these routes
+    const { data: testCases } = await supabase
+        .from('test_cases')
+        .select('id, test_key, title, target_route, category, priority, track:qa_tracks(name)')
+        .eq('project_id', PROJECT_ID)
+        .or(routes.map(r => `target_route.eq.${r}`).join(',') + ',' + routes.map(r => `category.eq.${r}`).join(','));
+    // Get route stats for risk assessment
+    const { data: routeStats } = await supabase
+        .from('route_test_stats')
+        .select('*')
+        .eq('project_id', PROJECT_ID)
+        .in('route', Array.from(allRoutes));
+    const routeStatsMap = new Map((routeStats || []).map(r => [r.route, r]));
+    // Categorize tests
+    const checklist = { critical: [], recommended: [], optional: [], gaps: [] };
+    // Track covered routes
+    const coveredRoutes = new Set();
+    (testCases || []).forEach(tc => {
+        const route = tc.target_route || tc.category || '';
+        coveredRoutes.add(route);
+        const stats = routeStatsMap.get(route);
+        const item = {
+            testCaseId: tc.id,
+            testKey: tc.test_key,
+            title: tc.title,
+            route,
+            track: tc.track?.name,
+            priority: tc.priority,
+            hasCriticalBugs: (stats?.critical_bugs || 0) > 0,
+            lastTested: stats?.last_tested_at,
+            reason: '',
+        };
+        // Categorize based on priority and context
+        if (tc.priority === 'P0' || (stats?.critical_bugs || 0) > 0) {
+            item.reason = tc.priority === 'P0'
+                ? 'P0 priority test case'
+                : `Route has ${stats?.critical_bugs} critical bug(s)`;
+            checklist.critical.push(item);
+        }
+        else if (tc.priority === 'P1' || deploymentType === 'hotfix') {
+            item.reason = deploymentType === 'hotfix'
+                ? 'Hotfix deployment - verify fix'
+                : 'P1 priority test case';
+            checklist.recommended.push(item);
+        }
+        else if (deploymentType === 'release') {
+            item.reason = 'Release deployment - full verification';
+            checklist.recommended.push(item);
+        }
+        else {
+            item.reason = 'Standard test coverage';
+            checklist.optional.push(item);
+        }
+    });
+    // Find coverage gaps
+    allRoutes.forEach(route => {
+        if (!coveredRoutes.has(route)) {
+            const stats = routeStatsMap.get(route);
+            checklist.gaps.push({
+                route,
+                title: `No test coverage for ${route}`,
+                reason: 'Route is being deployed but has no test cases',
+                hasCriticalBugs: (stats?.critical_bugs || 0) > 0,
+                openBugs: stats?.open_bugs || 0,
+                recommendation: `Create test cases for ${route} before deploying`,
+            });
+        }
+    });
+    // Calculate thoroughness
+    const totalTests = checklist.critical.length + checklist.recommended.length + checklist.optional.length;
+    const thoroughness = allRoutes.size > 0
+        ? Math.round((coveredRoutes.size / allRoutes.size) * 100)
+        : 100;
+    let guidance = '';
+    if (checklist.critical.length > 0) {
+        guidance = `MUST RUN: ${checklist.critical.length} critical test(s) before deploying. `;
+    }
+    if (checklist.gaps.length > 0) {
+        guidance += `WARNING: ${checklist.gaps.length} route(s) have no test coverage. `;
+    }
+    if (deploymentType === 'hotfix') {
+        guidance += 'Hotfix mode: Focus on critical and recommended tests.';
+    }
+    else if (deploymentType === 'release') {
+        guidance += 'Release mode: Run all tests for comprehensive verification.';
+    }
+    return {
+        checklist,
+        summary: {
+            criticalTests: checklist.critical.length,
+            recommendedTests: checklist.recommended.length,
+            optionalTests: checklist.optional.length,
+            coverageGaps: checklist.gaps.length,
+            thoroughness,
+            deploymentType,
+        },
+        guidance: guidance || 'Ready to deploy with standard test coverage.',
+    };
+}
+async function getQAHealth(args) {
+    const periodDays = args.period_days || 30;
+    const comparePrevious = args.compare_previous !== false;
+    const now = new Date();
+    const periodStart = new Date(now.getTime() - periodDays * 24 * 60 * 60 * 1000);
+    const previousStart = new Date(periodStart.getTime() - periodDays * 24 * 60 * 60 * 1000);
+    // Get current period data
+    const { data: currentTests } = await supabase
+        .from('test_assignments')
+        .select('id, status, completed_at')
+        .eq('project_id', PROJECT_ID)
+        .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('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('report_type', 'bug')
+        .in('status', ['resolved', 'fixed', 'verified', 'closed'])
+        .gte('resolved_at', periodStart.toISOString());
+    const { data: testers } = await supabase
+        .from('testers')
+        .select('id, status')
+        .eq('project_id', PROJECT_ID);
+    const { data: routeStats } = await supabase
+        .from('route_test_stats')
+        .select('route, test_case_count')
+        .eq('project_id', PROJECT_ID);
+    // Get previous period data for comparison
+    let previousTests = [];
+    let previousBugs = [];
+    let previousResolved = [];
+    if (comparePrevious) {
+        const { data: pt } = await supabase
+            .from('test_assignments')
+            .select('id, status')
+            .eq('project_id', PROJECT_ID)
+            .gte('completed_at', previousStart.toISOString())
+            .lt('completed_at', periodStart.toISOString())
+            .in('status', ['passed', 'failed']);
+        previousTests = pt || [];
+        const { data: pb } = await supabase
+            .from('reports')
+            .select('id, severity')
+            .eq('project_id', PROJECT_ID)
+            .eq('report_type', 'bug')
+            .gte('created_at', previousStart.toISOString())
+            .lt('created_at', periodStart.toISOString());
+        previousBugs = pb || [];
+        const { data: pr } = await supabase
+            .from('reports')
+            .select('id')
+            .eq('project_id', PROJECT_ID)
+            .in('status', ['resolved', 'fixed', 'verified', 'closed'])
+            .gte('resolved_at', previousStart.toISOString())
+            .lt('resolved_at', periodStart.toISOString());
+        previousResolved = pr || [];
+    }
+    // Calculate metrics
+    const testsCompleted = (currentTests || []).length;
+    const testsPerWeek = Math.round(testsCompleted / (periodDays / 7));
+    const prevTestsPerWeek = comparePrevious ? Math.round(previousTests.length / (periodDays / 7)) : 0;
+    const bugsFound = (currentBugs || []).length;
+    const criticalBugs = (currentBugs || []).filter(b => b.severity === 'critical').length;
+    const bugsPerTest = testsCompleted > 0 ? Math.round((bugsFound / testsCompleted) * 100) / 100 : 0;
+    const prevBugsFound = previousBugs.length;
+    const bugsResolvedCount = (resolvedBugs || []).length;
+    const prevResolvedCount = previousResolved.length;
+    // Calculate average resolution time (approximate)
+    let avgResolutionDays = 0;
+    if (resolvedBugs && resolvedBugs.length > 0) {
+        const totalDays = resolvedBugs.reduce((sum, bug) => {
+            if (bug.created_at && bug.resolved_at) {
+                const days = (new Date(bug.resolved_at).getTime() - new Date(bug.created_at).getTime()) / (1000 * 60 * 60 * 24);
+                return sum + days;
+            }
+            return sum;
+        }, 0);
+        avgResolutionDays = Math.round(totalDays / resolvedBugs.length);
+    }
+    // Coverage metrics
+    const totalRoutes = (routeStats || []).length;
+    const routesWithTests = (routeStats || []).filter(r => r.test_case_count > 0).length;
+    const routeCoverage = totalRoutes > 0 ? Math.round((routesWithTests / totalRoutes) * 100) : 0;
+    // Tester health
+    const totalTesters = (testers || []).length;
+    const activeTesters = (testers || []).filter(t => t.status === 'active').length;
+    const utilizationPercent = totalTesters > 0 ? Math.round((activeTesters / totalTesters) * 100) : 0;
+    // Calculate trends
+    const getTrend = (current, previous) => {
+        if (!comparePrevious || previous === 0)
+            return 'stable';
+        const change = ((current - previous) / previous) * 100;
+        if (change > 10)
+            return 'up';
+        if (change < -10)
+            return 'down';
+        return 'stable';
+    };
+    const getChangePercent = (current, previous) => {
+        if (!comparePrevious || previous === 0)
+            return undefined;
+        return Math.round(((current - previous) / previous) * 100);
+    };
+    const metrics = {
+        velocity: {
+            testsPerWeek,
+            testsCompleted,
+            trend: getTrend(testsPerWeek, prevTestsPerWeek),
+            changePercent: getChangePercent(testsPerWeek, prevTestsPerWeek),
+        },
+        bugDiscovery: {
+            bugsFound,
+            bugsPerTest,
+            criticalBugs,
+            trend: getTrend(bugsFound, prevBugsFound),
+            changePercent: getChangePercent(bugsFound, prevBugsFound),
+        },
+        resolution: {
+            bugsResolved: bugsResolvedCount,
+            avgResolutionDays,
+            trend: getTrend(bugsResolvedCount, prevResolvedCount),
+            changePercent: getChangePercent(bugsResolvedCount, prevResolvedCount),
+        },
+        coverage: {
+            routeCoverage,
+            routesWithTests,
+            totalRoutes,
+        },
+        testerHealth: {
+            activeTesters,
+            totalTesters,
+            utilizationPercent,
+        },
+    };
+    // Calculate health score (0-100)
+    const coverageScore = routeCoverage; // 0-100
+    const velocityScore = Math.min(testsPerWeek * 10, 100); // 10+ tests/week = 100
+    const resolutionScore = avgResolutionDays <= 3 ? 100 : avgResolutionDays <= 7 ? 75 : avgResolutionDays <= 14 ? 50 : 25;
+    const stabilityScore = criticalBugs === 0 ? 100 : criticalBugs === 1 ? 75 : criticalBugs <= 3 ? 50 : 25;
+    const overallScore = Math.round((coverageScore * 0.3) +
+        (velocityScore * 0.25) +
+        (resolutionScore * 0.25) +
+        (stabilityScore * 0.2));
+    const getGrade = (score) => {
+        if (score >= 90)
+            return 'A';
+        if (score >= 80)
+            return 'B';
+        if (score >= 70)
+            return 'C';
+        if (score >= 60)
+            return 'D';
+        return 'F';
+    };
+    const healthScore = {
+        score: overallScore,
+        grade: getGrade(overallScore),
+        breakdown: {
+            coverage: coverageScore,
+            velocity: velocityScore,
+            resolution: resolutionScore,
+            stability: stabilityScore,
+        },
+    };
+    // Generate recommendations
+    const recommendations = [];
+    if (coverageScore < 70) {
+        recommendations.push(`Increase test coverage (currently ${routeCoverage}%) - add tests for ${totalRoutes - routesWithTests} uncovered routes`);
+    }
+    if (velocityScore < 50) {
+        recommendations.push(`Increase testing velocity (${testsPerWeek}/week) - aim for 10+ tests per week`);
+    }
+    if (avgResolutionDays > 7) {
+        recommendations.push(`Improve bug resolution time (currently ${avgResolutionDays} days) - target <7 days`);
+    }
+    if (criticalBugs > 0) {
+        recommendations.push(`Address ${criticalBugs} critical bug(s) immediately`);
+    }
+    if (utilizationPercent < 50) {
+        recommendations.push(`Improve tester utilization (${utilizationPercent}%) - ${totalTesters - activeTesters} testers are inactive`);
+    }
+    return {
+        metrics,
+        healthScore,
+        recommendations,
+        period: {
+            days: periodDays,
+            start: periodStart.toISOString(),
+            end: now.toISOString(),
+        },
+    };
+}
+async function analyzeChangesForTests(args) {
+    // Get existing tests to check coverage
+    const { data: existingTests } = await supabase
+        .from('test_cases')
+        .select('test_key, title, target_route, description')
+        .eq('project_id', PROJECT_ID);
+    // Get next test key
+    const { data: lastTest } = await supabase
+        .from('test_cases')
+        .select('test_key')
+        .eq('project_id', PROJECT_ID)
+        .order('test_key', { ascending: false })
+        .limit(1);
+    const lastKey = lastTest?.[0]?.test_key || 'TC-000';
+    const lastNum = parseInt(lastKey.replace('TC-', '')) || 0;
+    // Get bug history for these routes to understand risk areas
+    const routes = args.affected_routes || [];
+    let relatedBugs = [];
+    if (routes.length > 0) {
+        const { data: bugs } = await supabase
+            .from('reports')
+            .select('id, description, severity, app_context')
+            .eq('project_id', PROJECT_ID)
+            .eq('report_type', 'bug')
+            .limit(50);
+        relatedBugs = (bugs || []).filter(bug => {
+            const bugRoute = bug.app_context?.currentRoute;
+            return bugRoute && routes.some(r => bugRoute.includes(r) || r.includes(bugRoute));
+        });
+    }
+    // Analyze file types to determine what kind of tests are needed
+    const fileAnalysis = analyzeFileTypes(args.changed_files);
+    // Check existing test coverage for affected routes
+    const existingCoverage = (existingTests || []).filter(test => routes.some(r => test.target_route?.includes(r) || test.title.toLowerCase().includes(r.toLowerCase())));
+    // Generate intelligent suggestions based on change type and file analysis
+    const suggestions = [];
+    let testNum = lastNum;
+    // Change-type specific test suggestions
+    if (args.change_type === 'feature') {
+        // New features need comprehensive testing
+        for (const route of routes.slice(0, 2)) {
+            testNum++;
+            suggestions.push({
+                test_key: `TC-${String(testNum).padStart(3, '0')}`,
+                title: `Verify new feature: ${args.change_summary.slice(0, 40)}`,
+                description: `Test the new functionality added: ${args.change_summary}`,
+                track: 'functional',
+                priority: 'P1',
+                target_route: route,
+                rationale: 'New features require verification that they work as intended',
+                steps: [
+                    { stepNumber: 1, action: `Navigate to ${route}`, expectedResult: 'Page loads successfully' },
+                    { stepNumber: 2, action: 'Locate the new feature/element', expectedResult: 'Feature is visible and accessible' },
+                    { stepNumber: 3, action: 'Interact with the new feature', expectedResult: 'Feature responds as expected' },
+                    { stepNumber: 4, action: 'Verify the expected outcome', expectedResult: 'Correct result is produced' },
+                ],
+                expected_result: 'New feature functions correctly without errors',
+            });
+        }
+        // Add edge case test for features
+        if (routes.length > 0) {
+            testNum++;
+            suggestions.push({
+                test_key: `TC-${String(testNum).padStart(3, '0')}`,
+                title: `Edge cases: ${args.change_summary.slice(0, 35)}`,
+                description: `Test edge cases and error handling for the new feature`,
+                track: 'functional',
+                priority: 'P2',
+                target_route: routes[0],
+                rationale: 'Edge cases often reveal bugs that happy-path testing misses',
+                steps: [
+                    { stepNumber: 1, action: `Navigate to ${routes[0]}`, expectedResult: 'Page loads' },
+                    { stepNumber: 2, action: 'Test with empty/null input', expectedResult: 'Graceful handling, no crash' },
+                    { stepNumber: 3, action: 'Test with invalid input', expectedResult: 'Appropriate error message' },
+                    { stepNumber: 4, action: 'Test boundary conditions', expectedResult: 'Correct behavior at limits' },
+                ],
+                expected_result: 'Feature handles edge cases gracefully without errors',
+            });
+        }
+    }
+    if (args.change_type === 'bugfix') {
+        // Bug fixes need regression tests
+        for (const route of routes.slice(0, 1)) {
+            testNum++;
+            suggestions.push({
+                test_key: `TC-${String(testNum).padStart(3, '0')}`,
+                title: `Regression: ${args.change_summary.slice(0, 40)}`,
+                description: `Verify the bug fix works and hasn't regressed: ${args.change_summary}`,
+                track: 'functional',
+                priority: 'P1',
+                target_route: route,
+                rationale: 'Bug fixes should have regression tests to prevent recurrence',
+                steps: [
+                    { stepNumber: 1, action: `Navigate to ${route}`, expectedResult: 'Page loads' },
+                    { stepNumber: 2, action: 'Reproduce the original bug scenario', expectedResult: 'Bug no longer occurs' },
+                    { stepNumber: 3, action: 'Test related functionality', expectedResult: 'No side effects from fix' },
+                ],
+                expected_result: 'Bug is fixed and related functionality still works',
+            });
+        }
+    }
+    if (args.change_type === 'ui_change') {
+        // UI changes need visual and interaction testing
+        for (const route of routes.slice(0, 1)) {
+            testNum++;
+            suggestions.push({
+                test_key: `TC-${String(testNum).padStart(3, '0')}`,
+                title: `UI verification: ${args.change_summary.slice(0, 35)}`,
+                description: `Verify UI changes display correctly across devices`,
+                track: 'design',
+                priority: 'P2',
+                target_route: route,
+                rationale: 'UI changes should be verified visually and for responsiveness',
+                steps: [
+                    { stepNumber: 1, action: `Navigate to ${route}`, expectedResult: 'Page loads' },
+                    { stepNumber: 2, action: 'Verify visual appearance matches design', expectedResult: 'UI looks correct' },
+                    { stepNumber: 3, action: 'Test on mobile viewport (375px)', expectedResult: 'Responsive layout works' },
+                    { stepNumber: 4, action: 'Test interactive elements', expectedResult: 'Buttons, links work correctly' },
+                ],
+                expected_result: 'UI changes look correct and are responsive',
+            });
+        }
+    }
+    if (args.change_type === 'api_change') {
+        // API changes need integration testing
+        for (const route of routes.slice(0, 1)) {
+            testNum++;
+            suggestions.push({
+                test_key: `TC-${String(testNum).padStart(3, '0')}`,
+                title: `API integration: ${args.change_summary.slice(0, 35)}`,
+                description: `Verify API changes work correctly end-to-end`,
+                track: 'functional',
+                priority: 'P1',
+                target_route: route,
+                rationale: 'API changes can break frontend functionality',
+                steps: [
+                    { stepNumber: 1, action: `Navigate to ${route}`, expectedResult: 'Page loads' },
+                    { stepNumber: 2, action: 'Trigger the API call', expectedResult: 'Request is sent' },
+                    { stepNumber: 3, action: 'Verify response handling', expectedResult: 'Data displays correctly' },
+                    { stepNumber: 4, action: 'Test error scenarios', expectedResult: 'Errors handled gracefully' },
+                ],
+                expected_result: 'API integration works correctly',
+            });
+        }
+    }
+    // Add accessibility test if UI components were changed
+    if (fileAnalysis.hasUIComponents && (args.change_type === 'feature' || args.change_type === 'ui_change')) {
+        testNum++;
+        suggestions.push({
+            test_key: `TC-${String(testNum).padStart(3, '0')}`,
+            title: `Accessibility: ${args.change_summary.slice(0, 35)}`,
+            description: `Verify changes meet accessibility standards`,
+            track: 'accessibility',
+            priority: 'P2',
+            target_route: routes[0] || null,
+            rationale: 'UI changes should maintain accessibility compliance',
+            steps: [
+                { stepNumber: 1, action: 'Navigate using keyboard only (Tab)', expectedResult: 'All interactive elements reachable' },
+                { stepNumber: 2, action: 'Check focus indicators', expectedResult: 'Focus is visible on all elements' },
+                { stepNumber: 3, action: 'Verify with screen reader', expectedResult: 'Content is announced correctly' },
+            ],
+            expected_result: 'Changes are accessible to all users',
+        });
+    }
+    // Determine if tests are recommended
+    const shouldCreateTests = suggestions.length > 0 &&
+        (args.change_type !== 'config' && args.change_type !== 'refactor');
+    // Check if routes already have good coverage
+    const coverageRatio = existingCoverage.length / Math.max(routes.length, 1);
+    return {
+        analysis: {
+            change_type: args.change_type,
+            files_changed: args.changed_files.length,
+            file_types: fileAnalysis,
+            affected_routes: routes,
+            existing_coverage: existingCoverage.length,
+            related_bugs: relatedBugs.length,
+            coverage_ratio: coverageRatio,
+        },
+        recommendation: {
+            should_create_tests: shouldCreateTests,
+            urgency: args.change_type === 'feature' || args.change_type === 'bugfix' ? 'high' :
+                args.change_type === 'api_change' ? 'medium' : 'low',
+            reason: shouldCreateTests
+                ? `${args.change_type === 'feature' ? 'New features' : args.change_type === 'bugfix' ? 'Bug fixes' : 'Changes'} should have QA coverage to catch issues early.`
+                : args.change_type === 'config' ? 'Config changes typically don\'t need manual QA tests.'
+                    : 'Refactoring with good existing coverage may not need new tests.',
+        },
+        suggestions: suggestions.map(s => ({
+            ...s,
+            create_command: `create_test_case with test_key="${s.test_key}", title="${s.title}", target_route="${s.target_route}"`,
+        })),
+        existing_tests: existingCoverage.slice(0, 5).map(t => ({
+            test_key: t.test_key,
+            title: t.title,
+            target_route: t.target_route,
+        })),
+        next_steps: shouldCreateTests
+            ? [
+                'Review the suggested tests above',
+                'Modify titles/steps as needed for your specific implementation',
+                'Use create_test_case to add the ones that make sense',
+                'Skip any that duplicate existing coverage',
+            ]
+            : ['No new tests recommended for this change type'],
+    };
+}
+function analyzeFileTypes(files) {
+    const analysis = {
+        hasUIComponents: false,
+        hasAPIRoutes: false,
+        hasTests: false,
+        hasStyles: false,
+        hasConfig: false,
+        primaryType: 'unknown',
+    };
+    for (const file of files) {
+        const lower = file.toLowerCase();
+        if (lower.includes('component') || lower.endsWith('.tsx') || lower.endsWith('.jsx') ||
+            lower.includes('/pages/') || lower.includes('/app/') || lower.includes('/screens/')) {
+            analysis.hasUIComponents = true;
+        }
+        if (lower.includes('/api/') || lower.includes('route.ts') || lower.includes('handler') ||
+            lower.includes('service') || lower.includes('controller')) {
+            analysis.hasAPIRoutes = true;
+        }
+        if (lower.includes('.test.') || lower.includes('.spec.') || lower.includes('__tests__')) {
+            analysis.hasTests = true;
+        }
+        if (lower.endsWith('.css') || lower.endsWith('.scss') || lower.includes('style') ||
+            lower.includes('tailwind')) {
+            analysis.hasStyles = true;
+        }
+        if (lower.includes('config') || lower.endsWith('.json') || lower.endsWith('.env') ||
+            lower.includes('settings')) {
+            analysis.hasConfig = true;
+        }
+    }
+    // Determine primary type
+    if (analysis.hasUIComponents)
+        analysis.primaryType = 'ui';
+    else if (analysis.hasAPIRoutes)
+        analysis.primaryType = 'api';
+    else if (analysis.hasConfig)
+        analysis.primaryType = 'config';
+    else if (analysis.hasStyles)
+        analysis.primaryType = 'styles';
+    return analysis;
+}
+function getTrackTemplates(track) {
+    const templates = {
+        functional: [
+            {
+                title: 'Happy path navigation to {route}',
+                description: 'Verify basic navigation and page load for {route}',
+                steps: [
+                    { action: 'Navigate to {route}', expectedResult: 'Page loads without errors' },
+                    { action: 'Verify all main elements are visible', expectedResult: 'Headers, content, and navigation present' },
+                    { action: 'Check for console errors', expectedResult: 'No JavaScript errors in console' },
+                ],
+                expected_result: 'Page functions correctly with all elements visible',
+            },
+            {
+                title: 'Error handling at {route}',
+                description: 'Test error states and edge cases at {route}',
+                steps: [
+                    { action: 'Navigate to {route}', expectedResult: 'Page loads' },
+                    { action: 'Trigger an error condition (e.g., invalid input)', expectedResult: 'Error message displayed' },
+                    { action: 'Verify error is user-friendly', expectedResult: 'Clear explanation of what went wrong' },
+                ],
+                expected_result: 'Errors are handled gracefully with clear messaging',
+            },
+            {
+                title: 'Form submission at {route}',
+                description: 'Test form validation and submission at {route}',
+                steps: [
+                    { action: 'Navigate to {route}', expectedResult: 'Form is visible' },
+                    { action: 'Submit form with empty fields', expectedResult: 'Validation errors shown' },
+                    { action: 'Fill in valid data and submit', expectedResult: 'Success message or redirect' },
+                ],
+                expected_result: 'Form validates input and submits successfully',
+            },
+        ],
+        design: [
+            {
+                title: 'Visual consistency at {route}',
+                description: 'Check design system compliance at {route}',
+                steps: [
+                    { action: 'Navigate to {route}', expectedResult: 'Page loads' },
+                    { action: 'Check typography matches design system', expectedResult: 'Fonts, sizes, weights are correct' },
+                    { action: 'Verify color usage', expectedResult: 'Colors match brand guidelines' },
+                    { action: 'Check spacing and alignment', expectedResult: 'Consistent margins and padding' },
+                ],
+                expected_result: 'Page matches design specifications',
+            },
+            {
+                title: 'Responsive behavior at {route}',
+                description: 'Test responsive design at {route}',
+                steps: [
+                    { action: 'View {route} on desktop (1920px)', expectedResult: 'Full layout visible' },
+                    { action: 'Resize to tablet (768px)', expectedResult: 'Layout adapts appropriately' },
+                    { action: 'Resize to mobile (375px)', expectedResult: 'Mobile-friendly layout' },
+                ],
+                expected_result: 'Page is fully responsive across breakpoints',
+            },
+        ],
+        accessibility: [
+            {
+                title: 'Keyboard navigation at {route}',
+                description: 'Test keyboard accessibility at {route}',
+                steps: [
+                    { action: 'Navigate to {route}', expectedResult: 'Page loads' },
+                    { action: 'Press Tab to navigate through elements', expectedResult: 'Focus moves in logical order' },
+                    { action: 'Verify focus indicators are visible', expectedResult: 'Clear focus ring on interactive elements' },
+                    { action: 'Test Enter/Space on buttons', expectedResult: 'Buttons activate correctly' },
+                ],
+                expected_result: 'Page is fully navigable by keyboard',
+            },
+            {
+                title: 'Screen reader compatibility at {route}',
+                description: 'Test screen reader accessibility at {route}',
+                steps: [
+                    { action: 'Enable screen reader', expectedResult: 'Screen reader activates' },
+                    { action: 'Navigate to {route}', expectedResult: 'Page title is announced' },
+                    { action: 'Tab through content', expectedResult: 'All content is announced meaningfully' },
+                    { action: 'Check form labels', expectedResult: 'Inputs have associated labels' },
+                ],
+                expected_result: 'Page is fully accessible via screen reader',
+            },
+        ],
+        performance: [
+            {
+                title: 'Page load performance at {route}',
+                description: 'Measure load times at {route}',
+                steps: [
+                    { action: 'Clear browser cache', expectedResult: 'Cache cleared' },
+                    { action: 'Navigate to {route}', expectedResult: 'Page loads' },
+                    { action: 'Check Network tab for load time', expectedResult: 'Initial load under 3 seconds' },
+                    { action: 'Note Largest Contentful Paint', expectedResult: 'LCP under 2.5 seconds' },
+                ],
+                expected_result: 'Page loads within performance budget',
+            },
+        ],
+    };
+    return templates[track] || templates.functional;
+}
+// === WRITE-BACK TOOL HANDLERS ===
+async function createBugReport(args) {
+    // Build code context for the report
+    const codeContext = {};
+    if (args.file_path) {
+        codeContext.file_path = args.file_path;
+        codeContext.line_number = args.line_number;
+        codeContext.code_snippet = args.code_snippet;
+        codeContext.function_name = extractFunctionName(args.code_snippet);
+    }
+    if (args.related_files) {
+        codeContext.related_files = args.related_files;
+    }
+    if (args.suggested_fix) {
+        codeContext.suggested_fix = args.suggested_fix;
+    }
+    const report = {
+        project_id: PROJECT_ID,
+        report_type: 'bug',
+        title: args.title,
+        description: args.description,
+        severity: args.severity,
+        status: 'new',
+        app_context: {
+            currentRoute: args.file_path || 'code',
+            source: 'claude_code',
+            timestamp: new Date().toISOString(),
+        },
+        device_info: {
+            platform: 'claude_code',
+            environment: 'development',
+        },
+        code_context: codeContext,
+    };
+    const { data, error } = await supabase
+        .from('reports')
+        .insert(report)
+        .select('id')
+        .single();
+    if (error) {
+        return { error: error.message };
+    }
+    return {
+        success: true,
+        report_id: data.id,
+        message: `Bug report created: ${args.title}`,
+        details: {
+            id: data.id,
+            severity: args.severity,
+            file: args.file_path,
+            line: args.line_number,
+        },
+    };
+}
+function extractFunctionName(codeSnippet) {
+    if (!codeSnippet)
+        return undefined;
+    // Try to extract function/component name from code
+    const patterns = [
+        /function\s+(\w+)/,
+        /const\s+(\w+)\s*=\s*(?:async\s*)?\(/,
+        /export\s+(?:default\s+)?(?:async\s+)?function\s+(\w+)/,
+        /class\s+(\w+)/,
+        /(\w+)\s*:\s*(?:React\.)?FC/,
+    ];
+    for (const pattern of patterns) {
+        const match = codeSnippet.match(pattern);
+        if (match)
+            return match[1];
+    }
+    return undefined;
+}
+async function getBugsForFile(args) {
+    // Normalize the file path for matching
+    const normalizedPath = args.file_path.replace(/^\.\//, '').replace(/^\//, '');
+    let query = supabase
+        .from('reports')
+        .select('id, title, description, severity, status, created_at, code_context')
+        .eq('project_id', PROJECT_ID)
+        .eq('report_type', 'bug');
+    if (!args.include_resolved) {
+        query = query.in('status', ['new', 'confirmed', 'in_progress', 'reviewed']);
+    }
+    const { data, error } = await query.order('created_at', { ascending: false });
+    if (error) {
+        return { error: error.message };
+    }
+    // Filter bugs that match the file path
+    const matchingBugs = (data || []).filter(bug => {
+        const codeContext = bug.code_context;
+        if (!codeContext)
+            return false;
+        const bugFilePath = codeContext.file_path;
+        if (!bugFilePath)
+            return false;
+        const normalizedBugPath = bugFilePath.replace(/^\.\//, '').replace(/^\//, '');
+        return normalizedBugPath.includes(normalizedPath) || normalizedPath.includes(normalizedBugPath);
+    });
+    // Also check related_files
+    const relatedBugs = (data || []).filter(bug => {
+        if (matchingBugs.includes(bug))
+            return false;
+        const codeContext = bug.code_context;
+        const relatedFiles = codeContext?.related_files;
+        if (!relatedFiles)
+            return false;
+        return relatedFiles.some(f => f.includes(normalizedPath) || normalizedPath.includes(f));
+    });
+    return {
+        file: args.file_path,
+        direct_bugs: matchingBugs.map(b => ({
+            id: b.id,
+            title: b.title,
+            severity: b.severity,
+            status: b.status,
+            line: b.code_context?.line_number,
+            description: b.description.slice(0, 200),
+        })),
+        related_bugs: relatedBugs.map(b => ({
+            id: b.id,
+            title: b.title,
+            severity: b.severity,
+            status: b.status,
+            source_file: b.code_context?.file_path,
+        })),
+        summary: {
+            total: matchingBugs.length + relatedBugs.length,
+            critical: matchingBugs.filter(b => b.severity === 'critical').length,
+            open: matchingBugs.filter(b => ['new', 'confirmed', 'in_progress'].includes(b.status)).length,
+        },
+        recommendation: matchingBugs.length > 0
+            ? `Found ${matchingBugs.length} bug(s) in this file. Consider fixing them while you're here.`
+            : 'No known bugs in this file.',
+    };
+}
+async function markFixedWithCommit(args) {
+    if (!isValidUUID(args.report_id)) {
+        return { error: 'Invalid report_id format' };
+    }
+    // Get current report to preserve existing data
+    const { data: existing, error: fetchError } = await supabase
+        .from('reports')
+        .select('code_context')
+        .eq('id', args.report_id)
+        .eq('project_id', PROJECT_ID) // Security: ensure report belongs to this project
+        .single();
+    if (fetchError) {
+        return { error: fetchError.message };
+    }
+    const existingContext = existing?.code_context || {};
+    const updates = {
+        status: 'resolved',
+        resolved_at: new Date().toISOString(),
+        resolution: args.resolution_notes || `Fixed in commit ${args.commit_sha.slice(0, 7)}`,
+        code_context: {
+            ...existingContext,
+            fix: {
+                commit_sha: args.commit_sha,
+                commit_message: args.commit_message,
+                files_changed: args.files_changed,
+                fixed_at: new Date().toISOString(),
+                fixed_by: 'claude_code',
+            },
+        },
+    };
+    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: `Bug marked as fixed in commit ${args.commit_sha.slice(0, 7)}`,
+        report_id: args.report_id,
+        commit: args.commit_sha,
+        next_steps: [
+            'Consider running create_regression_test to prevent this bug from recurring',
+            'Push your changes to trigger CI/CD',
+        ],
+    };
+}
+async function getBugsAffectingCode(args) {
+    const includeRelated = args.include_related !== false;
+    const { data, error } = await supabase
+        .from('reports')
+        .select('id, title, description, severity, status, code_context, app_context')
+        .eq('project_id', PROJECT_ID)
+        .eq('report_type', 'bug')
+        .in('status', ['new', 'confirmed', 'in_progress', 'reviewed'])
+        .order('severity', { ascending: true });
+    if (error) {
+        return { error: error.message };
+    }
+    const normalizedPaths = args.file_paths.map(p => p.replace(/^\.\//, '').replace(/^\//, ''));
+    const affectedBugs = [];
+    for (const bug of data || []) {
+        const codeContext = bug.code_context;
+        const appContext = bug.app_context;
+        // Check direct file match
+        const bugFile = codeContext?.file_path;
+        if (bugFile) {
+            const normalizedBugFile = bugFile.replace(/^\.\//, '').replace(/^\//, '');
+            for (const path of normalizedPaths) {
+                if (normalizedBugFile.includes(path) || path.includes(normalizedBugFile)) {
+                    affectedBugs.push({
+                        id: bug.id,
+                        title: bug.title,
+                        severity: bug.severity,
+                        status: bug.status,
+                        matched_file: path,
+                        match_type: 'direct',
+                    });
+                    break;
+                }
+            }
+        }
+        // Check related files
+        if (includeRelated && codeContext?.related_files) {
+            const relatedFiles = codeContext.related_files;
+            for (const relatedFile of relatedFiles) {
+                for (const path of normalizedPaths) {
+                    if (relatedFile.includes(path) || path.includes(relatedFile)) {
+                        if (!affectedBugs.find(b => b.id === bug.id)) {
+                            affectedBugs.push({
+                                id: bug.id,
+                                title: bug.title,
+                                severity: bug.severity,
+                                status: bug.status,
+                                matched_file: path,
+                                match_type: 'related',
+                            });
+                        }
+                        break;
+                    }
+                }
+            }
+        }
+        // Check route-based matches (for component files)
+        const route = appContext?.currentRoute;
+        if (route && route !== 'code') {
+            for (const path of normalizedPaths) {
+                // Match route to common file patterns
+                if (path.includes('page') || path.includes('route') || path.includes('component')) {
+                    const pathParts = path.split('/');
+                    const fileName = pathParts[pathParts.length - 1].replace(/\.(tsx?|jsx?)$/, '');
+                    if (route.toLowerCase().includes(fileName.toLowerCase())) {
+                        if (!affectedBugs.find(b => b.id === bug.id)) {
+                            affectedBugs.push({
+                                id: bug.id,
+                                title: bug.title,
+                                severity: bug.severity,
+                                status: bug.status,
+                                matched_file: path,
+                                match_type: 'route',
+                            });
+                        }
+                    }
+                }
+            }
+        }
+    }
+    // Group by severity
+    const critical = affectedBugs.filter(b => b.severity === 'critical');
+    const high = affectedBugs.filter(b => b.severity === 'high');
+    const other = affectedBugs.filter(b => !['critical', 'high'].includes(b.severity));
+    return {
+        files_checked: args.file_paths,
+        affected_bugs: affectedBugs,
+        summary: {
+            total: affectedBugs.length,
+            critical: critical.length,
+            high: high.length,
+            direct_matches: affectedBugs.filter(b => b.match_type === 'direct').length,
+        },
+        warnings: critical.length > 0
+            ? [`⚠️ ${critical.length} CRITICAL bug(s) may be affected by your changes!`]
+            : [],
+        recommendation: affectedBugs.length > 0
+            ? `Review ${affectedBugs.length} potentially affected bug(s) before pushing.`
+            : 'No known bugs affected by these changes.',
+    };
+}
+async function linkBugToCode(args) {
+    if (!isValidUUID(args.report_id)) {
+        return { error: 'Invalid report_id format' };
+    }
+    // Get current report
+    const { data: existing, error: fetchError } = await supabase
+        .from('reports')
+        .select('code_context')
+        .eq('id', args.report_id)
+        .eq('project_id', PROJECT_ID) // Security: ensure report belongs to this project
+        .single();
+    if (fetchError) {
+        return { error: fetchError.message };
+    }
+    const existingContext = existing?.code_context || {};
+    const updates = {
+        code_context: {
+            ...existingContext,
+            file_path: args.file_path,
+            line_number: args.line_number,
+            code_snippet: args.code_snippet,
+            function_name: args.function_name || extractFunctionName(args.code_snippet),
+            linked_at: new Date().toISOString(),
+            linked_by: 'claude_code',
+        },
+    };
+    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: `Bug linked to ${args.file_path}${args.line_number ? `:${args.line_number}` : ''}`,
+        report_id: args.report_id,
+    };
+}
+async function createRegressionTest(args) {
+    if (!isValidUUID(args.report_id)) {
+        return { error: 'Invalid report_id format' };
+    }
+    // Get the bug report details
+    const { data: report, error: fetchError } = await supabase
+        .from('reports')
+        .select('*')
+        .eq('id', args.report_id)
+        .eq('project_id', PROJECT_ID) // Security: ensure report belongs to this project
+        .single();
+    if (fetchError) {
+        return { error: fetchError.message };
+    }
+    if (report.status !== 'resolved') {
+        return {
+            error: 'Bug must be resolved before creating a regression test',
+            current_status: report.status,
+        };
+    }
+    const codeContext = report.code_context;
+    const testType = args.test_type || 'integration';
+    // Get next test key
+    const { data: existingTests } = await supabase
+        .from('test_cases')
+        .select('test_key')
+        .eq('project_id', PROJECT_ID)
+        .order('test_key', { ascending: false })
+        .limit(1);
+    const lastKey = existingTests?.[0]?.test_key || 'TC-000';
+    const lastNum = parseInt(lastKey.replace('TC-', '')) || 0;
+    const newKey = `TC-${String(lastNum + 1).padStart(3, '0')}`;
+    // Get the route from the bug's app_context for deep linking
+    const appContext = report.app_context;
+    const targetRoute = appContext?.currentRoute;
+    // Generate test case from bug
+    const testCase = {
+        project_id: PROJECT_ID,
+        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}`,
+        priority: report.severity === 'critical' ? 'P0' : report.severity === 'high' ? 'P1' : 'P2',
+        steps: [
+            {
+                stepNumber: 1,
+                action: codeContext?.file_path
+                    ? `Navigate to the code/feature in ${codeContext.file_path}`
+                    : 'Navigate to the affected feature',
+                expectedResult: 'Feature loads correctly',
+            },
+            {
+                stepNumber: 2,
+                action: 'Reproduce the original bug scenario',
+                expectedResult: 'The bug should NOT occur',
+            },
+            {
+                stepNumber: 3,
+                action: 'Verify the fix is working',
+                expectedResult: report.resolution || 'Feature works as expected',
+            },
+        ],
+        expected_result: `The bug "${report.title}" should not recur`,
+        preconditions: codeContext?.fix
+            ? `Requires commit ${codeContext.fix.commit_sha?.slice(0, 7) || 'unknown'} or later`
+            : '',
+        target_route: targetRoute,
+        metadata: {
+            source: 'regression_from_bug',
+            original_bug_id: args.report_id,
+            test_type: testType,
+            created_by: 'claude_code',
+        },
+    };
+    const { data, error } = await supabase
+        .from('test_cases')
+        .insert(testCase)
+        .select('id, test_key, title')
+        .single();
+    if (error) {
+        return { error: error.message };
+    }
+    return {
+        success: true,
+        test_case: {
+            id: data.id,
+            test_key: data.test_key,
+            title: data.title,
+            type: testType,
+        },
+        message: `Regression test ${data.test_key} created from bug report`,
+        original_bug: {
+            id: args.report_id,
+            title: report.title,
+        },
+    };
+}
+// === FIX QUEUE TOOL HANDLERS ===
+async function getPendingFixes(args) {
+    const limit = args.limit || 10;
+    let query = supabase
+        .from('fix_requests')
+        .select(`
+      id,
+      title,
+      description,
+      prompt,
+      file_path,
+      status,
+      claimed_at,
+      claimed_by,
+      created_at,
+      report:reports(id, title, severity, description)
+    `)
+        .eq('project_id', PROJECT_ID)
+        .order('created_at', { ascending: true })
+        .limit(limit);
+    if (!args.include_claimed) {
+        query = query.eq('status', 'pending');
+    }
+    else {
+        query = query.in('status', ['pending', 'claimed']);
+    }
+    const { data, error } = await query;
+    if (error) {
+        return { error: error.message };
+    }
+    if (!data || data.length === 0) {
+        return {
+            fix_requests: [],
+            count: 0,
+            message: 'No pending fix requests in the queue. Great job keeping up!',
+        };
+    }
+    return {
+        fix_requests: data.map((fr) => ({
+            id: fr.id,
+            title: fr.title,
+            description: fr.description,
+            prompt: fr.prompt,
+            file_path: fr.file_path,
+            status: fr.status,
+            claimed_by: fr.claimed_by,
+            claimed_at: fr.claimed_at,
+            created_at: fr.created_at,
+            related_report: fr.report ? {
+                id: fr.report.id,
+                title: fr.report.title,
+                severity: fr.report.severity,
+            } : null,
+        })),
+        count: data.length,
+        message: `Found ${data.length} fix request(s) waiting. Use claim_fix_request to start working on one.`,
+    };
+}
+async function claimFixRequest(args) {
+    if (!isValidUUID(args.fix_request_id)) {
+        return { error: 'Invalid fix_request_id format' };
+    }
+    // First check if it's still available
+    const { data: existing, error: checkError } = await supabase
+        .from('fix_requests')
+        .select('id, status, claimed_by, prompt, title')
+        .eq('id', args.fix_request_id)
+        .eq('project_id', PROJECT_ID) // Security: ensure fix request belongs to this project
+        .single();
+    if (checkError) {
+        return { error: checkError.message };
+    }
+    if (existing.status === 'claimed') {
+        return {
+            error: `This fix request is already claimed by ${existing.claimed_by || 'another instance'}`,
+            status: existing.status,
+        };
+    }
+    if (existing.status === 'completed') {
+        return {
+            error: 'This fix request has already been completed',
+            status: existing.status,
+        };
+    }
+    // Claim it
+    const claimedBy = args.claimed_by || `claude-code-${Date.now()}`;
+    const { error: updateError } = await supabase
+        .from('fix_requests')
+        .update({
+        status: 'claimed',
+        claimed_at: new Date().toISOString(),
+        claimed_by: claimedBy,
+    })
+        .eq('id', args.fix_request_id)
+        .eq('project_id', PROJECT_ID) // Security: ensure fix request belongs to this project
+        .eq('status', 'pending'); // Only claim if still pending (race condition protection)
+    if (updateError) {
+        return { error: updateError.message };
+    }
+    return {
+        success: true,
+        message: `Fix request claimed successfully. Here's your task:`,
+        fix_request: {
+            id: args.fix_request_id,
+            title: existing.title,
+            prompt: existing.prompt,
+        },
+        next_steps: [
+            '1. Read and understand the prompt below',
+            '2. Implement the fix',
+            '3. Test your changes',
+            '4. Use complete_fix_request when done',
+        ],
+    };
+}
+async function completeFixRequest(args) {
+    if (!isValidUUID(args.fix_request_id)) {
+        return { error: 'Invalid fix_request_id format' };
+    }
+    const isSuccess = args.success !== false;
+    const updates = {
+        status: isSuccess ? 'completed' : 'cancelled',
+        completed_at: new Date().toISOString(),
+        completion_notes: args.completion_notes || (isSuccess ? 'Fix completed' : 'Could not complete fix'),
+    };
+    const { error } = await supabase
+        .from('fix_requests')
+        .update(updates)
+        .eq('id', args.fix_request_id)
+        .eq('project_id', PROJECT_ID); // Security: ensure fix request belongs to this project
+    if (error) {
+        return { error: error.message };
+    }
+    return {
+        success: true,
+        message: isSuccess
+            ? 'Fix request marked as completed!'
+            : 'Fix request marked as cancelled.',
+        fix_request_id: args.fix_request_id,
+        status: updates.status,
+    };
+}
+// === MCP PROMPTS FOR GUIDED WORKFLOWS ===
+const prompts = [
+    {
+        name: 'fix_bugs',
+        description: 'Review and fix open bugs in the project. Shows critical bugs first and guides you through fixing them one by one.',
+        arguments: [
+            {
+                name: 'severity',
+                description: 'Filter by severity: critical, high, medium, low, or all (default: all)',
+                required: false,
+            },
+            {
+                name: 'file',
+                description: 'Filter to bugs in a specific file path',
+                required: false,
+            },
+        ],
+    },
+    {
+        name: 'qa_check',
+        description: 'Run a QA check on your recent changes. Analyzes changed files for potential issues and related bugs.',
+        arguments: [
+            {
+                name: 'files',
+                description: 'Comma-separated list of changed file paths (or leave empty to auto-detect from git)',
+                required: false,
+            },
+        ],
+    },
+    {
+        name: 'regression_tests',
+        description: 'Generate regression tests for recently fixed bugs to prevent them from recurring.',
+        arguments: [
+            {
+                name: 'limit',
+                description: 'Number of recent fixes to generate tests for (default: 5)',
+                required: false,
+            },
+        ],
+    },
+    {
+        name: 'bug_hunt',
+        description: 'Proactive bug hunting mode. Analyzes the codebase for potential issues based on common patterns and past bugs.',
+        arguments: [
+            {
+                name: 'focus',
+                description: 'Area to focus on: error_handling, null_checks, async_issues, type_safety, security',
+                required: false,
+            },
+        ],
+    },
+];
+async function generatePromptContent(name, args) {
+    switch (name) {
+        case 'fix_bugs': {
+            const severity = args.severity || 'all';
+            const fileFilter = args.file;
+            // First, check the fix queue for requested fixes from the dashboard
+            const { data: fixRequests } = await supabase
+                .from('fix_requests')
+                .select(`
+          id,
+          title,
+          description,
+          prompt,
+          file_path,
+          status,
+          created_at,
+          report:reports(id, title, severity)
+        `)
+                .eq('project_id', PROJECT_ID)
+                .eq('status', 'pending')
+                .order('created_at', { ascending: true })
+                .limit(5);
+            // Fetch open bugs
+            let query = supabase
+                .from('reports')
+                .select('id, title, description, severity, status, code_context, created_at')
+                .eq('project_id', PROJECT_ID)
+                .eq('report_type', 'bug')
+                .in('status', ['new', 'confirmed', 'in_progress']);
+            if (severity !== 'all') {
+                query = query.eq('severity', severity);
+            }
+            const { data: bugs } = await query.order('severity', { ascending: true }).limit(20);
+            // Filter by file if specified
+            let filteredBugs = bugs || [];
+            if (fileFilter) {
+                filteredBugs = filteredBugs.filter(b => {
+                    const ctx = b.code_context;
+                    const filePath = ctx?.file_path;
+                    return filePath && filePath.includes(fileFilter);
+                });
+            }
+            // Build fix queue section if there are pending requests
+            let fixQueueSection = '';
+            if (fixRequests && fixRequests.length > 0) {
+                const queueList = fixRequests.map((fr, i) => {
+                    return `
+### ${i + 1}. ${fr.title}
+- **Fix Request ID:** \`${fr.id}\`
+- **File:** ${fr.file_path || 'Not specified'}
+- **Related Bug:** ${fr.report ? `[${fr.report.severity?.toUpperCase()}] ${fr.report.title}` : 'None'}
+- **Created:** ${new Date(fr.created_at).toLocaleDateString()}
+
+<details>
+<summary>View Fix Prompt</summary>
+
+\`\`\`
+${fr.prompt}
+\`\`\`
+</details>
+`;
+                }).join('\n');
+                fixQueueSection = `
+# 🔧 Fix Queue (Priority)
+
+**${fixRequests.length} fix request(s)** have been queued from the BugBear dashboard:
+
+${queueList}
+
+---
+
+**To start on a fix request:**
+1. Use \`claim_fix_request\` with the fix request ID
+2. Follow the prompt instructions
+3. Use \`complete_fix_request\` when done
+
+---
+
+`;
+            }
+            if (filteredBugs.length === 0 && (!fixRequests || fixRequests.length === 0)) {
+                return `# No Open Bugs Found
+
+Great news! There are no open bugs or fix requests matching your criteria.
+
+${severity !== 'all' ? `Filtered by severity: ${severity}` : ''}
+${fileFilter ? `Filtered by file: ${fileFilter}` : ''}
+
+Use \`list_reports\` to see all reports including resolved ones.`;
+            }
+            const bugList = filteredBugs.map((b, i) => {
+                const ctx = b.code_context;
+                return `
+## ${i + 1}. [${b.severity?.toUpperCase()}] ${b.title}
+- **ID:** \`${b.id}\`
+- **Status:** ${b.status}
+- **File:** ${ctx?.file_path || 'Unknown'}${ctx?.line_number ? `:${ctx.line_number}` : ''}
+- **Description:** ${b.description.slice(0, 200)}${b.description.length > 200 ? '...' : ''}
+${ctx?.suggested_fix ? `- **Suggested Fix:** ${ctx.suggested_fix}` : ''}
+`;
+            }).join('\n');
+            return `${fixQueueSection}# Bug Fixing Session
+
+Found **${filteredBugs.length}** open bug(s) to fix.
+
+${bugList}
+
+---
+
+## Workflow
+
+1. **Read the bug details** - Use \`get_report\` with the bug ID for full context
+2. **Check the code** - Use \`get_bugs_for_file\` to see related issues
+3. **Fix the bug** - Make your code changes
+4. **Mark as fixed** - Use \`mark_fixed_with_commit\` after committing
+5. **Create regression test** - Use \`create_regression_test\` to prevent recurrence
+
+${fixRequests && fixRequests.length > 0 ? '**Start with the Fix Queue items above** - these have been specifically requested by users!' : "Let's start with the most critical bug. Which one would you like to tackle first?"}`;
+        }
+        case 'qa_check': {
+            const filesArg = args.files;
+            let filePaths = [];
+            if (filesArg) {
+                filePaths = filesArg.split(',').map(f => f.trim());
+            }
+            // If no files specified, we'll provide instructions
+            if (filePaths.length === 0) {
+                return `# QA Check Mode
+
+I'll analyze your changes for potential issues and related bugs.
+
+**To get started, tell me which files you've changed:**
+
+Option 1: Run \`git diff --name-only\` and provide the file list
+Option 2: Tell me which files you're working on
+
+Once I know the files, I'll:
+1. Check for known bugs in those files
+2. Look for related issues that might be affected
+3. Suggest test cases to verify your changes
+4. Identify potential problem patterns
+
+What files have you changed?`;
+            }
+            // Analyze the files
+            const analysis = await getBugsAffectingCode({ file_paths: filePaths });
+            return `# QA Check Results
+
+Analyzed **${filePaths.length}** file(s):
+${filePaths.map(f => `- ${f}`).join('\n')}
+
+## Bug Analysis
+
+${analysis.affected_bugs?.length > 0
+                ? `Found **${analysis.affected_bugs.length}** potentially affected bug(s):
+
+${analysis.affected_bugs.map((b) => `- [${b.severity.toUpperCase()}] ${b.title} (${b.match_type} match in ${b.matched_file})`).join('\n')}
+
+${analysis.warnings?.join('\n') || ''}
+`
+                : '✅ No known bugs affected by these changes.'}
+
+## Recommended Actions
+
+1. ${analysis.affected_bugs?.length > 0 ? 'Review the affected bugs above before pushing' : 'Proceed with your changes'}
+2. Use \`suggest_test_cases\` to generate tests for your changed files
+3. Consider running the app and manually testing the affected areas
+
+Would you like me to generate test cases for these files?`;
+        }
+        case 'regression_tests': {
+            const limit = parseInt(args.limit) || 5;
+            // Get recently resolved bugs
+            const { data: resolvedBugs } = await supabase
+                .from('reports')
+                .select('id, title, description, severity, resolved_at, code_context')
+                .eq('project_id', PROJECT_ID)
+                .eq('report_type', 'bug')
+                .eq('status', 'resolved')
+                .order('resolved_at', { ascending: false })
+                .limit(limit);
+            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;
+                const hasCommit = ctx?.fix && ctx.fix.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.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 = {
+                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.hotspots?.slice(0, 5).map((h) => `- **${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';
+    }
+}
+// Main server setup
+async function main() {
+    initSupabase();
+    const server = new index_js_1.Server({
+        name: 'bugbear-mcp',
+        version: '0.1.0',
+    }, {
+        capabilities: {
+            tools: {},
+            resources: {},
+            prompts: {},
+        },
+    });
+    // Handle tool listing
+    server.setRequestHandler(types_js_1.ListToolsRequestSchema, async () => ({
+        tools,
+    }));
+    // Handle tool execution
+    server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
+        const { name, arguments: args } = request.params;
+        try {
+            let result;
+            switch (name) {
+                case 'list_reports':
+                    result = await listReports(args);
+                    break;
+                case 'get_report':
+                    result = await getReport(args);
+                    break;
+                case 'search_reports':
+                    result = await searchReports(args);
+                    break;
+                case 'update_report_status':
+                    result = await updateReportStatus(args);
+                    break;
+                case 'get_report_context':
+                    result = await getReportContext(args);
+                    break;
+                case 'get_project_info':
+                    result = await getProjectInfo();
+                    break;
+                case 'get_qa_tracks':
+                    result = await getQaTracks();
+                    break;
+                case 'create_test_case':
+                    result = await createTestCase(args);
+                    break;
+                case 'update_test_case':
+                    result = await updateTestCase(args);
+                    break;
+                case 'list_test_cases':
+                    result = await listTestCases(args);
+                    break;
+                case 'get_bug_patterns':
+                    result = await getBugPatterns(args);
+                    break;
+                case 'analyze_changes_for_tests':
+                    result = await analyzeChangesForTests(args);
+                    break;
+                case 'suggest_test_cases':
+                    result = await suggestTestCases(args);
+                    break;
+                // === QA INTELLIGENCE TOOLS ===
+                case 'get_test_priorities':
+                    result = await getTestPriorities(args);
+                    break;
+                case 'get_coverage_gaps':
+                    result = await getCoverageGaps(args);
+                    break;
+                case 'get_regressions':
+                    result = await getRegressions(args);
+                    break;
+                case 'get_coverage_matrix':
+                    result = await getCoverageMatrix(args);
+                    break;
+                case 'get_stale_coverage':
+                    result = await getStaleCoverage(args);
+                    break;
+                case 'generate_deploy_checklist':
+                    result = await generateDeployChecklist(args);
+                    break;
+                case 'get_qa_health':
+                    result = await getQAHealth(args);
+                    break;
+                // === WRITE-BACK TOOLS ===
+                case 'create_bug_report':
+                    result = await createBugReport(args);
+                    break;
+                case 'get_bugs_for_file':
+                    result = await getBugsForFile(args);
+                    break;
+                case 'mark_fixed_with_commit':
+                    result = await markFixedWithCommit(args);
+                    break;
+                case 'get_bugs_affecting_code':
+                    result = await getBugsAffectingCode(args);
+                    break;
+                case 'link_bug_to_code':
+                    result = await linkBugToCode(args);
+                    break;
+                case 'create_regression_test':
+                    result = await createRegressionTest(args);
+                    break;
+                // === FIX QUEUE TOOLS ===
+                case 'get_pending_fixes':
+                    result = await getPendingFixes(args);
+                    break;
+                case 'claim_fix_request':
+                    result = await claimFixRequest(args);
+                    break;
+                case 'complete_fix_request':
+                    result = await completeFixRequest(args);
+                    break;
+                default:
+                    return {
+                        content: [{ type: 'text', text: `Unknown tool: ${name}` }],
+                        isError: true,
+                    };
+            }
+            return {
+                content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+            };
+        }
+        catch (err) {
+            return {
+                content: [{ type: 'text', text: `Error: ${err instanceof Error ? err.message : 'Unknown error'}` }],
+                isError: true,
+            };
+        }
+    });
+    // Handle resource listing (reports as resources)
+    server.setRequestHandler(types_js_1.ListResourcesRequestSchema, async () => {
+        const { data } = await supabase
+            .from('reports')
+            .select('id, description, report_type, severity')
+            .eq('project_id', PROJECT_ID)
+            .eq('status', 'new')
+            .order('created_at', { ascending: false })
+            .limit(10);
+        return {
+            resources: (data || []).map(r => ({
+                uri: `bugbear://reports/${r.id}`,
+                name: `[${r.severity?.toUpperCase() || 'N/A'}] ${r.description.slice(0, 50)}...`,
+                description: `${r.report_type} report`,
+                mimeType: 'application/json',
+            })),
+        };
+    });
+    // Handle prompt listing
+    server.setRequestHandler(types_js_1.ListPromptsRequestSchema, async () => ({
+        prompts,
+    }));
+    // Handle prompt execution
+    server.setRequestHandler(types_js_1.GetPromptRequestSchema, async (request) => {
+        const { name, arguments: args } = request.params;
+        const content = await generatePromptContent(name, args || {});
+        return {
+            description: prompts.find(p => p.name === name)?.description || '',
+            messages: [
+                {
+                    role: 'user',
+                    content: {
+                        type: 'text',
+                        text: content,
+                    },
+                },
+            ],
+        };
+    });
+    // Handle resource reading
+    server.setRequestHandler(types_js_1.ReadResourceRequestSchema, async (request) => {
+        const uri = request.params.uri;
+        const match = uri.match(/^bugbear:\/\/reports\/(.+)$/);
+        if (!match) {
+            throw new Error(`Invalid resource URI: ${uri}`);
+        }
+        const reportId = match[1];
+        const result = await getReport({ report_id: reportId });
+        return {
+            contents: [
+                {
+                    uri,
+                    mimeType: 'application/json',
+                    text: JSON.stringify(result, null, 2),
+                },
+            ],
+        };
+    });
+    // Start the server
+    const transport = new stdio_js_1.StdioServerTransport();
+    await server.connect(transport);
+    console.error('BugBear MCP server started');
+}
+main().catch((err) => {
+    console.error('Failed to start server:', err);
+    process.exit(1);
+});