@yasserkhanorg/impact-gate 2.0.0 → 2.1.0

package/dist/esm/qa-agent/phase2/agent_loop.js

@@ -6,6 +6,7 @@ import { AgentBrowser } from './agent_browser.js';
 import { TOOL_DEFINITIONS, executeTool } from './tools.js';
 import { createExplorationState, recordAction, recordFinding, markFlowExplored, nextFlow, isStuck, isBudgetExhausted, allFlowsExplored, updateCost, compressActionsLog, } from './exploration_state.js';
 import { analyzeScreenshot } from './vision.js';
+import { computeHealthScore } from '../health_score.js';
 const MAX_ITERATIONS = 200;
 const COMPRESS_EVERY = 20;
 const MAX_LLM_RETRIES = 2;
@@ -45,11 +46,21 @@ For each flow, pick 3-4 of the most relevant dimensions based on what the flow d
 
 Pick dimensions that matter for THIS flow. Example: for "channel settings" → permissions + edge cases + state persistence. For "messaging" → happy path + error recovery + console health. Do NOT mechanically follow all 7.
 
+## Finding Categories
+When reporting findings, use the most specific category:
+- **visual** — Layout breaks, broken images, z-index issues, alignment, animation glitches, dark mode problems
+- **functional** — Broken links, dead buttons, form validation failures, incorrect redirects, race conditions, state not persisting
+- **ux** — Confusing navigation, missing loading indicators, slow interactions (>500ms), unclear error messages, no confirmation before destructive actions
+- **content** — Typos, grammar errors, placeholder/lorem ipsum left in, truncated text, wrong labels
+- **performance** — Slow page loads (>3s), janky scrolling, layout shifts (CLS), excessive network requests
+- **console** — JavaScript exceptions, failed network requests (4xx/5xx), CORS errors, mixed content warnings
+- **accessibility** — Missing alt text, unlabeled inputs, broken keyboard navigation, focus traps, insufficient contrast
+
 ## Rules
 1. Use the accessibility snapshot (provided after each action) to understand the page.
 2. Use click/fill/press_key to interact. References look like @e1, @e2, etc.
 3. Use wait_for to wait for elements to appear/disappear or for the page to settle after actions.
-4. Report findings immediately with report_finding — include severity, expected vs actual behavior, and repro steps.
+4. Report findings immediately with report_finding — use the specific category above, include severity, expected vs actual behavior, and repro steps.
 5. When you find a bug: take a screenshot BEFORE triggering the action and AFTER. Include expected vs actual behavior in the finding.
 6. Mark flows done with mark_flow_done when you've tested them thoroughly.
 7. Use take_screenshot sparingly — only for evidence of bugs or new flow entry.
@@ -329,6 +340,7 @@ export async function runAgentLoop(config, flows) {
         tokensUsed: state.tokensUsed,
         costUSD: state.costUSD,
         durationMs: Date.now() - state.startTime,
+        healthScore: computeHealthScore(state.findings),
     };
 }
 async function runVisionPass(config, state, browser, screenshotDir) {

package/dist/esm/qa-agent/phase2/tools.js

@@ -1,5 +1,6 @@
 // Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
 // See LICENSE.txt for license information.
+import { normalizeFindingType } from '../finding_taxonomy.js';
 // ---------------------------------------------------------------------------
 // Tool definitions (Anthropic tool_use schema)
 // ---------------------------------------------------------------------------
@@ -94,11 +95,11 @@ export const TOOL_DEFINITIONS = [
     },
     {
         name: 'report_finding',
-        description: 'Report a bug, visual issue, UX problem, or gap you discovered. Include expected/actual behavior and repro steps. Take before/after screenshots before calling this.',
+        description: 'Report a finding. Categories: visual (layout/images/alignment), functional (broken links/buttons/forms/state), ux (navigation/loading/error messages), content (typos/placeholder text/labels), performance (slow loads/layout shifts), console (JS errors/network failures), accessibility (alt text/keyboard nav/ARIA/contrast). Legacy types (bug, visual-regression, ux-issue, gap) are also accepted.',
         input_schema: {
             type: 'object',
             properties: {
-                type: { type: 'string', enum: ['bug', 'visual-regression', 'ux-issue', 'gap'] },
+                type: { type: 'string', enum: ['visual', 'functional', 'ux', 'content', 'performance', 'console', 'accessibility', 'bug', 'visual-regression', 'ux-issue', 'gap'] },
                 severity: { type: 'string', enum: ['critical', 'high', 'medium', 'low', 'info'] },
                 summary: { type: 'string', description: 'What you found' },
                 repro_steps: {
@@ -215,13 +216,18 @@ export function executeTool(ctx, name, input) {
             return { output: text || '(empty)' };
         }
         case 'report_finding': {
-            const VALID_TYPES = new Set(['bug', 'visual-regression', 'ux-issue', 'gap']);
+            const VALID_TYPES = new Set([
+                'visual', 'functional', 'ux', 'content', 'performance', 'console', 'accessibility',
+                'bug', 'visual-regression', 'ux-issue', 'gap',
+            ]);
             const VALID_SEVERITIES = new Set(['critical', 'high', 'medium', 'low', 'info']);
             const rawType = String(input.type);
             const rawSeverity = String(input.severity);
             if (!VALID_TYPES.has(rawType)) {
                 return { output: `Invalid finding type "${rawType}". Must be one of: ${[...VALID_TYPES].join(', ')}.` };
             }
+            // Normalize legacy types to canonical categories for health scoring
+            const canonicalType = normalizeFindingType(rawType);
             if (!VALID_SEVERITIES.has(rawSeverity)) {
                 return { output: `Invalid severity "${rawSeverity}". Must be one of: ${[...VALID_SEVERITIES].join(', ')}.` };
             }
@@ -260,7 +266,7 @@ export function executeTool(ctx, name, input) {
             }
             const finding = {
                 id: `f-${crypto.randomUUID()}`,
-                type: rawType,
+                type: canonicalType,
                 severity: rawSeverity,
                 summary: String(input.summary),
                 flow: ctx.currentFlow,

package/dist/esm/qa-agent/phase25/fix_loop.js

@@ -0,0 +1,238 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+import Anthropic from '@anthropic-ai/sdk';
+import { logger } from '../../logger.js';
+import { computeHealthScore } from '../health_score.js';
+import { isFixable } from '../finding_taxonomy.js';
+import { FIX_TOOL_DEFINITIONS, executeFixTool } from './fix_tools.js';
+import { WTFTracker } from './wtf_heuristic.js';
+const MAX_ITERATIONS_PER_FIX = 15;
+// Pricing per 1M tokens by model prefix
+const MODEL_PRICING = {
+    'claude-sonnet': { input: 3, output: 15 },
+    'claude-haiku': { input: 0.25, output: 1.25 },
+    'claude-opus': { input: 15, output: 75 },
+};
+function getPricing(model) {
+    for (const [prefix, pricing] of Object.entries(MODEL_PRICING)) {
+        if (model.startsWith(prefix))
+            return pricing;
+    }
+    return { input: 3, output: 15 };
+}
+function buildFixSystemPrompt(finding, baseUrl) {
+    const evidence = finding.evidence;
+    return `You are a bug-fix engineer. Fix the following QA finding with the MINIMAL code change needed.
+
+## Finding
+- **ID:** ${finding.id}
+- **Type:** ${finding.type}
+- **Severity:** ${finding.severity}
+- **Summary:** ${finding.summary}
+- **URL:** ${evidence.url}
+- **Expected:** ${evidence.expectedBehavior || 'Not specified'}
+- **Actual:** ${evidence.actualBehavior || 'Not specified'}
+- **Repro steps:** ${evidence.reproSteps.map((s, i) => `${i + 1}. ${s}`).join('\n')}
+${evidence.consoleErrors?.length ? `- **Console errors:** ${evidence.consoleErrors.join('; ')}` : ''}
+
+## Workflow
+1. Use search_code to find the responsible source file(s)
+2. Use read_file to understand the code
+3. Use write_file to make the minimal fix
+4. Use run_command to check types (npx tsc --noEmit) or lint
+5. Use git_commit to create an atomic commit: fix(qa): ${finding.id} — {description}
+6. Use verify_in_browser to navigate to ${evidence.url} and check the fix worked
+
+## Rules
+- Make the SMALLEST change that fixes the issue. Do NOT refactor surrounding code.
+- Only modify files directly related to the bug.
+- If you can't find the source after 3 search attempts, report that the fix is not possible.
+- If type checking fails after your fix, revert with git_revert.
+- The base URL is ${baseUrl}.
+- When done, respond with text only (no tool use) explaining the result.`;
+}
+export async function runFixLoop(config, findings, browser, projectRoot) {
+    const startTime = Date.now();
+    const tier = config.fixTier || 'standard';
+    const fixes = [];
+    const wtf = new WTFTracker();
+    let tokensUsed = 0;
+    let costUSD = 0;
+    // Budget: 40% of remaining total budget
+    const budgetUSD = config.budgetUSD * 0.4;
+    const healthScoreBefore = computeHealthScore(findings);
+    // Sort by severity (critical first) and filter by tier
+    const fixable = findings
+        .filter((f) => isFixable(f, tier))
+        .sort((a, b) => severityOrder(a.severity) - severityOrder(b.severity));
+    if (fixable.length === 0) {
+        logger.info('No fixable findings for tier', { tier });
+        return {
+            fixes: [],
+            fixesAttempted: 0,
+            fixesVerified: 0,
+            fixesBestEffort: 0,
+            fixesReverted: 0,
+            fixesSkipped: 0,
+            healthScoreBefore,
+            healthScoreAfter: healthScoreBefore,
+            durationMs: 0,
+            tokensUsed: 0,
+            costUSD: 0,
+        };
+    }
+    logger.info(`Fix loop: ${fixable.length} findings to fix (tier: ${tier})`);
+    const client = new Anthropic();
+    const model = process.env.QA_AGENT_MODEL || 'claude-sonnet-4-5-20250929';
+    const screenshotDir = config.screenshotDir || '.e2e-ai-agents/qa-screenshots';
+    const toolCtx = {
+        projectRoot,
+        browser,
+        baseUrl: config.baseUrl,
+        screenshotDir,
+        screenshotCounter: 100, // Start at 100 to avoid collisions with Phase 2 screenshots
+    };
+    for (const finding of fixable) {
+        if (wtf.shouldStop()) {
+            logger.warn(`WTF heuristic triggered (score: ${wtf.score}), stopping fix loop`);
+            // Mark remaining as skipped
+            fixes.push({ findingId: finding.id, status: 'skipped' });
+            continue;
+        }
+        if (costUSD >= budgetUSD) {
+            logger.info('Fix loop budget exhausted');
+            fixes.push({ findingId: finding.id, status: 'skipped' });
+            continue;
+        }
+        logger.info(`Fixing: [${finding.severity}] ${finding.summary}`);
+        const result = await fixSingleFinding(client, model, config, finding, toolCtx);
+        fixes.push(result.fix);
+        tokensUsed += result.tokensUsed;
+        costUSD += result.costUSD;
+        wtf.recordAttempt(result.fix.status, result.fix.filesChanged?.length || 0);
+    }
+    const healthScoreAfter = computeHealthScore(findings);
+    return {
+        fixes,
+        fixesAttempted: fixes.filter((f) => f.status !== 'skipped').length,
+        fixesVerified: fixes.filter((f) => f.status === 'verified').length,
+        fixesBestEffort: fixes.filter((f) => f.status === 'best-effort').length,
+        fixesReverted: fixes.filter((f) => f.status === 'reverted').length,
+        fixesSkipped: fixes.filter((f) => f.status === 'skipped').length,
+        healthScoreBefore,
+        healthScoreAfter,
+        durationMs: Date.now() - startTime,
+        tokensUsed,
+        costUSD,
+    };
+}
+async function fixSingleFinding(client, model, config, finding, toolCtx) {
+    const messages = [];
+    let tokensUsed = 0;
+    let costUSD = 0;
+    let commitHash;
+    let filesChanged = [];
+    let beforeScreenshot;
+    let afterScreenshot;
+    let status = 'skipped';
+    // Take "before" screenshot
+    try {
+        toolCtx.screenshotCounter++;
+        const label = `before-fix-${finding.id.slice(-6)}`;
+        const path = `${toolCtx.screenshotDir}/${String(toolCtx.screenshotCounter).padStart(3, '0')}-${label}.png`;
+        toolCtx.browser.open(finding.evidence.url.startsWith('http') ? finding.evidence.url : `${config.baseUrl}${finding.evidence.url}`);
+        toolCtx.browser.screenshot(path);
+        beforeScreenshot = path;
+    }
+    catch {
+        // Non-critical
+    }
+    messages.push({ role: 'user', content: 'Fix the finding described in the system prompt. Start by searching for the relevant source code.' });
+    for (let iteration = 0; iteration < MAX_ITERATIONS_PER_FIX; iteration++) {
+        let response;
+        try {
+            response = await client.messages.create({
+                model,
+                max_tokens: 4096,
+                system: buildFixSystemPrompt(finding, config.baseUrl),
+                tools: FIX_TOOL_DEFINITIONS,
+                messages,
+            });
+        }
+        catch (err) {
+            logger.warn('Fix LLM call failed', { error: String(err) });
+            status = 'skipped';
+            break;
+        }
+        // Track cost
+        const usage = response.usage;
+        const pricing = getPricing(model);
+        const inputCost = (usage.input_tokens / 1000000) * pricing.input;
+        const outputCost = (usage.output_tokens / 1000000) * pricing.output;
+        tokensUsed += usage.input_tokens + usage.output_tokens;
+        costUSD += inputCost + outputCost;
+        const assistantContent = response.content;
+        messages.push({ role: 'assistant', content: assistantContent });
+        // If no tool use, the agent is done
+        const toolUseBlocks = assistantContent.filter((b) => b.type === 'tool_use');
+        if (toolUseBlocks.length === 0) {
+            // Determine status from what happened
+            if (commitHash) {
+                status = afterScreenshot ? 'verified' : 'best-effort';
+            }
+            break;
+        }
+        // Execute tools
+        const toolResults = [];
+        for (const block of toolUseBlocks) {
+            if (block.type !== 'tool_use')
+                continue;
+            const result = executeFixTool(toolCtx, block.name, block.input);
+            if (result.commitHash && block.name === 'git_commit') {
+                commitHash = result.commitHash;
+            }
+            if (result.filesChanged) {
+                filesChanged = [...filesChanged, ...result.filesChanged];
+            }
+            if (result.screenshotPath && block.name === 'verify_in_browser') {
+                afterScreenshot = result.screenshotPath;
+            }
+            if (block.name === 'git_revert') {
+                status = 'reverted';
+                commitHash = undefined;
+                filesChanged = [];
+            }
+            toolResults.push({
+                type: 'tool_result',
+                tool_use_id: block.id,
+                content: result.output,
+            });
+        }
+        messages.push({ role: 'user', content: toolResults });
+    }
+    // If we have a commit but didn't get classified yet
+    if (status === 'skipped' && commitHash) {
+        status = 'best-effort';
+    }
+    return {
+        fix: {
+            findingId: finding.id,
+            status,
+            commitHash,
+            filesChanged: [...new Set(filesChanged)],
+            beforeScreenshot,
+            afterScreenshot,
+        },
+        tokensUsed,
+        costUSD,
+    };
+}
+function severityOrder(severity) {
+    switch (severity) {
+        case 'critical': return 0;
+        case 'high': return 1;
+        case 'medium': return 2;
+        case 'low': return 3;
+        default: return 4;
+    }
+}

package/dist/esm/qa-agent/phase25/fix_tools.js

@@ -0,0 +1,262 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+import { execFileSync } from 'child_process';
+import { readFileSync, writeFileSync, existsSync } from 'fs';
+import { resolve, relative, sep } from 'path';
+// ---------------------------------------------------------------------------
+// Tool definitions for the fix agent (Anthropic tool_use schema)
+// ---------------------------------------------------------------------------
+export const FIX_TOOL_DEFINITIONS = [
+    {
+        name: 'read_file',
+        description: 'Read the contents of a source file. Use startLine/endLine for large files.',
+        input_schema: {
+            type: 'object',
+            properties: {
+                path: { type: 'string', description: 'Relative path from project root' },
+                start_line: { type: 'number', description: 'First line to read (1-based, optional)' },
+                end_line: { type: 'number', description: 'Last line to read (inclusive, optional)' },
+            },
+            required: ['path'],
+        },
+    },
+    {
+        name: 'write_file',
+        description: 'Write content to a file. For patches, read the file first, modify, and write back.',
+        input_schema: {
+            type: 'object',
+            properties: {
+                path: { type: 'string', description: 'Relative path from project root' },
+                content: { type: 'string', description: 'Full file content to write' },
+            },
+            required: ['path', 'content'],
+        },
+    },
+    {
+        name: 'search_code',
+        description: 'Search for a pattern in the codebase using grep. Returns matching lines with file paths and line numbers.',
+        input_schema: {
+            type: 'object',
+            properties: {
+                pattern: { type: 'string', description: 'Search pattern (regex supported)' },
+                glob: { type: 'string', description: 'File glob to restrict search (e.g. "*.tsx", "src/**/*.ts")' },
+            },
+            required: ['pattern'],
+        },
+    },
+    {
+        name: 'run_command',
+        description: 'Run an allowlisted shell command (e.g. type checking, build, lint). Not for arbitrary commands.',
+        input_schema: {
+            type: 'object',
+            properties: {
+                command: { type: 'string', description: 'Command to run (must be allowlisted)' },
+            },
+            required: ['command'],
+        },
+    },
+    {
+        name: 'git_commit',
+        description: 'Stage changed files and create an atomic commit.',
+        input_schema: {
+            type: 'object',
+            properties: {
+                message: { type: 'string', description: 'Commit message (format: fix(qa): ISSUE-{id} — {description})' },
+                files: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: 'Files to stage (relative paths)',
+                },
+            },
+            required: ['message', 'files'],
+        },
+    },
+    {
+        name: 'git_revert',
+        description: 'Revert the most recent commit (HEAD).',
+        input_schema: {
+            type: 'object',
+            properties: {},
+            required: [],
+        },
+    },
+    {
+        name: 'verify_in_browser',
+        description: 'Navigate to a URL and take a screenshot to verify a fix. Returns the screenshot path and any console errors.',
+        input_schema: {
+            type: 'object',
+            properties: {
+                url: { type: 'string', description: 'URL to navigate to for verification' },
+                label: { type: 'string', description: 'Label for the screenshot (e.g. "after-fix-001")' },
+            },
+            required: ['url', 'label'],
+        },
+    },
+];
+// ---------------------------------------------------------------------------
+// Security: path and command validation
+// ---------------------------------------------------------------------------
+const BLOCKED_PATHS = new Set(['.env', '.env.local', '.env.production', 'node_modules']);
+function isPathSafe(projectRoot, filePath) {
+    const resolved = resolve(projectRoot, filePath);
+    const rel = relative(projectRoot, resolved);
+    // Must stay within project
+    if (rel.startsWith('..') || rel.startsWith(sep)) {
+        return false;
+    }
+    // Block sensitive files and directories
+    const parts = rel.split(sep);
+    for (const part of parts) {
+        if (BLOCKED_PATHS.has(part)) {
+            return false;
+        }
+    }
+    return true;
+}
+const COMMAND_ALLOWLIST = [
+    /^npx tsc\b/,
+    /^npx eslint\b/,
+    /^npm run (build|lint|typecheck|check)\b/,
+    /^npx playwright test\b/,
+];
+function isCommandAllowed(command) {
+    return COMMAND_ALLOWLIST.some((re) => re.test(command.trim()));
+}
+// ---------------------------------------------------------------------------
+// Tool execution
+// ---------------------------------------------------------------------------
+export function executeFixTool(ctx, name, input) {
+    switch (name) {
+        case 'read_file': {
+            const filePath = String(input.path);
+            if (!isPathSafe(ctx.projectRoot, filePath)) {
+                return { output: `Blocked: "${filePath}" is outside the project or a restricted path.` };
+            }
+            const fullPath = resolve(ctx.projectRoot, filePath);
+            if (!existsSync(fullPath)) {
+                return { output: `File not found: ${filePath}` };
+            }
+            const content = readFileSync(fullPath, 'utf-8');
+            const lines = content.split('\n');
+            const startLine = Math.max(1, Number(input.start_line) || 1);
+            const endLine = Math.min(lines.length, Number(input.end_line) || lines.length);
+            const slice = lines.slice(startLine - 1, endLine);
+            const numbered = slice.map((l, i) => `${startLine + i}: ${l}`).join('\n');
+            return { output: numbered };
+        }
+        case 'write_file': {
+            const filePath = String(input.path);
+            if (!isPathSafe(ctx.projectRoot, filePath)) {
+                return { output: `Blocked: "${filePath}" is outside the project or a restricted path.` };
+            }
+            const fullPath = resolve(ctx.projectRoot, filePath);
+            writeFileSync(fullPath, String(input.content), 'utf-8');
+            return { output: `Written: ${filePath}`, filesChanged: [filePath] };
+        }
+        case 'search_code': {
+            const pattern = String(input.pattern);
+            const glob = input.glob ? String(input.glob) : undefined;
+            try {
+                const args = ['-rn', '--max-count=20', pattern];
+                if (glob) {
+                    args.push('--include', glob);
+                }
+                args.push('.');
+                const result = execFileSync('grep', args, {
+                    cwd: ctx.projectRoot,
+                    encoding: 'utf-8',
+                    timeout: 10000,
+                    maxBuffer: 1024 * 1024,
+                });
+                return { output: result.trim() || 'No matches found.' };
+            }
+            catch (err) {
+                const error = err;
+                if (error.status === 1) {
+                    return { output: 'No matches found.' };
+                }
+                return { output: `Search error: ${String(err)}` };
+            }
+        }
+        case 'run_command': {
+            const command = String(input.command).trim();
+            if (!isCommandAllowed(command)) {
+                return { output: `Blocked: "${command}" is not in the allowlist. Allowed: npx tsc, npx eslint, npm run build/lint/typecheck/check, npx playwright test.` };
+            }
+            try {
+                const parts = command.split(/\s+/);
+                const result = execFileSync(parts[0], parts.slice(1), {
+                    cwd: ctx.projectRoot,
+                    encoding: 'utf-8',
+                    timeout: 60000,
+                    maxBuffer: 2 * 1024 * 1024,
+                });
+                return { output: result.trim() || '(no output)' };
+            }
+            catch (err) {
+                const error = err;
+                const stdout = error.stdout || '';
+                const stderr = error.stderr || '';
+                return { output: `Command failed:\n${stdout}\n${stderr}`.trim() };
+            }
+        }
+        case 'git_commit': {
+            const message = String(input.message);
+            const files = Array.isArray(input.files) ? input.files.map(String) : [];
+            if (files.length === 0) {
+                return { output: 'No files specified for commit.' };
+            }
+            // Validate all files are safe
+            for (const f of files) {
+                if (!isPathSafe(ctx.projectRoot, f)) {
+                    return { output: `Blocked: "${f}" is outside the project or a restricted path.` };
+                }
+            }
+            try {
+                execFileSync('git', ['add', ...files], { cwd: ctx.projectRoot, encoding: 'utf-8' });
+                execFileSync('git', ['commit', '-m', message], { cwd: ctx.projectRoot, encoding: 'utf-8' });
+                const hash = execFileSync('git', ['rev-parse', '--short', 'HEAD'], { cwd: ctx.projectRoot, encoding: 'utf-8' }).trim();
+                return { output: `Committed: ${hash} — ${message}`, commitHash: hash, filesChanged: files };
+            }
+            catch (err) {
+                const error = err;
+                return { output: `Git commit failed: ${error.stderr || String(err)}` };
+            }
+        }
+        case 'git_revert': {
+            try {
+                execFileSync('git', ['revert', '--no-edit', 'HEAD'], { cwd: ctx.projectRoot, encoding: 'utf-8' });
+                const hash = execFileSync('git', ['rev-parse', '--short', 'HEAD'], { cwd: ctx.projectRoot, encoding: 'utf-8' }).trim();
+                return { output: `Reverted HEAD. New HEAD: ${hash}`, commitHash: hash };
+            }
+            catch (err) {
+                const error = err;
+                return { output: `Git revert failed: ${error.stderr || String(err)}` };
+            }
+        }
+        case 'verify_in_browser': {
+            const url = String(input.url);
+            const label = String(input.label || 'verify').replace(/[^a-zA-Z0-9_-]/g, '_');
+            ctx.screenshotCounter++;
+            const filename = `${String(ctx.screenshotCounter).padStart(3, '0')}-${label}.png`;
+            const screenshotPath = `${ctx.screenshotDir}/${filename}`;
+            ctx.browser.open(url.startsWith('http') ? url : `${ctx.baseUrl}${url}`);
+            ctx.browser.screenshot(screenshotPath);
+            // Capture console errors
+            let consoleErrors = '';
+            try {
+                const raw = ctx.browser.evaluateInternal('JSON.stringify(window.__consoleErrors || [])');
+                const errors = JSON.parse(raw);
+                if (Array.isArray(errors) && errors.length > 0) {
+                    consoleErrors = `\nConsole errors: ${errors.slice(-5).join('; ')}`;
+                }
+            }
+            catch {
+                // Not available
+            }
+            return { output: `Screenshot saved: ${screenshotPath}${consoleErrors}`, screenshotPath };
+        }
+        default:
+            return { output: `Unknown fix tool: ${name}` };
+    }
+}

package/dist/esm/qa-agent/phase25/wtf_heuristic.js

@@ -0,0 +1,60 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+/**
+ * Tracks fix-loop health using a WTF-likelihood heuristic.
+ *
+ * Accumulates risk based on:
+ *  - Each revert: +15%
+ *  - Each fix touching >3 files: +5%
+ *  - After fix #15: +1% per additional fix
+ *  - All-low-severity batch: +10%
+ *  - Touching files outside the affected area: +20%
+ *
+ * When WTF > 20%, the fix loop should stop.
+ */
+export class WTFTracker {
+    constructor() {
+        this.wtf = 0;
+        this.totalFixes = 0;
+        this.consecutiveReverts = 0;
+    }
+    recordAttempt(status, filesChanged) {
+        this.totalFixes++;
+        if (status === 'reverted') {
+            this.wtf += 15;
+            this.consecutiveReverts++;
+        }
+        else {
+            this.consecutiveReverts = 0;
+        }
+        if (filesChanged > 3) {
+            this.wtf += 5;
+        }
+        if (this.totalFixes > 15) {
+            this.wtf += 1;
+        }
+    }
+    recordUnrelatedFileTouch() {
+        this.wtf += 20;
+    }
+    recordAllLowSeverityBatch() {
+        this.wtf += 10;
+    }
+    shouldStop() {
+        if (this.totalFixes >= WTFTracker.MAX_FIXES) {
+            return true;
+        }
+        if (this.consecutiveReverts >= 3) {
+            return true;
+        }
+        return this.wtf > 20;
+    }
+    get score() {
+        return this.wtf;
+    }
+    get fixes() {
+        return this.totalFixes;
+    }
+}
+/** Hard cap — stop regardless after this many fixes. */
+WTFTracker.MAX_FIXES = 50;