laxy-verify 1.2.2 → 1.2.3

package/dist/cli.js

@@ -58,8 +58,18 @@ const report_markdown_js_1 = require("./report-markdown.js");
 const visual_diff_js_1 = require("./visual-diff.js");
 const security_audit_js_1 = require("./security-audit.js");
 const broken_links_js_1 = require("./audit/broken-links.js");
+const typecheck_js_1 = require("./typecheck.js");
+const secret_scan_js_1 = require("./secret-scan.js");
+const bundle_size_js_1 = require("./bundle-size.js");
+const outdated_check_js_1 = require("./outdated-check.js");
+const a11y_deep_js_1 = require("./a11y-deep.js");
+const seo_deep_js_1 = require("./seo-deep.js");
+const vitals_budget_js_1 = require("./vitals-budget.js");
 const index_js_1 = require("./verification-core/index.js");
 const trend_js_1 = require("./trend.js");
+const ai_analysis_js_1 = require("./ai-analysis.js");
+const compare_env_js_1 = require("./compare-env.js");
+const route_discovery_js_1 = require("./route-discovery.js");
 const package_json_1 = __importDefault(require("../package.json"));
 let activeDevServerPid;
 let activeDevServerCleanup = null;
@@ -161,12 +171,38 @@ function parseArgs() {
         port: flags.port !== undefined ? Number(flags.port) : undefined,
         share: flags.share !== undefined,
         help: flags.help !== undefined || flags.h !== undefined,
+        compareUrl: flags.compare,
+        typecheck: flags.typecheck !== undefined,
+        secretScan: flags["secret-scan"] !== undefined,
+        bundleSize: flags["bundle-size"] !== undefined,
+        outdatedCheck: flags["outdated-check"] !== undefined,
+        a11yDeep: flags["a11y-deep"] !== undefined,
+        seoDeep: flags["seo-deep"] !== undefined,
+        vitalsBudget: flags["vitals-budget"] !== undefined,
     };
 }
 function writeResultFile(projectDir, result) {
     const filePath = path.join(projectDir, ".laxy-result.json");
     fs.writeFileSync(filePath, JSON.stringify(result, null, 2) + "\n", "utf-8");
 }
+function uniqueRouteList(routes) {
+    const seen = new Set();
+    const result = [];
+    for (const route of routes) {
+        if (!route)
+            continue;
+        const normalized = route.startsWith("/") ? route : `/${route}`;
+        const trimmed = normalized.split("?")[0]?.split("#")[0]?.replace(/\/+/g, "/") ?? "/";
+        const finalRoute = trimmed.endsWith("/") && trimmed !== "/" ? trimmed.slice(0, -1) : trimmed;
+        if (finalRoute === "/" || finalRoute.startsWith("/api/") || finalRoute.startsWith("/_next/"))
+            continue;
+        if (seen.has(finalRoute))
+            continue;
+        seen.add(finalRoute);
+        result.push(finalRoute);
+    }
+    return result;
+}
 function summarizeViewportIssues(scores, thresholds) {
     if (!scores)
         return { count: 0 };
@@ -208,12 +244,30 @@ function consoleOutput(result) {
         const lh = result.lighthouse;
         const t = result.thresholds;
         const check = (passed) => (passed ? " OK" : " FAIL");
-        console.log("  Lighthouse:");
+        const routeLabel = result.lighthouseRoutes && result.lighthouseRoutes.length > 1
+            ? ` (weighted avg of ${result.lighthouseRoutes.length} routes)`
+            : "";
+        console.log(`  Lighthouse${routeLabel}:`);
         console.log(`    Performance:     ${lh.performance} / ${t.performance}${check(lh.performance >= t.performance)}`);
         console.log(`    Accessibility:   ${lh.accessibility} / ${t.accessibility}${check(lh.accessibility >= t.accessibility)}`);
         console.log(`    SEO:             ${lh.seo} / ${t.seo}${check(lh.seo >= t.seo)}`);
         console.log(`    Best Practices:  ${lh.bestPractices} / ${t.bestPractices}${check(lh.bestPractices >= t.bestPractices)}`);
         console.log(`    Runs:            ${lh.runs}`);
+        if (result.lighthouseRoutes && result.lighthouseRoutes.length > 1) {
+            console.log("    Per-route:");
+            for (const r of result.lighthouseRoutes) {
+                if (r.scores) {
+                    const pass = r.scores.performance >= t.performance &&
+                        r.scores.accessibility >= t.accessibility &&
+                        r.scores.seo >= t.seo &&
+                        r.scores.bestPractices >= t.bestPractices;
+                    console.log(`      ${r.route.padEnd(20)} P=${r.scores.performance} A=${r.scores.accessibility} S=${r.scores.seo} BP=${r.scores.bestPractices}${pass ? "" : "  FAIL"}`);
+                }
+                else {
+                    console.log(`      ${r.route.padEnd(20)} (no data)`);
+                }
+            }
+        }
     }
     else {
         console.log("  Lighthouse: skipped");
@@ -238,6 +292,27 @@ function consoleOutput(result) {
         const ml = result.mobileLighthouse;
         console.log(`  Mobile LH: P=${ml.performance} A=${ml.accessibility} SEO=${ml.seo} BP=${ml.bestPractices}`);
     }
+    if (result.typecheck && !result.typecheck.skipped) {
+        console.log(`  TypeScript: ${result.typecheck.passed ? "OK" : `${result.typecheck.errorCount} error(s)`}`);
+    }
+    if (result.secretScan && !result.secretScan.skipped) {
+        console.log(`  Secret scan: ${result.secretScan.passed ? "OK" : `${result.secretScan.findings.length} finding(s)`} (${result.secretScan.filesScanned} files)`);
+    }
+    if (result.bundleSize && !result.bundleSize.skipped) {
+        console.log(`  Bundle size: ${result.bundleSize.advisory}`);
+    }
+    if (result.outdatedCheck && !result.outdatedCheck.skipped) {
+        console.log(`  Outdated: ${result.outdatedCheck.advisory}`);
+    }
+    if (result.a11yDeep && !result.a11yDeep.skipped) {
+        console.log(`  A11y deep: ${result.a11yDeep.summary}`);
+    }
+    if (result.seoDeep && !result.seoDeep.skipped) {
+        console.log(`  SEO deep: ${result.seoDeep.summary}`);
+    }
+    if (result.vitalsBudget && !result.vitalsBudget.skipped) {
+        console.log(`  Vitals budget: ${result.vitalsBudget.summary}`);
+    }
     if (result.verification) {
         const view = result.verification.view;
         const verboseFailure = result._verbose_failure ?? true;
@@ -293,6 +368,9 @@ function consoleOutput(result) {
         if (result.github.status === "status_set")
             console.log(`  Status check: ${result.github.grade}`);
     }
+    if (result.compareEnv) {
+        (0, compare_env_js_1.printEnvComparison)(result.compareEnv);
+    }
     console.log("  Result: .laxy-result.json");
     if (result.markdownReportPath) {
         console.log(`  Report: ${path.basename(result.markdownReportPath)}`);
@@ -329,10 +407,18 @@ async function run() {
     --skip-lighthouse Skip Lighthouse but still run build and E2E
     --port <port>     Use an already-running dev server on this port (skip build & server start)
     --share           Create a public share link for this verification result (Pro)
+    --compare <url>   Compare Lighthouse scores against a reference environment URL (Pro)
     --plan-override   free | pro | team (testing metadata only)
     --multi-viewport  Lighthouse on desktop/tablet/mobile
-    --crawl           Crawl the app to discover routes before E2E
+    --crawl           Crawl the app to discover routes before E2E (also enables multi-route Lighthouse)
     --badge           Print shields.io badge markdown
+    --typecheck       Run TypeScript type check (tsc --noEmit)
+    --secret-scan     Scan for hardcoded secrets and credentials
+    --bundle-size     Analyze bundle size (Next.js/Vite)
+    --outdated-check  Check for outdated dependencies
+    --a11y-deep       Deep accessibility audit (axe-core)
+    --seo-deep        Deep SEO audit (meta, OG, JSON-LD)
+    --vitals-budget   Core Web Vitals budget check (LCP, CLS, INP)
     --help            Show this help
 
   Exit codes:
@@ -347,6 +433,7 @@ async function run() {
     npx laxy-verify . --fail-on silver  # Block Bronze or worse
     npx laxy-verify . --port 3001       # Use existing dev server on port 3001
     npx laxy-verify . --share           # Save and share a public verification link
+    npx laxy-verify . --compare https://staging.example.com  # Compare vs reference env (Pro)
 
   Docs: https://github.com/SUNgm24/Laxy/tree/main/laxy-verify
 `);
@@ -437,6 +524,13 @@ async function run() {
             cliFlags: {
                 failOn: args.failOn,
                 skipLighthouse: args.skipLighthouse,
+                typecheck: args.typecheck,
+                secretScan: args.secretScan,
+                bundleSize: args.bundleSize,
+                outdatedCheck: args.outdatedCheck,
+                a11yDeep: args.a11yDeep,
+                seoDeep: args.seoDeep,
+                vitalsBudget: args.vitalsBudget,
             },
             teamThresholds,
         });
@@ -446,6 +540,21 @@ async function run() {
         exitGracefully(2);
         return;
     }
+    if (args.compareUrl) {
+        try {
+            const u = new URL(args.compareUrl);
+            if (!["http:", "https:"].includes(u.protocol)) {
+                console.error(`Config error: --compare URL must use http or https protocol: ${args.compareUrl}`);
+                exitGracefully(2);
+                return;
+            }
+        }
+        catch {
+            console.error(`Config error: --compare value is not a valid URL: ${args.compareUrl}`);
+            exitGracefully(2);
+            return;
+        }
+    }
     let detected;
     try {
         detected = (0, detect_js_1.detect)(args.projectDir);
@@ -517,11 +626,11 @@ async function run() {
     }
     const features = entitlements ?? {
         plan: "free",
-        // All verification features run on every plan
-        // Automation features ??not available on Free
         github_actions: false,
         queue_priority: false,
         parallel_execution: false,
+        ai_failure_analysis: false,
+        compare_env: false,
     };
     let effectiveFeatures = features;
     if (args.planOverride) {
@@ -539,17 +648,28 @@ async function run() {
     if (config.lighthouse_runs < 3) {
         config = { ...config, lighthouse_runs: 3 };
     }
+    let multiRouteLhResult = null;
     let multiViewportScores = null;
     let allViewportsOk = false;
     let e2eResult;
     let crossBrowserResults;
     let e2eCoverageGaps = [];
     let e2eConsoleErrors = [];
+    let lastCrawlRoutes = [];
+    let runtimeDiscoveredRoutes = [];
     let e2eStabilityPassed = true;
     let visualDiffResult = null;
     let securityAuditResult = null;
     let mobileLighthouseScores = null;
     let brokenLinksResult = null;
+    let compareEnvResult = null;
+    let typecheckResult = null;
+    let secretScanResult = null;
+    let bundleSizeResult = null;
+    let outdatedCheckResult = null;
+    let a11yDeepResult = null;
+    let seoDeepResult = null;
+    let vitalsBudgetResult = null;
     const failureEvidence = [];
     if (buildResult.success) {
         let servePid;
@@ -559,13 +679,37 @@ async function run() {
                 servePid = serve.pid;
                 activeDevServerPid = serve.pid;
             }
-            const verifyUrl = `http://127.0.0.1:${port}/`;
+            const verifyUrl = `http://localhost:${port}/`;
             const verificationTier = (0, index_js_1.planToVerificationTier)(effectiveFeatures.plan);
+            try {
+                const runtimeRouteDiscovery = await (0, route_discovery_js_1.discoverRuntimeRoutes)(verifyUrl);
+                runtimeDiscoveredRoutes = runtimeRouteDiscovery.routes;
+                if (runtimeDiscoveredRoutes.length > 0) {
+                    console.log(`  Runtime route discovery: found ${runtimeDiscoveredRoutes.length} route(s) from app bundles.`);
+                }
+            }
+            catch (routeErr) {
+                console.error(`Runtime route discovery warning: ${routeErr instanceof Error ? routeErr.message : String(routeErr)}`);
+            }
             if (!args.skipLighthouse) {
                 try {
-                    const lhResult = await (0, lighthouse_js_1.runLighthouse)(port, config.lighthouse_runs);
-                    lighthouseErrorCount = lhResult.errors.length;
-                    scores = lhResult.scores ?? undefined;
+                    const explicitRoutes = config.lighthouse_routes?.length
+                        ? config.lighthouse_routes
+                        : config.extra_routes?.length
+                            ? config.extra_routes
+                            : undefined;
+                    if (explicitRoutes && explicitRoutes.length > 0) {
+                        // Multi-route mode: run on all explicitly configured routes
+                        multiRouteLhResult = await (0, lighthouse_js_1.runLighthouseOnRoutes)(port, config.lighthouse_runs, explicitRoutes);
+                        lighthouseErrorCount = multiRouteLhResult.perRoute.reduce((n, r) => n + r.errors.length, 0);
+                        scores = multiRouteLhResult.aggregated ?? undefined;
+                    }
+                    else {
+                        // Single-route mode (default): root only
+                        const lhResult = await (0, lighthouse_js_1.runLighthouse)(port, config.lighthouse_runs);
+                        lighthouseErrorCount = lhResult.errors.length;
+                        scores = lhResult.scores ?? undefined;
+                    }
                     if (scores) {
                         lighthouseResult = {
                             performance: scores.performance,
@@ -599,8 +743,10 @@ async function run() {
             }
             // Security audit (npm audit)
             try {
-                securityAuditResult = await (0, security_audit_js_1.runSecurityAudit)(args.projectDir);
-                if (securityAuditResult.critical > 0 || securityAuditResult.high > 0) {
+                securityAuditResult = await (0, security_audit_js_1.runSecurityAudit)(args.projectDir, verifyUrl);
+                if (securityAuditResult.critical > 0 ||
+                    securityAuditResult.high > 0 ||
+                    securityAuditResult.missingHeaders.length > 0) {
                     failureEvidence.push(`Security: ${securityAuditResult.summary}`);
                 }
             }
@@ -630,11 +776,22 @@ async function run() {
                         const unique = crawlConsoleErrors.filter((e) => !e2eConsoleErrors.includes(e));
                         e2eConsoleErrors = [...e2eConsoleErrors, ...unique];
                     }
+                    // Store crawl-discovered routes for post-E2E Lighthouse pass
+                    lastCrawlRoutes = e2eRuns.crawlResult.pages
+                        .map((p) => p.path)
+                        .filter((p) => typeof p === "string" && p.startsWith("/"));
                 }
                 // Broken links audit — runs after E2E so we have the crawl result
-                if (e2eRuns.crawlResult && e2eRuns.crawlResult.totalLinks > 0) {
+                const auditRoutes = uniqueRouteList([
+                    ...(config.extra_routes ?? []),
+                    ...runtimeDiscoveredRoutes,
+                    ...lastCrawlRoutes,
+                ]);
+                if (e2eRuns.crawlResult || auditRoutes.length > 0) {
                     try {
-                        brokenLinksResult = await (0, broken_links_js_1.auditBrokenLinks)(e2eRuns.crawlResult, verifyUrl);
+                        brokenLinksResult = await (0, broken_links_js_1.auditBrokenLinks)(e2eRuns.crawlResult, verifyUrl, {
+                            extraRoutes: auditRoutes,
+                        });
                         if (brokenLinksResult.hasBrokenLinks) {
                             failureEvidence.push(`Broken links: ${brokenLinksResult.summary}`);
                         }
@@ -670,6 +827,34 @@ async function run() {
             catch (e2eErr) {
                 console.error(`E2E error: ${e2eErr instanceof Error ? e2eErr.message : String(e2eErr)}`);
             }
+            // Crawl-based multi-route Lighthouse (only if no explicit lighthouse_routes configured)
+            if (!args.skipLighthouse &&
+                !config.lighthouse_routes?.length &&
+                uniqueRouteList([
+                    ...(config.extra_routes ?? []),
+                    ...runtimeDiscoveredRoutes,
+                    ...lastCrawlRoutes,
+                ]).length > 1) {
+                try {
+                    const crawlRoutes = uniqueRouteList([
+                        ...(config.extra_routes ?? []),
+                        ...runtimeDiscoveredRoutes,
+                        ...lastCrawlRoutes,
+                    ]).slice(0, config.max_lighthouse_routes);
+                    console.log(`\n  Running Lighthouse on ${crawlRoutes.length} discovered routes...`);
+                    multiRouteLhResult = await (0, lighthouse_js_1.runLighthouseOnRoutes)(port, config.lighthouse_runs, crawlRoutes);
+                    if (multiRouteLhResult.aggregated) {
+                        scores = multiRouteLhResult.aggregated;
+                        lighthouseResult = {
+                            ...multiRouteLhResult.aggregated,
+                            runs: config.lighthouse_runs,
+                        };
+                    }
+                }
+                catch (crawlLhErr) {
+                    console.error(`Crawl-based Lighthouse error: ${crawlLhErr instanceof Error ? crawlLhErr.message : String(crawlLhErr)}`);
+                }
+            }
             // Cross-browser E2E via Playwright (if non-chromium browsers configured)
             const extraBrowsers = (config.browsers || []).filter((b) => b !== "chromium" && ["firefox", "webkit"].includes(b));
             if (extraBrowsers.length > 0 && lastE2EScenarios && lastE2EScenarios.length > 0) {
@@ -694,11 +879,118 @@ async function run() {
                 }
             }
             try {
-                visualDiffResult = await (0, visual_diff_js_1.runVisualDiff)(args.projectDir, verifyUrl, "verify");
+                visualDiffResult = await (0, visual_diff_js_1.runVisualDiff)(args.projectDir, verifyUrl, "verify", {
+                    pixelmatchThreshold: config.visual_diff.pixelmatchThreshold,
+                    warnThreshold: config.visual_diff.warnThreshold,
+                    rollbackThreshold: config.visual_diff.rollbackThreshold,
+                    ignoreSelectors: config.visual_diff.ignoreSelectors,
+                    disableAnimations: config.visual_diff.disableAnimations,
+                });
             }
             catch (visualErr) {
                 console.error(`Visual diff error: ${visualErr instanceof Error ? visualErr.message : String(visualErr)}`);
             }
+            // Mobile Lighthouse (standalone — not part of multi-viewport)
+            if (!args.skipLighthouse && !args.multiViewport) {
+                try {
+                    mobileLighthouseScores = await (0, multi_viewport_js_1.runMobileLighthouse)(port);
+                }
+                catch (mlErr) {
+                    console.error(`Mobile Lighthouse error: ${mlErr instanceof Error ? mlErr.message : String(mlErr)}`);
+                }
+            }
+            // TypeScript type check
+            if (config.typecheck) {
+                try {
+                    typecheckResult = await (0, typecheck_js_1.runTypecheck)(args.projectDir);
+                    if (!typecheckResult.skipped && !typecheckResult.passed) {
+                        failureEvidence.push(`TypeScript: ${typecheckResult.errorCount} type error(s)`);
+                    }
+                }
+                catch (tcErr) {
+                    console.error(`Typecheck error: ${tcErr instanceof Error ? tcErr.message : String(tcErr)}`);
+                }
+            }
+            // Secret scan
+            if (config.secret_scan) {
+                try {
+                    secretScanResult = await (0, secret_scan_js_1.runSecretScan)(args.projectDir, {
+                        ignorePaths: config.secret_scan_ignore_paths,
+                    });
+                    if (!secretScanResult.skipped && !secretScanResult.passed) {
+                        failureEvidence.push(`Secret scan: ${secretScanResult.findings.length} finding(s)`);
+                    }
+                }
+                catch (ssErr) {
+                    console.error(`Secret scan error: ${ssErr instanceof Error ? ssErr.message : String(ssErr)}`);
+                }
+            }
+            // Bundle size analysis (advisory)
+            if (config.bundle_size) {
+                try {
+                    bundleSizeResult = await (0, bundle_size_js_1.runBundleSize)(args.projectDir);
+                }
+                catch (bsErr) {
+                    console.error(`Bundle size error: ${bsErr instanceof Error ? bsErr.message : String(bsErr)}`);
+                }
+            }
+            // Outdated dependency check (advisory)
+            if (config.outdated_check) {
+                try {
+                    outdatedCheckResult = await (0, outdated_check_js_1.runOutdatedCheck)(args.projectDir);
+                }
+                catch (ocErr) {
+                    console.error(`Outdated check error: ${ocErr instanceof Error ? ocErr.message : String(ocErr)}`);
+                }
+            }
+            // Deep accessibility audit (axe-core)
+            if (config.a11y_deep) {
+                try {
+                    a11yDeepResult = await (0, a11y_deep_js_1.runA11yDeep)(verifyUrl);
+                    if (!a11yDeepResult.skipped && !a11yDeepResult.passed) {
+                        failureEvidence.push(`A11y deep: ${a11yDeepResult.summary}`);
+                    }
+                }
+                catch (a11yErr) {
+                    console.error(`A11y deep error: ${a11yErr instanceof Error ? a11yErr.message : String(a11yErr)}`);
+                }
+            }
+            // Deep SEO audit
+            if (config.seo_deep) {
+                try {
+                    seoDeepResult = await (0, seo_deep_js_1.runSeoDeep)(verifyUrl);
+                    if (!seoDeepResult.skipped && !seoDeepResult.passed) {
+                        failureEvidence.push(`SEO deep: ${seoDeepResult.summary}`);
+                    }
+                }
+                catch (seoErr) {
+                    console.error(`SEO deep error: ${seoErr instanceof Error ? seoErr.message : String(seoErr)}`);
+                }
+            }
+            // Core Web Vitals budget check
+            if (config.vitals_budget) {
+                try {
+                    vitalsBudgetResult = await (0, vitals_budget_js_1.runVitalsBudget)(verifyUrl);
+                    if (!vitalsBudgetResult.skipped && !vitalsBudgetResult.passed) {
+                        failureEvidence.push(`Vitals budget: ${vitalsBudgetResult.summary}`);
+                    }
+                }
+                catch (vbErr) {
+                    console.error(`Vitals budget error: ${vbErr instanceof Error ? vbErr.message : String(vbErr)}`);
+                }
+            }
+            // Pro: multi-environment comparison
+            if (effectiveFeatures.compare_env && args.compareUrl) {
+                try {
+                    compareEnvResult = await (0, compare_env_js_1.runEnvComparison)(port, args.compareUrl, 1);
+                }
+                catch (cmpErr) {
+                    console.error(`Env comparison error: ${cmpErr instanceof Error ? cmpErr.message : String(cmpErr)}`);
+                }
+            }
+            else if (args.compareUrl && !effectiveFeatures.compare_env) {
+                console.log("  [warn] --compare requires a logged-in Pro account. Skipping env comparison.");
+            }
         }
         catch (serveErr) {
             console.error(`Dev server error: ${serveErr instanceof Error ? serveErr.message : String(serveErr)}`);
@@ -711,6 +1003,21 @@ async function run() {
     }
     const verificationTier = (0, index_js_1.planToVerificationTier)(effectiveFeatures.plan);
     const viewportSummary = summarizeViewportIssues(multiViewportScores, adjustedThresholds);
+    // Multi-route Lighthouse: add per-route failures to evidence
+    const allRoutesPass = multiRouteLhResult
+        ? multiRouteLhResult.allRoutesPass(adjustedThresholds)
+        : true;
+    if (multiRouteLhResult && !allRoutesPass) {
+        const failingRoutes = multiRouteLhResult.perRoute.filter((r) => r.scores !== null &&
+            (r.scores.performance < adjustedThresholds.performance ||
+                r.scores.accessibility < adjustedThresholds.accessibility ||
+                r.scores.seo < adjustedThresholds.seo ||
+                r.scores.bestPractices < adjustedThresholds.bestPractices));
+        for (const fr of failingRoutes.slice(0, 3)) {
+            const s = fr.scores;
+            failureEvidence.push(`Lighthouse ${fr.route}: P=${s.performance} A=${s.accessibility} SEO=${s.seo} BP=${s.bestPractices}`);
+        }
+    }
     failureEvidence.push(...buildResult.errors.slice(0, 3).map((error) => `Build: ${error}`), ...(lighthouseErrorCount > 0 ? [`Lighthouse: ${lighthouseErrorCount} run error(s) were recorded during collection.`] : []), ...(e2eResult
         ? e2eResult.results
             .filter((scenario) => !scenario.passed)
@@ -754,11 +1061,38 @@ async function run() {
                 summary: brokenLinksResult.summary,
             }
             : undefined,
+        typecheck: typecheckResult
+            ? { passed: typecheckResult.passed, errorCount: typecheckResult.errorCount, skipped: typecheckResult.skipped }
+            : undefined,
+        secretScan: secretScanResult
+            ? { passed: secretScanResult.passed, findingsCount: secretScanResult.findings.length, filesScanned: secretScanResult.filesScanned, skipped: secretScanResult.skipped }
+            : undefined,
+        a11yDeep: a11yDeepResult
+            ? { passed: a11yDeepResult.passed, criticalCount: a11yDeepResult.criticalCount, seriousCount: a11yDeepResult.seriousCount, summary: a11yDeepResult.summary, skipped: a11yDeepResult.skipped }
+            : undefined,
+        seoDeep: seoDeepResult
+            ? { passed: seoDeepResult.passed, errorCount: seoDeepResult.errorCount, warningCount: seoDeepResult.warningCount, summary: seoDeepResult.summary, skipped: seoDeepResult.skipped }
+            : undefined,
+        vitalsBudget: vitalsBudgetResult
+            ? { passed: vitalsBudgetResult.passed, lcp: vitalsBudgetResult.lcp, cls: vitalsBudgetResult.cls, inp: vitalsBudgetResult.inp, summary: vitalsBudgetResult.summary, skipped: vitalsBudgetResult.skipped }
+            : undefined,
+        bundleSize: bundleSizeResult
+            ? { framework: bundleSizeResult.framework, firstLoadJsKb: bundleSizeResult.firstLoadJsKb, largestChunkKb: bundleSizeResult.largestChunkKb, advisory: bundleSizeResult.advisory, skipped: bundleSizeResult.skipped }
+            : undefined,
+        outdatedCheck: outdatedCheckResult
+            ? { outdatedCount: outdatedCheckResult.outdatedCount, majorOutdated: outdatedCheckResult.majorOutdated, advisory: outdatedCheckResult.advisory, skipped: outdatedCheckResult.skipped }
+            : undefined,
         failureEvidence,
     }, {
         tier: verificationTier,
         thresholds: adjustedThresholds,
     });
+    // Gold eligibility: every route must individually pass all thresholds.
+    // If the weighted-average aggregate earned Gold but some routes individually failed,
+    // downgrade to Silver to enforce the per-route requirement.
+    if (multiRouteLhResult && !allRoutesPass && verificationReport.grade === "gold") {
+        verificationReport.grade = "silver";
+    }
     const verificationView = (0, index_js_1.getTierVerificationView)(verificationReport);
     const unifiedGrade = verificationReport.grade;
     const exitCode = shouldFailVerificationResult(verificationReport, config.fail_on) ? 1 : 0;
@@ -773,9 +1107,19 @@ async function run() {
         e2e: e2eResult,
         crossBrowser: crossBrowserResults,
         lighthouse: lighthouseResult,
+        lighthouseRoutes: multiRouteLhResult
+            ? multiRouteLhResult.perRoute.map((r) => ({ route: r.route, scores: r.scores }))
+            : undefined,
         mobileLighthouse: mobileLighthouseScores,
         security: securityAuditResult,
         visualDiff: visualDiffResult,
+        typecheck: typecheckResult,
+        secretScan: secretScanResult,
+        bundleSize: bundleSizeResult,
+        outdatedCheck: outdatedCheckResult,
+        a11yDeep: a11yDeepResult,
+        seoDeep: seoDeepResult,
+        vitalsBudget: vitalsBudgetResult,
         thresholds: adjustedThresholds,
         ciMode: config.ciMode,
         framework: detected.framework,
@@ -789,6 +1133,7 @@ async function run() {
             report: verificationReport,
             view: verificationView,
         },
+        compareEnv: compareEnvResult ?? undefined,
     };
     const markdownReportPath = (0, report_markdown_js_1.getMarkdownReportPath)(args.projectDir);
     if ((0, report_markdown_js_1.shouldWriteMarkdownReport)(resultObj)) {
@@ -849,6 +1194,7 @@ async function run() {
                         ? "client-ready"
                         : "hold",
                     share: args.share,
+                    blockers: verificationView.blockers.slice(0, 5).map((b) => b.title),
                     scores: {
                         performance: scores?.performance,
                         accessibility: scores?.accessibility,
@@ -890,6 +1236,38 @@ async function run() {
         }
     }
     writeResultFile(args.projectDir, resultObj);
+    // Pro: AI failure analysis — runs after result is finalized, before output
+    if (effectiveFeatures.ai_failure_analysis &&
+        verificationReport.verdict !== "client-ready" &&
+        verificationReport.verdict !== "release-ready" &&
+        args.format !== "json") {
+        try {
+            console.log("\n  Requesting AI failure analysis...");
+            const aiAnalysis = await (0, ai_analysis_js_1.requestAiFailureAnalysis)({
+                grade: unifiedGrade,
+                blockers: verificationView.blockers.map((b) => ({ title: b.title, action: b.action })),
+                lighthouseScores: scores ?? null,
+                thresholds: adjustedThresholds,
+                buildErrors: buildResult.errors.slice(0, 3),
+                e2eFailed: e2eResult ? e2eResult.failed : 0,
+                e2eTotal: e2eResult ? e2eResult.total : 0,
+                securitySummary: securityAuditResult?.summary,
+            });
+            if (aiAnalysis) {
+                console.log("\n  AI Analysis (Pro):");
+                console.log(`    Root cause: ${aiAnalysis.rootCause}`);
+                if (aiAnalysis.topFixes.length > 0) {
+                    console.log("    Top fixes:");
+                    for (const fix of aiAnalysis.topFixes) {
+                        console.log(`      - ${fix}`);
+                    }
+                }
+            }
+        }
+        catch {
+            // AI analysis errors are non-critical
+        }
+    }
     if (args.format === "json") {
         console.log(JSON.stringify(resultObj, null, 2));
     }

package/dist/compare-env.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Multi-environment Lighthouse comparison (Pro feature).
+ *
+ * Compares Lighthouse scores between the local build and a reference
+ * environment URL (e.g. staging, production) to detect regressions
+ * introduced by the current PR.
+ */
+import type { LighthouseScores } from "./grade.js";
+export interface EnvComparisonResult {
+    localUrl: string;
+    compareUrl: string;
+    local: LighthouseScores | null;
+    compare: LighthouseScores | null;
+    /** Positive = local is better, negative = compare env is better */
+    delta: {
+        performance: number | null;
+        accessibility: number | null;
+        seo: number | null;
+        bestPractices: number | null;
+    } | null;
+}
+export declare function runEnvComparison(localPort: number, compareUrl: string, runs?: number): Promise<EnvComparisonResult>;
+export declare function printEnvComparison(result: EnvComparisonResult): void;

package/dist/compare-env.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runEnvComparison = runEnvComparison;
+exports.printEnvComparison = printEnvComparison;
+const lighthouse_js_1 = require("./lighthouse.js");
+function scoreDelta(local, compare) {
+    if (!local || !compare)
+        return null;
+    return {
+        performance: local.performance - compare.performance,
+        accessibility: local.accessibility - compare.accessibility,
+        seo: local.seo - compare.seo,
+        bestPractices: local.bestPractices - compare.bestPractices,
+    };
+}
+async function runEnvComparison(localPort, compareUrl, runs = 1) {
+    const localUrl = `http://127.0.0.1:${localPort}/`;
+    console.log(`\n  [compare] Running env comparison: local vs ${compareUrl}`);
+    const [localResult, compareResult] = await Promise.all([
+        (0, lighthouse_js_1.runLighthouseOnUrl)(localUrl, runs),
+        (0, lighthouse_js_1.runLighthouseOnUrl)(compareUrl, runs),
+    ]);
+    return {
+        localUrl,
+        compareUrl,
+        local: localResult.scores,
+        compare: compareResult.scores,
+        delta: scoreDelta(localResult.scores, compareResult.scores),
+    };
+}
+function printEnvComparison(result) {
+    console.log("\n  Environment comparison:");
+    console.log(`    Local:   ${result.localUrl}`);
+    console.log(`    Compare: ${result.compareUrl}`);
+    if (!result.local && !result.compare) {
+        console.log("    Both environments returned no Lighthouse data.");
+        return;
+    }
+    const fmt = (v) => (v === null ? "—" : String(v));
+    const fmtDelta = (d) => {
+        if (d === null)
+            return "";
+        if (d > 0)
+            return ` (+${d})`;
+        if (d < 0)
+            return ` (${d})`;
+        return " (=)";
+    };
+    const d = result.delta;
+    console.log("    Metric           Local  Compare  Delta");
+    console.log(`    Performance      ${fmt(result.local?.performance ?? null).padEnd(6)} ${fmt(result.compare?.performance ?? null).padEnd(8)}${fmtDelta(d?.performance ?? null)}`);
+    console.log(`    Accessibility    ${fmt(result.local?.accessibility ?? null).padEnd(6)} ${fmt(result.compare?.accessibility ?? null).padEnd(8)}${fmtDelta(d?.accessibility ?? null)}`);
+    console.log(`    SEO              ${fmt(result.local?.seo ?? null).padEnd(6)} ${fmt(result.compare?.seo ?? null).padEnd(8)}${fmtDelta(d?.seo ?? null)}`);
+    console.log(`    Best Practices   ${fmt(result.local?.bestPractices ?? null).padEnd(6)} ${fmt(result.compare?.bestPractices ?? null).padEnd(8)}${fmtDelta(d?.bestPractices ?? null)}`);
+}