@bbearai/mcp-server 0.6.0 → 0.7.1

package/dist/index.js

@@ -128,7 +128,7 @@ const tools = [
                 },
                 status: {
                     type: 'string',
-                    enum: ['new', 'triaging', 'confirmed', 'in_progress', 'fixed', 'resolved', 'verified', 'wont_fix', 'duplicate'],
+                    enum: ['new', 'triaging', 'confirmed', 'in_progress', 'fixed', 'ready_to_test', 'verified', 'resolved', 'reviewed', 'closed', 'wont_fix', 'duplicate'],
                     description: 'The new status for the report',
                 },
                 resolution_notes: {
@@ -141,7 +141,47 @@ const tools = [
     },
     {
         name: 'get_report_context',
-        description: 'Get the full debugging context for a report including console logs, network requests, and navigation history',
+        description: 'Get the full debugging context for a report including console logs, network requests, and navigation history. Use compact=true for app_context summary only (no console/network/navigation).',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                report_id: {
+                    type: 'string',
+                    description: 'The UUID of the report',
+                },
+                compact: {
+                    type: 'boolean',
+                    description: 'Compact mode: returns app_context only, skips console logs, network requests, and navigation history. (default: false)',
+                },
+            },
+            required: ['report_id'],
+        },
+    },
+    {
+        name: 'add_report_comment',
+        description: 'Add a comment/note to a bug report thread without changing its status. Use this for follow-up questions, investigation notes, or developer-tester communication.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                report_id: {
+                    type: 'string',
+                    description: 'The UUID of the report to comment on',
+                },
+                message: {
+                    type: 'string',
+                    description: 'The comment/note content',
+                },
+                author: {
+                    type: 'string',
+                    description: 'Optional author name (defaults to "Claude Code")',
+                },
+            },
+            required: ['report_id', 'message'],
+        },
+    },
+    {
+        name: 'get_report_comments',
+        description: 'Get all comments/notes on a bug report in chronological order. Returns the full discussion thread.',
         inputSchema: {
             type: 'object',
             properties: {
@@ -153,6 +193,25 @@ const tools = [
             required: ['report_id'],
         },
     },
+    {
+        name: 'resolve_conversations',
+        description: 'Mark one or more discussion threads as resolved (closed) or reopen them. Use this to close conversations after issues are addressed.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                thread_ids: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: 'UUIDs of the discussion threads to resolve/reopen',
+                },
+                resolved: {
+                    type: 'boolean',
+                    description: 'true to mark as resolved (default), false to reopen',
+                },
+            },
+            required: ['thread_ids'],
+        },
+    },
     {
         name: 'get_project_info',
         description: 'Get project information including QA tracks, test case counts, and common bug patterns',
@@ -308,7 +367,7 @@ const tools = [
     },
     {
         name: 'list_test_cases',
-        description: 'List all test cases in the project. Returns test_key, title, target_route, and other metadata. Use this to see existing tests before updating them.',
+        description: 'List all test cases in the project. Returns test_key, title, target_route, and other metadata. Use this to see existing tests before updating them. Use compact=true for id, test_key, title, and priority only (saves tokens).',
         inputSchema: {
             type: 'object',
             properties: {
@@ -333,6 +392,10 @@ const tools = [
                     type: 'number',
                     description: 'Offset for pagination (default 0)',
                 },
+                compact: {
+                    type: 'boolean',
+                    description: 'Compact mode: returns id, test_key, title, and priority only. (default: false)',
+                },
             },
         },
     },
@@ -441,7 +504,7 @@ const tools = [
                 },
                 notify_tester: {
                     type: 'boolean',
-                    description: 'If true, notify the original tester about the fix with a message and verification task. Default: false (silent resolve).',
+                    description: 'Notify the original tester about the fix with a message and verification task. Default: true. Set to false for silent resolve.',
                 },
             },
             required: ['report_id', 'commit_sha'],
@@ -683,17 +746,17 @@ const tools = [
     },
     {
         name: 'get_coverage_matrix',
-        description: 'Get a comprehensive Route × Track coverage matrix showing test counts, pass rates, and execution data. Use this for a complete view of test coverage.',
+        description: 'Get a comprehensive Route × Track coverage matrix showing test counts, pass rates, and execution data. Use this for a complete view of test coverage. Execution data and bug counts are opt-in to save tokens.',
         inputSchema: {
             type: 'object',
             properties: {
                 include_execution_data: {
                     type: 'boolean',
-                    description: 'Include pass/fail rates and last execution times (default: true)',
+                    description: 'Include pass/fail rates and last execution times (default: false). Set true when you need execution history.',
                 },
                 include_bug_counts: {
                     type: 'boolean',
-                    description: 'Include open/critical bug counts per route (default: true)',
+                    description: 'Include open/critical bug counts per route (default: false). Set true when you need bug context.',
                 },
             },
         },
@@ -927,6 +990,11 @@ const tools = [
                     enum: ['ios', 'android', 'web'],
                     description: 'Filter by platform support',
                 },
+                role: {
+                    type: 'string',
+                    enum: ['tester', 'feedback'],
+                    description: 'Filter by role: "tester" for QA testers, "feedback" for feedback-only users (default: all)',
+                },
             },
         },
     },
@@ -1015,6 +1083,21 @@ const tools = [
             required: ['tester_id', 'test_case_ids'],
         },
     },
+    {
+        name: 'unassign_tests',
+        description: 'Remove one or more test assignments by assignment ID. Preserves the test case and its history — only the assignment link is deleted. Use list_test_assignments first to find assignment IDs. Max 50 per call.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                assignment_ids: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: 'Array of test assignment UUIDs to remove (required, max 50)',
+                },
+            },
+            required: ['assignment_ids'],
+        },
+    },
     {
         name: 'get_tester_workload',
         description: 'View a specific tester\'s current workload — assignment counts by status and recent assignments.',
@@ -1057,6 +1140,11 @@ const tools = [
                     type: 'string',
                     description: 'Optional notes about the tester',
                 },
+                role: {
+                    type: 'string',
+                    enum: ['tester', 'feedback'],
+                    description: 'Role: "tester" for QA testers (default), "feedback" for feedback-only users',
+                },
             },
             required: ['name', 'email'],
         },
@@ -1159,7 +1247,7 @@ const tools = [
     },
     {
         name: 'export_test_results',
-        description: 'Export test results for a specific test run as structured JSON — includes every assignment, tester, result, and duration.',
+        description: 'Export test results for a specific test run as structured JSON — includes every assignment, tester, result, and duration. Use compact=true for summary only (no assignments array). Use limit to cap assignments returned.',
         inputSchema: {
             type: 'object',
             properties: {
@@ -1167,6 +1255,14 @@ const tools = [
                     type: 'string',
                     description: 'UUID of the test run to export (required)',
                 },
+                compact: {
+                    type: 'boolean',
+                    description: 'Compact mode: returns test run info + summary only, no assignments array. (default: false)',
+                },
+                limit: {
+                    type: 'number',
+                    description: 'Max assignments to return in full mode (default: 100, max: 500). Ignored when compact=true.',
+                },
             },
             required: ['test_run_id'],
         },
@@ -1215,7 +1311,610 @@ const tools = [
             properties: {},
         },
     },
+    // === TEST EXECUTION INTELLIGENCE ===
+    {
+        name: 'get_test_impact',
+        description: 'Given changed files, identify which test cases are affected by mapping file paths to test case target routes.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                changed_files: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: 'List of changed file paths (relative to project root)',
+                },
+            },
+            required: ['changed_files'],
+        },
+    },
+    {
+        name: 'get_flaky_tests',
+        description: 'Analyze test run history to identify tests with intermittent failure rates above a threshold.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                threshold: {
+                    type: 'number',
+                    description: 'Minimum flakiness rate to report (0-100, default: 5)',
+                },
+                limit: {
+                    type: 'number',
+                    description: 'Maximum results to return (default: 20)',
+                },
+            },
+        },
+    },
+    {
+        name: 'assess_test_quality',
+        description: 'Analyze test case steps for weak patterns: vague assertions, missing edge cases, no negative testing, generic descriptions.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                test_case_ids: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: 'Specific test case IDs to assess. If omitted, assesses recent test cases.',
+                },
+                limit: {
+                    type: 'number',
+                    description: 'Maximum test cases to assess (default: 20)',
+                },
+            },
+        },
+    },
+    {
+        name: 'get_test_execution_summary',
+        description: 'Aggregate test execution metrics: pass rate, completion rate, most-failed tests, fastest/slowest tests.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                days: {
+                    type: 'number',
+                    description: 'Number of days to analyze (default: 30)',
+                },
+            },
+        },
+    },
+    {
+        name: 'check_test_freshness',
+        description: 'Identify test cases that have not been updated since their target code was modified.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                limit: {
+                    type: 'number',
+                    description: 'Maximum results to return (default: 20)',
+                },
+            },
+        },
+    },
+    {
+        name: 'get_untested_changes',
+        description: 'Given recent commits or changed files, find code changes with no corresponding test coverage in BugBear.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                changed_files: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: 'List of changed file paths. If omitted, uses git diff against main.',
+                },
+            },
+        },
+    },
+    // === AUTO-MONITORING TOOLS ===
+    {
+        name: 'get_auto_detected_issues',
+        description: 'Get auto-detected monitoring issues grouped by error fingerprint. Shows recurring crashes, API failures, and rage clicks with frequency and user impact.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                source: {
+                    type: 'string',
+                    enum: ['auto_crash', 'auto_api', 'auto_rage_click'],
+                    description: 'Filter by source type',
+                },
+                min_occurrences: {
+                    type: 'number',
+                    description: 'Min occurrence count (default: 1)',
+                },
+                since: {
+                    type: 'string',
+                    description: 'ISO date — only issues after this date (default: 7 days ago)',
+                },
+                limit: {
+                    type: 'number',
+                    description: 'Max results (default: 20)',
+                },
+                compact: {
+                    type: 'boolean',
+                    description: 'Compact mode: fingerprint, source, count only',
+                },
+            },
+        },
+    },
+    {
+        name: 'generate_tests_from_errors',
+        description: 'Suggest QA test cases from auto-detected error patterns. Returns structured suggestions — does NOT auto-create test cases.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                report_ids: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: 'Specific report IDs. If omitted, uses top uncovered errors.',
+                },
+                limit: {
+                    type: 'number',
+                    description: 'Max suggestions (default: 5)',
+                },
+            },
+        },
+    },
 ];
+// === TEST EXECUTION INTELLIGENCE ===
+async function getTestImpact(args) {
+    const projectId = requireProject();
+    const changedFiles = args.changed_files || [];
+    if (changedFiles.length === 0) {
+        return { affectedTests: [], message: 'No changed files provided.' };
+    }
+    // Get all test cases for the project with their target routes
+    const { data: testCases, error } = await supabase
+        .from('test_cases')
+        .select('id, title, target_route, qa_track, priority')
+        .eq('project_id', projectId);
+    if (error)
+        return { error: error.message };
+    if (!testCases || testCases.length === 0) {
+        return { affectedTests: [], message: 'No test cases found for this project.' };
+    }
+    // Map changed files to affected test cases
+    const affected = [];
+    for (const tc of testCases) {
+        const route = tc.target_route || '';
+        const matchedFiles = changedFiles.filter(f => {
+            // Match file path to route (e.g., src/app/api/tasks/route.ts -> /api/tasks)
+            const normalized = f.replace(/\\/g, '/');
+            const routeParts = route.split('/').filter(Boolean);
+            return routeParts.some((part) => normalized.includes(part)) || normalized.includes(route.replace(/\//g, '/'));
+        });
+        if (matchedFiles.length > 0) {
+            affected.push({
+                testId: tc.id,
+                title: tc.title,
+                targetRoute: route,
+                matchedFiles,
+                qaTrack: tc.qa_track,
+            });
+        }
+    }
+    return {
+        affectedTests: affected,
+        totalTestCases: testCases.length,
+        affectedCount: affected.length,
+        changedFileCount: changedFiles.length,
+    };
+}
+async function getFlakyTests(args) {
+    const projectId = requireProject();
+    const threshold = args.threshold || 5;
+    const limit = args.limit || 20;
+    // Get test results grouped by test case
+    const { data: results, error } = await supabase
+        .from('test_results')
+        .select('test_case_id, status, test_cases!inner(title, target_route, qa_track)')
+        .eq('test_cases.project_id', projectId)
+        .order('created_at', { ascending: false })
+        .limit(5000);
+    if (error)
+        return { error: error.message };
+    if (!results || results.length === 0) {
+        return { flakyTests: [], message: 'No test results found.' };
+    }
+    // Group by test case and calculate flakiness
+    const testStats = {};
+    for (const r of results) {
+        const id = r.test_case_id;
+        if (!testStats[id]) {
+            const tc = r.test_cases;
+            testStats[id] = { passes: 0, fails: 0, total: 0, title: tc?.title || '', route: tc?.target_route || '', track: tc?.qa_track || '' };
+        }
+        testStats[id].total++;
+        if (r.status === 'pass')
+            testStats[id].passes++;
+        else if (r.status === 'fail')
+            testStats[id].fails++;
+    }
+    // Find flaky tests (have both passes and fails, with fail rate above threshold)
+    const flaky = Object.entries(testStats)
+        .filter(([, stats]) => {
+        if (stats.total < 3)
+            return false; // Need enough data
+        const failRate = (stats.fails / stats.total) * 100;
+        const passRate = (stats.passes / stats.total) * 100;
+        return failRate >= threshold && passRate > 0; // Has both passes and fails
+    })
+        .map(([id, stats]) => ({
+        testCaseId: id,
+        title: stats.title,
+        targetRoute: stats.route,
+        qaTrack: stats.track,
+        totalRuns: stats.total,
+        failRate: Math.round((stats.fails / stats.total) * 100),
+        passRate: Math.round((stats.passes / stats.total) * 100),
+    }))
+        .sort((a, b) => b.failRate - a.failRate)
+        .slice(0, limit);
+    return {
+        flakyTests: flaky,
+        totalAnalyzed: Object.keys(testStats).length,
+        flakyCount: flaky.length,
+        threshold,
+    };
+}
+async function assessTestQuality(args) {
+    const projectId = requireProject();
+    const limit = args.limit || 20;
+    let query = supabase
+        .from('test_cases')
+        .select('id, title, steps, target_route, qa_track, priority')
+        .eq('project_id', projectId)
+        .limit(limit);
+    if (args.test_case_ids && args.test_case_ids.length > 0) {
+        query = query.in('id', args.test_case_ids);
+    }
+    const { data: testCases, error } = await query;
+    if (error)
+        return { error: error.message };
+    if (!testCases || testCases.length === 0) {
+        return { assessments: [], message: 'No test cases found.' };
+    }
+    const assessments = testCases.map(tc => {
+        const issues = [];
+        const steps = tc.steps || [];
+        // Check for weak patterns
+        if (steps.length < 2) {
+            issues.push('Too few steps — test may not cover the full flow');
+        }
+        const allStepsText = steps.map((s) => (typeof s === 'string' ? s : s.action || s.description || '')).join(' ');
+        // Vague assertions
+        if (/should work|looks good|is correct|verify it works/i.test(allStepsText)) {
+            issues.push('Vague assertions detected — use specific expected outcomes');
+        }
+        // Missing edge cases
+        if (!/error|invalid|empty|missing|unauthorized|forbidden|404|500/i.test(allStepsText)) {
+            issues.push('No negative/error test cases — add edge case testing');
+        }
+        // Generic descriptions
+        if (/test the|check the|verify the/i.test(tc.title) && tc.title.length < 30) {
+            issues.push('Generic test title — be more specific about what is being tested');
+        }
+        // No specific UI elements referenced
+        if (!/button|input|form|modal|dropdown|select|click|type|enter|submit/i.test(allStepsText)) {
+            issues.push('No specific UI elements referenced — steps may be too abstract');
+        }
+        const quality = issues.length === 0 ? 'good' : issues.length <= 2 ? 'needs-improvement' : 'poor';
+        return {
+            testCaseId: tc.id,
+            title: tc.title,
+            targetRoute: tc.target_route,
+            stepCount: steps.length,
+            quality,
+            issues,
+        };
+    });
+    const qualityCounts = {
+        good: assessments.filter(a => a.quality === 'good').length,
+        needsImprovement: assessments.filter(a => a.quality === 'needs-improvement').length,
+        poor: assessments.filter(a => a.quality === 'poor').length,
+    };
+    return {
+        assessments,
+        summary: qualityCounts,
+        totalAssessed: assessments.length,
+    };
+}
+async function getTestExecutionSummary(args) {
+    const projectId = requireProject();
+    const days = args.days || 30;
+    const since = new Date(Date.now() - days * 24 * 60 * 60 * 1000).toISOString();
+    // Get test results
+    const { data: results, error } = await supabase
+        .from('test_results')
+        .select('test_case_id, status, duration_ms, created_at, test_cases!inner(title, target_route)')
+        .eq('test_cases.project_id', projectId)
+        .gte('created_at', since)
+        .order('created_at', { ascending: false });
+    if (error)
+        return { error: error.message };
+    if (!results || results.length === 0) {
+        return { message: `No test results found in the last ${days} days.` };
+    }
+    const totalRuns = results.length;
+    const passed = results.filter(r => r.status === 'pass').length;
+    const failed = results.filter(r => r.status === 'fail').length;
+    const blocked = results.filter(r => r.status === 'blocked').length;
+    // Most failed tests
+    const failCounts = {};
+    for (const r of results.filter(r => r.status === 'fail')) {
+        const id = r.test_case_id;
+        const tc = r.test_cases;
+        if (!failCounts[id]) {
+            failCounts[id] = { count: 0, title: tc?.title || '', route: tc?.target_route || '' };
+        }
+        failCounts[id].count++;
+    }
+    const mostFailed = Object.entries(failCounts)
+        .sort((a, b) => b[1].count - a[1].count)
+        .slice(0, 5)
+        .map(([id, data]) => ({ testCaseId: id, ...data }));
+    // Duration stats
+    const durations = results.filter(r => r.duration_ms).map(r => r.duration_ms);
+    const avgDuration = durations.length > 0 ? Math.round(durations.reduce((a, b) => a + b, 0) / durations.length) : 0;
+    const maxDuration = durations.length > 0 ? Math.max(...durations) : 0;
+    return {
+        period: `${days} days`,
+        totalRuns,
+        passRate: Math.round((passed / totalRuns) * 100),
+        failRate: Math.round((failed / totalRuns) * 100),
+        blockedCount: blocked,
+        averageDurationMs: avgDuration,
+        maxDurationMs: maxDuration,
+        mostFailed,
+        uniqueTestsCovered: new Set(results.map(r => r.test_case_id)).size,
+    };
+}
+async function checkTestFreshness(args) {
+    const projectId = requireProject();
+    const limit = args.limit || 20;
+    // Get test cases with their last update and last result
+    const { data: testCases, error } = await supabase
+        .from('test_cases')
+        .select('id, title, target_route, updated_at, created_at')
+        .eq('project_id', projectId)
+        .order('updated_at', { ascending: true })
+        .limit(limit);
+    if (error)
+        return { error: error.message };
+    if (!testCases || testCases.length === 0) {
+        return { staleTests: [], message: 'No test cases found.' };
+    }
+    const thirtyDaysAgo = new Date(Date.now() - 30 * 24 * 60 * 60 * 1000).toISOString();
+    const stale = testCases
+        .filter(tc => tc.updated_at < thirtyDaysAgo)
+        .map(tc => ({
+        testCaseId: tc.id,
+        title: tc.title,
+        targetRoute: tc.target_route,
+        lastUpdated: tc.updated_at,
+        daysSinceUpdate: Math.round((Date.now() - new Date(tc.updated_at).getTime()) / (24 * 60 * 60 * 1000)),
+    }));
+    return {
+        staleTests: stale,
+        totalTestCases: testCases.length,
+        staleCount: stale.length,
+        stalenessThreshold: '30 days',
+    };
+}
+async function getUntestedChanges(args) {
+    const projectId = requireProject();
+    // Get all test cases to understand what's covered
+    const { data: testCases, error } = await supabase
+        .from('test_cases')
+        .select('id, title, target_route')
+        .eq('project_id', projectId);
+    if (error)
+        return { error: error.message };
+    const coveredRoutes = new Set((testCases || []).map(tc => tc.target_route).filter(Boolean));
+    // If changed_files provided, check coverage
+    const changedFiles = args.changed_files || [];
+    if (changedFiles.length === 0) {
+        return {
+            message: 'No changed files provided. Pass changed_files to check coverage.',
+            totalCoveredRoutes: coveredRoutes.size,
+        };
+    }
+    // Map changed files to routes and check coverage
+    const untested = [];
+    for (const file of changedFiles) {
+        const normalized = file.replace(/\\/g, '/');
+        // Extract route-like path from file
+        let inferredRoute = '';
+        // Next.js app router: app/api/tasks/route.ts -> /api/tasks
+        const appRouterMatch = normalized.match(/app\/(api\/[^/]+(?:\/[^/]+)*?)\/route\.\w+$/);
+        if (appRouterMatch) {
+            inferredRoute = '/' + appRouterMatch[1];
+        }
+        // Pages router: pages/api/tasks.ts -> /api/tasks
+        const pagesMatch = normalized.match(/pages\/(api\/[^.]+)\.\w+$/);
+        if (!inferredRoute && pagesMatch) {
+            inferredRoute = '/' + pagesMatch[1];
+        }
+        // Component files
+        const componentMatch = normalized.match(/(?:components|screens|pages)\/([^.]+)\.\w+$/);
+        if (!inferredRoute && componentMatch) {
+            inferredRoute = '/' + componentMatch[1].replace(/\\/g, '/');
+        }
+        if (inferredRoute && !coveredRoutes.has(inferredRoute)) {
+            untested.push({
+                file,
+                inferredRoute,
+                reason: 'No test cases cover this route',
+            });
+        }
+        else if (!inferredRoute) {
+            // Can't map to a route — flag as potentially untested
+            untested.push({
+                file,
+                inferredRoute: 'unknown',
+                reason: 'Could not map file to a testable route',
+            });
+        }
+    }
+    return {
+        untestedChanges: untested,
+        changedFileCount: changedFiles.length,
+        untestedCount: untested.length,
+        coveredRoutes: coveredRoutes.size,
+    };
+}
+// === AUTO-MONITORING HANDLERS ===
+async function getAutoDetectedIssues(args) {
+    const projectId = requireProject();
+    const since = args.since || new Date(Date.now() - 7 * 24 * 60 * 60 * 1000).toISOString();
+    const limit = args.limit || 20;
+    let query = supabase
+        .from('reports')
+        .select('id, error_fingerprint, report_source, title, severity, reporter_id, sentry_event_id, created_at, app_context')
+        .eq('project_id', projectId)
+        .neq('report_source', 'manual')
+        .not('error_fingerprint', 'is', null)
+        .gte('created_at', since)
+        .order('created_at', { ascending: false });
+    if (args.source) {
+        query = query.eq('report_source', args.source);
+    }
+    const { data, error } = await query;
+    if (error)
+        return { error: error.message };
+    if (!data || data.length === 0)
+        return { issues: [], total: 0 };
+    // Group by fingerprint
+    const grouped = new Map();
+    for (const report of data) {
+        const fp = report.error_fingerprint;
+        if (!grouped.has(fp))
+            grouped.set(fp, []);
+        grouped.get(fp).push(report);
+    }
+    // Build issue summaries
+    const issues = Array.from(grouped.entries())
+        .map(([fingerprint, reports]) => {
+        const uniqueReporters = new Set(reports.map(r => r.reporter_id));
+        const sorted = reports.sort((a, b) => new Date(a.created_at).getTime() - new Date(b.created_at).getTime());
+        const first = sorted[0];
+        const last = sorted[sorted.length - 1];
+        const route = first.app_context?.currentRoute || 'unknown';
+        return {
+            fingerprint,
+            source: first.report_source,
+            message: first.title,
+            route,
+            occurrence_count: reports.length,
+            affected_users: uniqueReporters.size,
+            first_seen: first.created_at,
+            last_seen: last.created_at,
+            severity: first.severity,
+            has_sentry_link: reports.some(r => r.sentry_event_id != null),
+            sample_report_id: first.id,
+        };
+    })
+        .filter(issue => issue.occurrence_count >= (args.min_occurrences || 1))
+        .sort((a, b) => b.occurrence_count - a.occurrence_count)
+        .slice(0, limit);
+    if (args.compact) {
+        return {
+            issues: issues.map(i => ({
+                fingerprint: i.fingerprint,
+                source: i.source,
+                count: i.occurrence_count,
+                users: i.affected_users,
+                severity: i.severity,
+            })),
+            total: issues.length,
+        };
+    }
+    return { issues, total: issues.length };
+}
+async function generateTestsFromErrors(args) {
+    const projectId = requireProject();
+    const limit = args.limit || 5;
+    let reports;
+    if (args.report_ids?.length) {
+        // Validate all UUIDs
+        for (const id of args.report_ids) {
+            if (!isValidUUID(id)) {
+                return { error: `Invalid report_id format: ${id}` };
+            }
+        }
+        const { data, error } = await supabase
+            .from('reports')
+            .select('id, title, report_source, severity, app_context, error_fingerprint, description')
+            .eq('project_id', projectId)
+            .in('id', args.report_ids);
+        if (error)
+            return { error: error.message };
+        reports = data;
+    }
+    else {
+        // Get top uncovered auto-detected errors
+        const { data, error } = await supabase
+            .from('reports')
+            .select('id, title, report_source, severity, app_context, error_fingerprint, description')
+            .eq('project_id', projectId)
+            .neq('report_source', 'manual')
+            .not('error_fingerprint', 'is', null)
+            .order('created_at', { ascending: false })
+            .limit(50);
+        if (error)
+            return { error: error.message };
+        // Deduplicate by fingerprint, keep first occurrence
+        const seen = new Set();
+        reports = (data || []).filter(r => {
+            if (!r.error_fingerprint || seen.has(r.error_fingerprint))
+                return false;
+            seen.add(r.error_fingerprint);
+            return true;
+        }).slice(0, limit);
+    }
+    if (!reports?.length)
+        return { suggestions: [] };
+    const suggestions = reports.map(report => {
+        const route = report.app_context?.currentRoute || '/unknown';
+        const source = report.report_source;
+        const priority = report.severity === 'critical' ? 'P1' : report.severity === 'high' ? 'P1' : 'P2';
+        let suggestedSteps;
+        if (source === 'auto_crash') {
+            suggestedSteps = [
+                `Navigate to ${route}`,
+                'Reproduce the action that triggered the crash',
+                'Verify the page does not throw an unhandled error',
+                'Verify error boundary displays a user-friendly message if error occurs',
+            ];
+        }
+        else if (source === 'auto_api') {
+            const statusCode = report.app_context?.custom?.statusCode || 'error';
+            const method = report.app_context?.custom?.requestMethod || 'API';
+            suggestedSteps = [
+                `Navigate to ${route}`,
+                `Trigger the ${method} request that returned ${statusCode}`,
+                'Verify the request succeeds or displays an appropriate error message',
+                'Verify no data corruption occurs on failure',
+            ];
+        }
+        else {
+            // rage_click or sentry_sync
+            const target = report.app_context?.custom?.targetSelector || 'the element';
+            suggestedSteps = [
+                `Navigate to ${route}`,
+                `Click on ${target}`,
+                'Verify the element responds to interaction',
+                'Verify loading state is shown if action takes time',
+            ];
+        }
+        return {
+            title: `Test: ${report.title?.replace('[Auto] ', '') || 'Auto-detected issue'}`,
+            track: source === 'auto_crash' ? 'Stability' : source === 'auto_api' ? 'API' : 'UX',
+            priority,
+            rationale: `Auto-detected ${source?.replace('auto_', '')} on ${route}`,
+            suggested_steps: suggestedSteps,
+            source_report_id: report.id,
+            route,
+        };
+    });
+    return { suggestions };
+}
 // === Project management handlers ===
 async function listProjects() {
     const { data, error } = await supabase
@@ -1320,7 +2019,7 @@ async function getReport(args) {
             app_context: data.app_context,
             device_info: data.device_info,
             navigation_history: data.navigation_history,
-            screenshots: data.screenshots,
+            screenshot_urls: data.screenshot_urls,
             created_at: data.created_at,
             reporter: data.tester ? {
                 name: data.tester.name,
@@ -1395,22 +2094,118 @@ async function getReportContext(args) {
     }
     const { data, error } = await supabase
         .from('reports')
-        .select('app_context, device_info, navigation_history, enhanced_context')
+        .select('app_context, device_info, navigation_history, enhanced_context, screenshot_urls')
         .eq('id', args.report_id)
         .eq('project_id', currentProjectId) // Security: ensure report belongs to this project
         .single();
     if (error) {
         return { error: error.message };
     }
+    // Compact: return app_context only (skip console/network/navigation)
+    if (args.compact === true) {
+        return {
+            context: {
+                app_context: data.app_context,
+                screenshot_urls: data.screenshot_urls,
+            },
+        };
+    }
     return {
         context: {
             app_context: data.app_context,
             device_info: data.device_info,
             navigation_history: data.navigation_history,
             enhanced_context: data.enhanced_context || {},
+            screenshot_urls: data.screenshot_urls,
         },
     };
 }
+async function addReportComment(args) {
+    if (!isValidUUID(args.report_id))
+        return { error: 'Invalid report_id format' };
+    if (!args.message?.trim())
+        return { error: 'Message is required' };
+    // Verify report exists
+    const { data: report } = await supabase
+        .from('reports').select('id').eq('id', args.report_id).eq('project_id', currentProjectId).single();
+    if (!report)
+        return { error: 'Report not found' };
+    // Find or create a discussion thread for this report
+    const { data: existingThread } = await supabase
+        .from('discussion_threads').select('id')
+        .eq('project_id', currentProjectId).eq('report_id', args.report_id).eq('thread_type', 'report')
+        .limit(1).single();
+    let threadId;
+    if (existingThread) {
+        threadId = existingThread.id;
+    }
+    else {
+        const newId = crypto.randomUUID();
+        const { error: threadErr } = await supabase
+            .from('discussion_threads').insert({
+            id: newId, project_id: currentProjectId, report_id: args.report_id,
+            thread_type: 'report', subject: 'Bug Report Discussion', audience: 'all',
+            priority: 'normal', created_by_admin: true, last_message_at: new Date().toISOString(),
+        });
+        if (threadErr)
+            return { error: `Failed to create thread: ${threadErr.message}` };
+        threadId = newId;
+    }
+    const { data: msg, error: msgErr } = await supabase
+        .from('discussion_messages').insert({
+        thread_id: threadId, sender_type: 'admin', sender_name: args.author || 'Claude Code', content: args.message.trim(), content_type: 'text',
+    }).select('id, content, created_at').single();
+    if (msgErr)
+        return { error: `Failed to add comment: ${msgErr.message}` };
+    return { success: true, comment: { id: msg.id, thread_id: threadId, content: msg.content, author: args.author || 'Claude Code', created_at: msg.created_at }, message: 'Comment added to report' };
+}
+async function getReportComments(args) {
+    if (!isValidUUID(args.report_id))
+        return { error: 'Invalid report_id format' };
+    const { data: threads } = await supabase
+        .from('discussion_threads').select('id')
+        .eq('project_id', currentProjectId).eq('report_id', args.report_id).order('created_at', { ascending: true });
+    if (!threads || threads.length === 0)
+        return { comments: [], total: 0, message: 'No comments on this report' };
+    const { data: messages, error } = await supabase
+        .from('discussion_messages').select('id, thread_id, sender_type, content, content_type, created_at, attachments')
+        .in('thread_id', threads.map(t => t.id)).order('created_at', { ascending: true });
+    if (error)
+        return { error: error.message };
+    return { comments: (messages || []).map(m => ({ id: m.id, sender_type: m.sender_type, content: m.content, created_at: m.created_at, attachments: m.attachments })), total: (messages || []).length };
+}
+async function resolveConversations(args) {
+    if (!args.thread_ids || args.thread_ids.length === 0) {
+        return { error: 'At least one thread_id is required' };
+    }
+    if (args.thread_ids.length > 50) {
+        return { error: 'Maximum 50 threads per request' };
+    }
+    for (const id of args.thread_ids) {
+        if (!isValidUUID(id))
+            return { error: `Invalid thread_id format: ${id}` };
+    }
+    const resolved = args.resolved !== false;
+    const { data, error } = await supabase
+        .from('discussion_threads')
+        .update({ is_resolved: resolved })
+        .eq('project_id', currentProjectId)
+        .in('id', args.thread_ids)
+        .select('id, subject, is_resolved');
+    if (error)
+        return { error: error.message };
+    const updated = data || [];
+    const updatedIds = new Set(updated.map((t) => t.id));
+    const notFound = args.thread_ids.filter(id => !updatedIds.has(id));
+    return {
+        success: true,
+        updatedCount: updated.length,
+        resolved,
+        notFound: notFound.length > 0 ? notFound : undefined,
+        threads: updated.map((t) => ({ id: t.id, subject: t.subject, is_resolved: t.is_resolved })),
+        message: `${resolved ? 'Resolved' : 'Reopened'} ${updated.length} conversation(s).${notFound.length > 0 ? ` ${notFound.length} not found.` : ''}`,
+    };
+}
 async function getProjectInfo() {
     // Get project details
     const { data: project, error: projectError } = await supabase
@@ -1727,6 +2522,19 @@ async function listTestCases(args) {
     if (args.track) {
         testCases = testCases.filter((tc) => tc.track?.name?.toLowerCase().includes(args.track.toLowerCase()));
     }
+    // Compact: return minimal fields only
+    if (args.compact === true) {
+        return {
+            count: testCases.length,
+            testCases: testCases.map((tc) => ({
+                id: tc.id,
+                testKey: tc.test_key,
+                title: tc.title,
+                priority: tc.priority,
+            })),
+            pagination: { limit, offset, hasMore: testCases.length === limit },
+        };
+    }
     return {
         count: testCases.length,
         testCases: testCases.map((tc) => ({
@@ -2236,8 +3044,8 @@ async function getRegressions(args) {
     };
 }
 async function getCoverageMatrix(args) {
-    const includeExecution = args.include_execution_data !== false;
-    const includeBugs = args.include_bug_counts !== false;
+    const includeExecution = args.include_execution_data === true;
+    const includeBugs = args.include_bug_counts === true;
     // Get tracks
     const { data: tracks } = await supabase
         .from('qa_tracks')
@@ -3690,7 +4498,7 @@ async function markFixedWithCommit(args) {
         status: 'resolved',
         resolved_at: new Date().toISOString(),
         resolution_notes: args.resolution_notes || `Fixed in commit ${args.commit_sha.slice(0, 7)}`,
-        notify_tester: args.notify_tester === true, // Opt-in: only notify if explicitly requested
+        notify_tester: args.notify_tester !== false, // Default: notify tester. Pass false to silently resolve.
         code_context: {
             ...existingContext,
             fix: {
@@ -3710,7 +4518,8 @@ async function markFixedWithCommit(args) {
     if (error) {
         return { error: error.message };
     }
-    const notificationStatus = args.notify_tester
+    const notifyTester = args.notify_tester !== false;
+    const notificationStatus = notifyTester
         ? 'The original tester will be notified and assigned a verification task.'
         : 'No notification sent (silent resolve). A verification task was created.';
     return {
@@ -3718,7 +4527,7 @@ async function markFixedWithCommit(args) {
         message: `Bug marked as fixed in commit ${args.commit_sha.slice(0, 7)}. ${notificationStatus}`,
         report_id: args.report_id,
         commit: args.commit_sha,
-        tester_notified: args.notify_tester === true,
+        tester_notified: notifyTester,
         next_steps: [
             'Consider running create_regression_test to prevent this bug from recurring',
             'Push your changes to trigger CI/CD',
@@ -4443,12 +5252,15 @@ Which files or areas would you like me to analyze?`;
 async function listTesters(args) {
     let query = supabase
         .from('testers')
-        .select('id, name, email, status, platforms, tier, assigned_count, completed_count, notes, created_at')
+        .select('id, name, email, status, platforms, tier, assigned_count, completed_count, notes, role, created_at')
         .eq('project_id', currentProjectId)
         .order('name', { ascending: true });
     if (args.status) {
         query = query.eq('status', args.status);
     }
+    if (args.role) {
+        query = query.eq('role', args.role);
+    }
     const { data, error } = await query;
     if (error) {
         return { error: error.message };
@@ -4470,6 +5282,7 @@ async function listTesters(args) {
             assignedCount: t.assigned_count,
             completedCount: t.completed_count,
             notes: t.notes,
+            role: t.role,
         })),
     };
 }
@@ -4671,6 +5484,22 @@ async function assignTests(args) {
         test_run_id: args.test_run_id || null,
         status: 'pending',
     }));
+    // Helper: after assignments change, sync the test run's total_tests counter
+    async function syncRunCounter() {
+        if (!args.test_run_id)
+            return;
+        const { count } = await supabase
+            .from('test_assignments')
+            .select('id', { count: 'exact', head: true })
+            .eq('test_run_id', args.test_run_id)
+            .eq('project_id', currentProjectId);
+        if (count !== null) {
+            await supabase
+                .from('test_runs')
+                .update({ total_tests: count })
+                .eq('id', args.test_run_id);
+        }
+    }
     // Insert — use upsert-like approach: insert and handle conflicts
     const { data: inserted, error: insertErr } = await supabase
         .from('test_assignments')
@@ -4696,6 +5525,7 @@ async function assignTests(args) {
                     created.push(single);
                 }
             }
+            await syncRunCounter();
             return {
                 success: true,
                 created: created.length,
@@ -4707,6 +5537,7 @@ async function assignTests(args) {
         }
         return { error: insertErr.message };
     }
+    await syncRunCounter();
     return {
         success: true,
         created: (inserted || []).length,
@@ -4716,6 +5547,71 @@ async function assignTests(args) {
         message: `Assigned ${(inserted || []).length} test(s) to ${tester.name}.`,
     };
 }
+async function unassignTests(args) {
+    if (!args.assignment_ids || args.assignment_ids.length === 0) {
+        return { error: 'At least one assignment_id is required' };
+    }
+    if (args.assignment_ids.length > 50) {
+        return { error: 'Maximum 50 assignments per unassign batch' };
+    }
+    const invalidIds = args.assignment_ids.filter(id => !isValidUUID(id));
+    if (invalidIds.length > 0) {
+        return { error: `Invalid UUID(s): ${invalidIds.join(', ')}` };
+    }
+    // Verify assignments exist and belong to this project
+    const { data: existing, error: lookupErr } = await supabase
+        .from('test_assignments')
+        .select('id, test_run_id, test_case:test_cases(test_key, title), tester:testers(name)')
+        .eq('project_id', currentProjectId)
+        .in('id', args.assignment_ids);
+    if (lookupErr)
+        return { error: lookupErr.message };
+    if (!existing || existing.length === 0) {
+        return { error: 'No matching assignments found in this project' };
+    }
+    const foundIds = new Set(existing.map((a) => a.id));
+    const notFound = args.assignment_ids.filter(id => !foundIds.has(id));
+    // Delete the assignments
+    const { error: deleteErr } = await supabase
+        .from('test_assignments')
+        .delete()
+        .eq('project_id', currentProjectId)
+        .in('id', args.assignment_ids);
+    if (deleteErr)
+        return { error: deleteErr.message };
+    // Sync run counters for any affected test runs
+    const affectedRunIds = [...new Set(existing.filter((a) => a.test_run_id).map((a) => a.test_run_id))];
+    for (const runId of affectedRunIds) {
+        const { count } = await supabase
+            .from('test_assignments')
+            .select('id', { count: 'exact', head: true })
+            .eq('test_run_id', runId)
+            .eq('project_id', currentProjectId);
+        if (count !== null) {
+            await supabase.from('test_runs').update({ total_tests: count }).eq('id', runId);
+        }
+    }
+    const deleted = existing.map((a) => {
+        const tc = a.test_case;
+        const tester = a.tester;
+        return {
+            id: a.id,
+            testKey: tc?.test_key || null,
+            testTitle: tc?.title || null,
+            testerName: tester?.name || null,
+        };
+    });
+    const firstKey = deleted[0]?.testKey;
+    return {
+        success: true,
+        deletedCount: existing.length,
+        deleted,
+        notFound: notFound.length > 0 ? notFound : undefined,
+        message: existing.length === 1
+            ? `Removed 1 assignment${firstKey ? ` (${firstKey})` : ''}`
+            : `Removed ${existing.length} assignment(s)`,
+    };
+}
 async function getTesterWorkload(args) {
     if (!isValidUUID(args.tester_id)) {
         return { error: 'Invalid tester_id format' };
@@ -4815,8 +5711,9 @@ async function createTester(args) {
         tier: args.tier ?? 1,
         notes: args.notes?.trim() || null,
         status: 'active',
+        role: args.role || 'tester',
     })
-        .select('id, name, email, status, platforms, tier, notes, created_at')
+        .select('id, name, email, status, platforms, tier, notes, role, created_at')
         .single();
     if (error) {
         if (error.message.includes('duplicate') || error.message.includes('unique')) {
@@ -4834,6 +5731,7 @@ async function createTester(args) {
             platforms: data.platforms,
             tier: data.tier,
             notes: data.notes,
+            role: data.role,
             createdAt: data.created_at,
         },
         message: `Tester "${data.name}" added to the project. Use assign_tests to give them test cases.`,
@@ -5124,27 +6022,38 @@ async function exportTestResults(args) {
     const all = assignments || [];
     const passCount = all.filter(a => a.status === 'passed').length;
     const failCount = all.filter(a => a.status === 'failed').length;
+    const testRunInfo = {
+        id: run.id,
+        name: run.name,
+        description: run.description,
+        status: run.status,
+        startedAt: run.started_at,
+        completedAt: run.completed_at,
+        createdAt: run.created_at,
+    };
+    const summaryInfo = {
+        totalAssignments: all.length,
+        passed: passCount,
+        failed: failCount,
+        blocked: all.filter(a => a.status === 'blocked').length,
+        skipped: all.filter(a => a.status === 'skipped').length,
+        pending: all.filter(a => a.status === 'pending').length,
+        inProgress: all.filter(a => a.status === 'in_progress').length,
+        passRate: all.length > 0 ? Math.round((passCount / all.length) * 100) : 0,
+    };
+    // Compact: return test run info + summary only, no assignments array
+    if (args.compact === true) {
+        return { testRun: testRunInfo, summary: summaryInfo };
+    }
+    // Apply limit (default: 100, max: 500)
+    const assignmentLimit = Math.min(Math.max(args.limit ?? 100, 1), 500);
+    const limitedAssignments = all.slice(0, assignmentLimit);
     return {
-        testRun: {
-            id: run.id,
-            name: run.name,
-            description: run.description,
-            status: run.status,
-            startedAt: run.started_at,
-            completedAt: run.completed_at,
-            createdAt: run.created_at,
-        },
-        summary: {
-            totalAssignments: all.length,
-            passed: passCount,
-            failed: failCount,
-            blocked: all.filter(a => a.status === 'blocked').length,
-            skipped: all.filter(a => a.status === 'skipped').length,
-            pending: all.filter(a => a.status === 'pending').length,
-            inProgress: all.filter(a => a.status === 'in_progress').length,
-            passRate: all.length > 0 ? Math.round((passCount / all.length) * 100) : 0,
-        },
-        assignments: all.map((a) => ({
+        testRun: testRunInfo,
+        summary: summaryInfo,
+        assignmentsReturned: limitedAssignments.length,
+        assignmentsTotal: all.length,
+        assignments: limitedAssignments.map((a) => ({
             id: a.id,
             status: a.status,
             assignedAt: a.assigned_at,
@@ -5258,6 +6167,15 @@ async function main() {
                 case 'get_report_context':
                     result = await getReportContext(args);
                     break;
+                case 'add_report_comment':
+                    result = await addReportComment(args);
+                    break;
+                case 'get_report_comments':
+                    result = await getReportComments(args);
+                    break;
+                case 'resolve_conversations':
+                    result = await resolveConversations(args);
+                    break;
                 case 'get_project_info':
                     result = await getProjectInfo();
                     break;
@@ -5371,6 +6289,9 @@ async function main() {
                 case 'assign_tests':
                     result = await assignTests(args);
                     break;
+                case 'unassign_tests':
+                    result = await unassignTests(args);
+                    break;
                 case 'get_tester_workload':
                     result = await getTesterWorkload(args);
                     break;
@@ -5406,6 +6327,32 @@ async function main() {
                 case 'get_current_project':
                     result = getCurrentProject();
                     break;
+                // === TEST EXECUTION INTELLIGENCE ===
+                case 'get_test_impact':
+                    result = await getTestImpact(args);
+                    break;
+                case 'get_flaky_tests':
+                    result = await getFlakyTests(args);
+                    break;
+                case 'assess_test_quality':
+                    result = await assessTestQuality(args);
+                    break;
+                case 'get_test_execution_summary':
+                    result = await getTestExecutionSummary(args);
+                    break;
+                case 'check_test_freshness':
+                    result = await checkTestFreshness(args);
+                    break;
+                case 'get_untested_changes':
+                    result = await getUntestedChanges(args);
+                    break;
+                // === AUTO-MONITORING TOOLS ===
+                case 'get_auto_detected_issues':
+                    result = await getAutoDetectedIssues(args);
+                    break;
+                case 'generate_tests_from_errors':
+                    result = await generateTestsFromErrors(args);
+                    break;
                 default:
                     return {
                         content: [{ type: 'text', text: `Unknown tool: ${name}` }],