laxy-verify 1.1.23 → 1.1.24

package/README.md

@@ -2,15 +2,44 @@
 
 `laxy-verify` is a deployment blocker gate for frontend apps.
 
-Its job is simple:
+**Free**: Run verification manually on any project.  
+**Pro**: GitHub Actions auto-runs it on every PR + Slack/Discord alerts when things break.
 
-- catch the broken build before merge
-- catch the broken user flow before QA or client review
-- catch the obvious mobile or viewport break before release
+## Quick start
+
+Run it on a frontend app:
+
+```bash
+cd your-project
+npx laxy-verify .
+```
+
+Generate config plus GitHub Actions workflow:
+
+```bash
+npx laxy-verify --init
+```
+
+That creates:
 
-It runs your production build, Lighthouse, and user-visible verification flows in one command, then leaves one decision and one evidence trail for local use or CI.
+- `.laxy.yml`
+- `.github/workflows/laxy-verify.yml`
+
+Log in to unlock Pro features:
+
+```bash
+npx laxy-verify login
+npx laxy-verify whoami
+```
+
+For CI, set `LAXY_TOKEN` instead of interactive login:
+
+```yaml
+env:
+  LAXY_TOKEN: ${{ secrets.LAXY_TOKEN }}
+```
 
-## Why use this instead of stitching tools together?
+## Why laxy-verify?
 
 Most teams already have some mix of:
 
@@ -26,7 +55,7 @@ The gap is not "can these tools exist together?" The gap is "who turns that pile
 - one command instead of a custom build plus audit plus smoke-check script stack
 - one result file instead of scattered logs
 - one blocker-first decision instead of "build passed, but do we actually trust this release?"
-- a faster setup path with `--init` for config plus GitHub Actions
+- **Pro**: GitHub Actions auto-run + Slack/Discord alerts so you never miss a failure
 
 This is most useful if you ship frontend apps and want a practical gate before:
 
@@ -201,7 +230,7 @@ Options:
   --config <path>
   --fail-on unverified|bronze|silver|gold
   --skip-lighthouse
-  --plan-override free|pro|pro_plus
+  --plan-override free|pro|team
   --badge
   --init
   --multi-viewport

package/dist/audit/broken-links.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Broken-links audit.
+ * Uses the crawl result to find all internal links, then validates each
+ * with an HTTP HEAD/GET request. Links that return 4xx/5xx or timeout are
+ * reported as blockers.
+ */
+import { type CrawlResult } from "../crawler.js";
+export interface BrokenLink {
+    url: string;
+    path: string;
+    status: number;
+    statusText: string;
+    severity: "critical" | "high";
+}
+export interface BrokenLinksResult {
+    brokenLinks: BrokenLink[];
+    checkedCount: number;
+    hasBrokenLinks: boolean;
+    summary: string;
+}
+export declare function auditBrokenLinks(crawlResult: CrawlResult, baseUrl: string, abortSignal?: AbortSignal): Promise<BrokenLinksResult>;

package/dist/audit/broken-links.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.auditBrokenLinks = auditBrokenLinks;
+const TIMEOUT_MS = 5000;
+const VALID_OK_STATUS = [200, 201, 202, 203, 204, 301, 302, 303, 307, 308];
+function isSuccessStatus(n) {
+    return VALID_OK_STATUS.includes(n);
+}
+async function auditBrokenLinks(crawlResult, baseUrl, abortSignal) {
+    const origin = new URL(baseUrl).origin;
+    const allUrls = [];
+    for (const page of crawlResult.pages) {
+        for (const href of page.internalLinks) {
+            try {
+                const url = new URL(href, baseUrl).href;
+                if (!allUrls.includes(url))
+                    allUrls.push(url);
+            }
+            catch {
+                // skip malformed URLs
+            }
+        }
+    }
+    const uniqueUrls = allUrls;
+    const brokenLinks = [];
+    await Promise.all(uniqueUrls.map(async (url) => {
+        if (abortSignal?.aborted)
+            return;
+        try {
+            const controller = new AbortController();
+            const timer = setTimeout(() => controller.abort(), TIMEOUT_MS);
+            let status = 0;
+            let statusText = "";
+            try {
+                const res = await fetch(url, {
+                    method: "HEAD",
+                    redirect: "follow",
+                    signal: controller.signal,
+                });
+                status = res.status;
+                statusText = res.statusText;
+            }
+            catch {
+                // Fall back to GET if HEAD is not allowed
+                const controller2 = new AbortController();
+                const timer2 = setTimeout(() => controller2.abort(), TIMEOUT_MS);
+                try {
+                    const res = await fetch(url, {
+                        method: "GET",
+                        redirect: "follow",
+                        signal: controller2.signal,
+                    });
+                    status = res.status;
+                    statusText = res.statusText;
+                }
+                catch {
+                    status = 0;
+                    statusText = "timeout or network error";
+                }
+                clearTimeout(timer2);
+            }
+            clearTimeout(timer);
+            if (!isSuccessStatus(status)) {
+                const severity = status >= 500 ? "critical" : "high";
+                let path = url;
+                try {
+                    path = new URL(url).pathname;
+                }
+                catch { }
+                brokenLinks.push({ url, path, status, statusText, severity });
+            }
+        }
+        catch {
+            // skip
+        }
+    }));
+    const summary = brokenLinks.length === 0
+        ? `All ${uniqueUrls.length} links OK`
+        : `${brokenLinks.length} broken link(s) found`;
+    return {
+        brokenLinks,
+        checkedCount: uniqueUrls.length,
+        hasBrokenLinks: brokenLinks.length > 0,
+        summary,
+    };
+}

package/dist/cli.js

@@ -57,6 +57,7 @@ const playwright_runner_js_1 = require("./playwright-runner.js");
 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 index_js_1 = require("./verification-core/index.js");
 const package_json_1 = __importDefault(require("../package.json"));
 function shouldFailVerificationResult(report, failOn) {
@@ -64,7 +65,7 @@ function shouldFailVerificationResult(report, failOn) {
         return false;
     if (report.verdict === "build-failed" || report.verdict === "hold")
         return true;
-    if (report.tier === "pro_plus" && report.verdict === "investigate")
+    if (report.tier === "team" && report.verdict === "investigate")
         return true;
     return (0, grade_js_1.isWorseOrEqual)(report.grade, failOn);
 }
@@ -210,18 +211,14 @@ function consoleOutput(result) {
     }
     if (result.verification) {
         const view = result.verification.view;
-        const isPro = view.tier === "pro" || view.tier === "pro_plus";
-        const isProPlus = view.tier === "pro_plus";
-        // verbose_failure: Pro에서 서버가 활성화하면 blockers 전체 설명 표시
-        // failure_analysis: Pro+에서 서버가 활성화하면 warnings 전체 설명 + evidence 전체 표시
-        const verboseFailure = isPro && (result._verbose_failure ?? isPro);
-        const failureAnalysis = isProPlus && (result._failure_analysis ?? isProPlus);
+        const verboseFailure = result._verbose_failure ?? true;
+        const failureAnalysis = result._failure_analysis ?? true;
         console.log(`  Verification depth: ${view.tier}`);
         console.log(`  Decision question: ${view.question}`);
         console.log(`  Decision: ${view.verdict} (${view.confidence})`);
         console.log(`  Why it stopped here: ${view.summary}`);
-        // Pro/Pro+: 체크 통과 목록 요약
-        if (isPro && view.passes.length > 0) {
+        // Passed/Failed checks summary
+        if (view.passes.length > 0) {
             const passedChecks = view.passes.filter((p) => p.passed).map((p) => p.label);
             const failedChecks = view.passes.filter((p) => !p.passed).map((p) => p.label);
             if (passedChecks.length > 0)
@@ -238,8 +235,8 @@ function consoleOutput(result) {
                     console.log(`      Fix: ${blocker.action}`);
             }
         }
-        // Warnings: Pro/Pro+에서만 표시, Review 액션은 failure_analysis(Pro+)에서 표시
-        if (isPro && view.warnings.length > 0) {
+        // Warnings: always show all
+        if (view.warnings.length > 0) {
             console.log("  Risks to review:");
             for (const warning of view.warnings) {
                 console.log(`    - ${warning.title}`);
@@ -297,8 +294,8 @@ async function run() {
     --config <path>   Path to .laxy.yml
     --fail-on         unverified | bronze | silver | gold
     --skip-lighthouse Skip Lighthouse but still run build and E2E
-    --plan-override   free | pro | pro_plus (downgrade testing only)
-    --multi-viewport  Pro+: Lighthouse on desktop/tablet/mobile
+    --plan-override   free | pro | team (downgrade testing only)
+    --multi-viewport  team: Lighthouse on desktop/tablet/mobile
     --crawl           Crawl the app to discover routes before E2E
     --badge           Print shields.io badge markdown
     --help            Show this help
@@ -423,12 +420,11 @@ async function run() {
     }
     const features = entitlements ?? {
         plan: "free",
-        gold_grade: false,
-        lighthouse_runs_3: false,
-        verbose_failure: false,
-        multi_viewport: false,
-        failure_analysis: false,
-        fast_lane: false,
+        // All verification features run on every plan
+        // Automation features — not available on Free
+        github_actions: false,
+        queue_priority: false,
+        parallel_execution: false,
     };
     let effectiveFeatures = features;
     if (args.planOverride) {
@@ -442,7 +438,8 @@ async function run() {
             return;
         }
     }
-    if (effectiveFeatures.lighthouse_runs_3 && config.lighthouse_runs < 3) {
+    // Always run 3 Lighthouse passes for median score
+    if (config.lighthouse_runs < 3) {
         config = { ...config, lighthouse_runs: 3 };
     }
     let multiViewportScores = null;
@@ -455,6 +452,7 @@ async function run() {
     let visualDiffResult = null;
     let securityAuditResult = null;
     let mobileLighthouseScores = null;
+    let brokenLinksResult = null;
     const failureEvidence = [];
     if (buildResult.success) {
         let servePid;
@@ -482,15 +480,11 @@ async function run() {
                     console.error(`Lighthouse error: ${lhErr instanceof Error ? lhErr.message : String(lhErr)}`);
                 }
             }
-            if (!args.skipLighthouse && args.multiViewport && !effectiveFeatures.multi_viewport) {
-                console.log("\n  Note: --multi-viewport requires Pro+. Run laxy-verify login with a paid account to unlock it.");
-            }
-            else if (!args.skipLighthouse && effectiveFeatures.multi_viewport) {
+            if (!args.skipLighthouse && args.multiViewport) {
                 try {
                     multiViewportScores = await (0, multi_viewport_js_1.runMultiViewportLighthouse)(port);
                     (0, multi_viewport_js_1.printMultiViewportResults)(multiViewportScores, adjustedThresholds);
                     allViewportsOk = (0, multi_viewport_js_1.allViewportsPass)(multiViewportScores, adjustedThresholds);
-                    // Surface screenshot diff issues in failure evidence
                     if (multiViewportScores.screenshotDiffs) {
                         for (const diff of multiViewportScores.screenshotDiffs) {
                             if (!diff.baselineCreated && diff.diffPercent > 10) {
@@ -503,10 +497,9 @@ async function run() {
                     console.error(`Multi-viewport error: ${mvErr instanceof Error ? mvErr.message : String(mvErr)}`);
                 }
             }
-            // Pro: single mobile Lighthouse check (if not using full multi-viewport)
+            // Mobile Lighthouse check (runs when multi-viewport is not enabled)
             if (!args.skipLighthouse &&
-                verificationTier === "pro" &&
-                !effectiveFeatures.multi_viewport) {
+                !args.multiViewport) {
                 try {
                     mobileLighthouseScores = await (0, multi_viewport_js_1.runMobileLighthouse)(port);
                     if (mobileLighthouseScores) {
@@ -521,18 +514,16 @@ async function run() {
                     console.error(`Mobile Lighthouse error: ${mobileLhErr instanceof Error ? mobileLhErr.message : String(mobileLhErr)}`);
                 }
             }
-            // Pro/Pro+: security audit
-            if (verificationTier !== "free") {
-                try {
-                    securityAuditResult = await (0, security_audit_js_1.runSecurityAudit)(args.projectDir);
-                    if (securityAuditResult.critical > 0 || securityAuditResult.high > 0) {
-                        failureEvidence.push(`Security: ${securityAuditResult.summary}`);
-                    }
-                }
-                catch (secErr) {
-                    console.error(`Security audit error: ${secErr instanceof Error ? secErr.message : String(secErr)}`);
+            // Security audit (npm audit)
+            try {
+                securityAuditResult = await (0, security_audit_js_1.runSecurityAudit)(args.projectDir);
+                if (securityAuditResult.critical > 0 || securityAuditResult.high > 0) {
+                    failureEvidence.push(`Security: ${securityAuditResult.summary}`);
                 }
             }
+            catch (secErr) {
+                console.error(`Security audit error: ${secErr instanceof Error ? secErr.message : String(secErr)}`);
+            }
             const crawlEnabled = args.crawl || config.crawl;
             const crawlOpts = crawlEnabled
                 ? { enabled: true, maxDepth: config.max_crawl_depth, maxPages: config.max_crawl_pages }
@@ -549,9 +540,21 @@ async function run() {
                 };
                 e2eCoverageGaps = e2eRuns.coverageGaps;
                 e2eConsoleErrors = e2eRuns.consoleErrors;
-                // Pro+ stability: run E2E a second time if first run passed all
-                if (verificationTier === "pro_plus" && e2eRuns.passed === e2eRuns.results.length && e2eRuns.results.length > 0) {
-                    console.log("  [Pro+] Running stability pass (run 2/2)...");
+                // Broken links audit — runs after E2E so we have the crawl result
+                if (e2eRuns.crawlResult && e2eRuns.crawlResult.totalLinks > 0) {
+                    try {
+                        brokenLinksResult = await (0, broken_links_js_1.auditBrokenLinks)(e2eRuns.crawlResult, verifyUrl);
+                        if (brokenLinksResult.hasBrokenLinks) {
+                            failureEvidence.push(`Broken links: ${brokenLinksResult.summary}`);
+                        }
+                    }
+                    catch (blErr) {
+                        console.error(`Broken links audit error: ${blErr instanceof Error ? blErr.message : String(blErr)}`);
+                    }
+                }
+                // E2E stability: run a second time if first run passed all
+                if (e2eRuns.passed === e2eRuns.results.length && e2eRuns.results.length > 0) {
+                    console.log("  Running stability pass (run 2/2)...");
                     const e2eRuns2 = await (0, e2e_js_1.runVerifyE2E)(verifyUrl, verificationTier, config.scenarios, crawlOpts);
                     if (e2eRuns2.passed < e2eRuns2.results.length) {
                         e2eStabilityPassed = false;
@@ -563,7 +566,7 @@ async function run() {
                         failureEvidence.push(`E2E stability: second run failed (${failedNames})`);
                     }
                     else {
-                        console.log("  [Pro+] Stability pass: OK (2/2 runs passed)");
+                        console.log("  Stability pass: OK (2/2 runs passed)");
                     }
                 }
                 if (e2eRuns.coverageGaps.length > 0) {
@@ -599,13 +602,11 @@ async function run() {
                     console.log("  Note: Cross-browser testing requires playwright. Run: npm install -D playwright && npx playwright install");
                 }
             }
-            if (verificationTier === "pro_plus") {
-                try {
-                    visualDiffResult = await (0, visual_diff_js_1.runVisualDiff)(args.projectDir, verifyUrl, "verify");
-                }
-                catch (visualErr) {
-                    console.error(`Visual diff error: ${visualErr instanceof Error ? visualErr.message : String(visualErr)}`);
-                }
+            try {
+                visualDiffResult = await (0, visual_diff_js_1.runVisualDiff)(args.projectDir, verifyUrl, "verify");
+            }
+            catch (visualErr) {
+                console.error(`Visual diff error: ${visualErr instanceof Error ? visualErr.message : String(visualErr)}`);
             }
         }
         catch (serveErr) {
@@ -657,6 +658,13 @@ async function run() {
                 summary: securityAuditResult.summary,
             }
             : undefined,
+        brokenLinksAudit: brokenLinksResult
+            ? {
+                checkedCount: brokenLinksResult.checkedCount,
+                brokenCount: brokenLinksResult.brokenLinks.length,
+                summary: brokenLinksResult.summary,
+            }
+            : undefined,
         failureEvidence,
     }, {
         tier: verificationTier,
@@ -685,8 +693,8 @@ async function run() {
         exitCode,
         config_fail_on: config.fail_on,
         _plan: effectiveFeatures.plan,
-        _verbose_failure: effectiveFeatures.verbose_failure,
-        _failure_analysis: effectiveFeatures.failure_analysis,
+        _verbose_failure: true,
+        _failure_analysis: true,
         verification: {
             tier: verificationTier,
             report: verificationReport,

package/dist/crawler.js

@@ -220,7 +220,7 @@ async function crawlApp(baseUrl, options) {
  */
 function buildScenariosFromCrawl(crawlResult, tier) {
     const scenarios = [];
-    const limit = tier === "pro_plus" ? 6 : tier === "pro" ? 4 : 2;
+    const limit = tier === "team" ? 6 : tier === "pro" ? 4 : 2;
     // Scenario 1: Root page render
     const rootPage = crawlResult.pages.find((p) => p.path === "/");
     if (rootPage) {
@@ -310,8 +310,8 @@ function buildScenariosFromCrawl(crawlResult, tier) {
             ],
         });
     }
-    // Scenario: Button interactions (Pro+ only)
-    if (tier === "pro_plus") {
+    // Scenario: Button interactions (Team only)
+    if (tier === "team") {
         for (const page of crawlResult.pages) {
             if (scenarios.length >= limit)
                 break;

package/dist/e2e.d.ts

@@ -1,6 +1,6 @@
 import type { VerificationTier } from "./verification-core/types.js";
 import type { UserScenario } from "./config.js";
-import { type CrawlOptions } from "./crawler.js";
+import { type CrawlOptions, type CrawlResult } from "./crawler.js";
 export interface E2EStep {
     type: "click" | "fill" | "check_visible" | "check_text" | "wait" | "scroll" | "clear_fill" | "check_validation" | "check_healthy_page" | "goto";
     selector?: string;
@@ -44,5 +44,6 @@ export declare function runVerifyE2E(url: string, tier: VerificationTier, userSc
     failed: number;
     coverageGaps: string[];
     consoleErrors: string[];
+    crawlResult?: CrawlResult;
 }>;
 export {};

package/dist/e2e.js

@@ -40,7 +40,7 @@ function getScenarioLimit(tier) {
     switch (tier) {
         case "pro":
             return 4;
-        case "pro_plus":
+        case "team":
             return 5;
         default:
             return 2;
@@ -95,8 +95,8 @@ function getVerificationCoverageGaps(scenarios, tier) {
     if (tier !== "free" && !hasPrimaryAction) {
         gaps.push("No primary action scenario was detected, so the verify run could not validate a real user action.");
     }
-    if (tier === "pro_plus" && scenarios.length < 4) {
-        gaps.push("Too few meaningful scenarios were detected for a release-confidence pass, so this run stayed shallower than Pro+ expects.");
+    if (tier === "team" && scenarios.length < 4) {
+        gaps.push("Too few meaningful scenarios were detected for a release-confidence pass, so this run stayed shallower than Team expects.");
     }
     return gaps;
 }
@@ -168,7 +168,7 @@ function buildVerifyScenarios(snapshot, tier) {
             ],
         });
     }
-    if (tier === "pro_plus" && clickTarget && fillTarget && clickTarget !== fillTarget) {
+    if (tier === "team" && clickTarget && fillTarget && clickTarget !== fillTarget) {
         scenarios.push({
             name: "Repeated interaction stability",
             steps: [
@@ -511,6 +511,7 @@ async function executeScenario(url, scenario) {
 async function runVerifyE2E(url, tier, userScenarios, crawlOptions) {
     let scenarios;
     let coverageGaps;
+    let crawlResultUsed;
     if (userScenarios && userScenarios.length > 0) {
         console.log(`  Using ${userScenarios.length} user-defined scenario(s) from .laxy.yml`);
         scenarios = convertUserScenarios(userScenarios);
@@ -518,11 +519,10 @@ async function runVerifyE2E(url, tier, userScenarios, crawlOptions) {
     }
     else if (crawlOptions?.enabled) {
         console.log("  Crawling app to discover routes and interactions...");
-        const crawlResult = await (0, crawler_js_1.crawlApp)(url, crawlOptions);
-        console.log(`  Crawled ${crawlResult.crawledCount} page(s), found ${crawlResult.totalLinks} internal link(s)`);
-        scenarios = (0, crawler_js_1.buildScenariosFromCrawl)(crawlResult, tier);
+        crawlResultUsed = await (0, crawler_js_1.crawlApp)(url, crawlOptions);
+        console.log(`  Crawled ${crawlResultUsed.crawledCount} page(s), found ${crawlResultUsed.totalLinks} internal link(s)`);
+        scenarios = (0, crawler_js_1.buildScenariosFromCrawl)(crawlResultUsed, tier);
         if (scenarios.length === 0) {
-            // Fallback to DOM snapshot if crawl found nothing useful
             const snapshot = await captureDomSnapshot(url);
             scenarios = buildVerifyScenarios(snapshot, tier);
         }
@@ -540,5 +540,5 @@ async function runVerifyE2E(url, tier, userScenarios, crawlOptions) {
     const passed = results.filter((result) => result.passed).length;
     const failed = results.length - passed;
     const consoleErrors = Array.from(new Set(results.flatMap((r) => r.consoleErrors ?? []))).slice(0, 10);
-    return { scenarios, results, passed, failed, coverageGaps, consoleErrors };
+    return { scenarios, results, passed, failed, coverageGaps, consoleErrors, crawlResult: crawlResultUsed };
 }

package/dist/entitlement.d.ts

@@ -1,13 +1,10 @@
 export interface EntitlementFeatures {
     plan: string;
-    gold_grade: boolean;
-    lighthouse_runs_3: boolean;
-    verbose_failure: boolean;
-    multi_viewport: boolean;
-    failure_analysis: boolean;
-    fast_lane: boolean;
+    github_actions: boolean;
+    queue_priority: boolean;
+    parallel_execution: boolean;
 }
-export type TestablePlan = "free" | "pro" | "pro_plus";
+export type TestablePlan = "free" | "pro" | "team";
 export declare function normalizePlan(plan?: string | null): TestablePlan;
 export declare function getEntitlements(): Promise<EntitlementFeatures>;
 export declare function applyPlanOverride(features: EntitlementFeatures, overridePlan?: TestablePlan): EntitlementFeatures;

package/dist/entitlement.js

@@ -14,27 +14,23 @@ exports.printPlanBanner = printPlanBanner;
 const auth_js_1 = require("./auth.js");
 const FREE_FEATURES = {
     plan: "free",
-    gold_grade: true,
-    lighthouse_runs_3: true,
-    verbose_failure: true,
-    multi_viewport: true,
-    failure_analysis: true,
-    fast_lane: true,
+    // Automation features — not available on Free
+    github_actions: false,
+    queue_priority: false,
+    parallel_execution: false,
 };
 let cache = null;
 const CACHE_TTL_MS = 5 * 60 * 1000;
 const PLAN_RANK = {
     free: 0,
     pro: 1,
-    pro_plus: 2,
     team: 2,
-    enterprise: 2,
 };
 function normalizePlan(plan) {
     if (plan === "pro")
         return "pro";
-    if (plan === "pro_plus" || plan === "team" || plan === "enterprise")
-        return "pro_plus";
+    if (plan === "team")
+        return "team";
     return "free";
 }
 function getPlanRank(plan) {
@@ -68,15 +64,22 @@ async function getEntitlements() {
 function applyPlanOverride(features, overridePlan) {
     if (!overridePlan)
         return features;
-    return { ...features, plan: overridePlan };
+    const isTeam = overridePlan === "team";
+    return {
+        ...features,
+        plan: overridePlan,
+        // All verification features run on every plan
+        // Automation features — Team only
+        github_actions: isTeam,
+        queue_priority: isTeam,
+        parallel_execution: isTeam,
+    };
 }
 function printPlanBanner(features) {
     const planLabels = {
         free: "Free",
         pro: "Pro",
-        pro_plus: "Pro+",
         team: "Team",
-        enterprise: "Enterprise",
     };
     const label = planLabels[features.plan] ?? features.plan;
     if (features.plan !== "free") {

package/dist/report-markdown.js

@@ -41,12 +41,8 @@ function titleCasePlan(plan) {
     switch (plan) {
         case "pro":
             return "Pro";
-        case "pro_plus":
-            return "Pro+";
         case "team":
             return "Team";
-        case "enterprise":
-            return "Enterprise";
         default:
             return "Free";
     }
@@ -64,7 +60,7 @@ function formatTimestamp(iso) {
     return date.toISOString().replace("T", " ").replace(".000Z", " UTC");
 }
 function sentenceForVerdict(view) {
-    const isReleaseTier = view.tier === "pro_plus";
+    const isReleaseTier = view.tier === "team";
     switch (view.verdict) {
         case "client-ready":
             return "Yes. This run collected enough evidence to support a client-ready call.";
@@ -102,7 +98,7 @@ function defaultNextActions(result) {
         case "release-ready":
             return ["Ship this version, or archive this report as release evidence."];
         case "investigate":
-            return view.tier === "pro_plus"
+            return view.tier === "team"
                 ? ["Collect the missing verification evidence, then rerun the command before release."]
                 : ["Collect the missing verification evidence, then rerun the command before sending this to a client."];
         case "build-failed":
@@ -185,7 +181,7 @@ function getReportFlavor(view) {
     switch (view.tier) {
         case "pro":
             return "delivery";
-        case "pro_plus":
+        case "team":
             return "release";
         default:
             return "generic";

package/dist/verification-core/report.js

@@ -202,6 +202,16 @@ function getImprovementRecommendations(input, thresholds = exports.DEFAULT_LH_TH
             });
         }
     }
+    // Broken links audit
+    if (input.brokenLinksAudit && input.brokenLinksAudit.brokenCount > 0) {
+        findings.push({
+            category: "security",
+            severity: "high",
+            title: `Broken links detected (${input.brokenLinksAudit.brokenCount}/${input.brokenLinksAudit.checkedCount})`,
+            description: `${input.brokenLinksAudit.brokenCount} link(s) returned non-OK status codes. Users will hit 404/500 errors.`,
+            action: "Fix or remove the broken links and rerun the verification.",
+        });
+    }
     // Mobile Lighthouse — Pro tier mobile check
     if (input.mobileLighthouseScores) {
         const mobileScores = input.mobileLighthouseScores;
@@ -317,67 +327,23 @@ function buildVerificationReport(input, options) {
     }
     else if (blockers.length > 0) {
         verdict = "hold";
-        confidence = tier === "free" ? "low" : "medium";
-        summary = "Blocking verification issues were found. Hold release until the blockers are fixed.";
-    }
-    else if (tier === "pro_plus" &&
-        coreChecksPassed &&
-        evidence.e2eStabilityPassed &&
-        proPlusEvidenceComplete &&
-        !hasWarnings) {
-        verdict = "release-ready";
-        confidence = "high";
-        summary = "Core verification checks passed. This run supports a release-ready call.";
-    }
-    else if (tier === "pro_plus" &&
-        coreChecksPassed &&
-        evidence.e2eStabilityPassed &&
-        proPlusEvidenceComplete &&
-        hasWarnings) {
-        verdict = "investigate";
-        confidence = "medium";
-        summary = "Core checks passed, but non-blocking warnings remain. Review warnings before calling this run release-ready.";
-    }
-    else if (tier === "pro_plus" &&
-        coreChecksPassed &&
-        (!evidence.hasMultiViewportData || !evidence.hasComparableVisualDiffData)) {
-        verdict = "investigate";
         confidence = "medium";
-        const missingEvidence = [];
-        if (!evidence.hasMultiViewportData)
-            missingEvidence.push("multi-viewport evidence");
-        if (!evidence.hasComparableVisualDiffData)
-            missingEvidence.push("visual diff evidence");
-        summary = `Core checks passed, but release-ready confidence still needs ${missingEvidence.join(" and ")}.`;
+        summary = "Blocking verification issues were found. Hold release until the blockers are fixed.";
     }
-    else if (tier === "pro" && coreChecksPassed && !hasWarnings) {
+    else if (coreChecksPassed && !hasWarnings) {
         verdict = "client-ready";
-        confidence = "medium";
-        summary = "No blocking issues found. Build, E2E, and Lighthouse checks passed. This run supports a client-ready call.";
+        confidence = "high";
+        summary = "No blocking issues found. Build, E2E, and Lighthouse checks passed.";
     }
-    else if (tier === "pro" && coreChecksPassed && hasWarnings) {
+    else if (coreChecksPassed && hasWarnings) {
         verdict = "investigate";
         confidence = "medium";
         summary = "Core checks passed, but warning-level risks remain. Review warnings before calling this run client-ready.";
     }
-    else if (tier === "free") {
-        if (evidence.hasConsoleErrors) {
-            verdict = "quick-pass";
-            confidence = "low";
-            summary = "Build passed, but runtime console errors were detected. The app may crash or misbehave for users.";
-        }
-        else {
-            verdict = "quick-pass";
-            confidence = evidence.hasLighthouseData && evidence.lighthousePassed ? "medium" : "low";
-            summary = "No immediate hard blockers were found in the quick verification pass.";
-        }
-    }
     else {
-        verdict = "investigate";
-        confidence = "medium";
-        summary = evidence.lighthouseSkipped
-            ? "The build is standing. Lighthouse was skipped, so review the remaining verification evidence before release."
-            : "The build is standing, but deeper verification evidence should be reviewed before release.";
+        verdict = "quick-pass";
+        confidence = evidence.hasLighthouseData && evidence.lighthousePassed ? "medium" : "low";
+        summary = "No immediate hard blockers were found in the quick verification pass.";
     }
     const passes = [
         { key: "build", label: "Production build", passed: evidence.buildPassed },

package/dist/verification-core/tier-policy.js

@@ -21,13 +21,13 @@ const TIER_POLICIES = {
         maxBlockers: 5,
         maxWarnings: 5,
     },
-    pro_plus: {
-        tier: "pro_plus",
+    team: {
+        tier: "team",
         showDetailedLighthouse: true,
         showDetailedE2E: true,
         showReportExport: true,
-        maxBlockers: 8,
-        maxWarnings: 8,
+        maxBlockers: 10,
+        maxWarnings: 10,
     },
 };
 function getTierPolicy(tier = "free") {
@@ -36,16 +36,16 @@ function getTierPolicy(tier = "free") {
 function planToVerificationTier(plan) {
     if (plan === "pro")
         return "pro";
-    if (plan === "pro_plus" || plan === "team" || plan === "enterprise")
-        return "pro_plus";
+    if (plan === "team")
+        return "team";
     return "free";
 }
 function getVerificationTierQuestion(tier) {
     switch (tier) {
         case "pro":
             return "Ready to show a client?";
-        case "pro_plus":
-            return "Ready for production?";
+        case "team":
+            return "Ready for team deployment?";
         default:
             return "Any critical issues right now?";
     }

package/dist/verification-core/types.d.ts

@@ -1,5 +1,5 @@
 export type VerificationGrade = "gold" | "silver" | "bronze" | "unverified";
-export type VerificationTier = "free" | "pro" | "pro_plus";
+export type VerificationTier = "free" | "pro" | "team";
 export type ReleaseVerdict = "quick-pass" | "client-ready" | "investigate" | "hold" | "release-ready" | "build-failed";
 export interface LighthouseThresholds {
     performance: number;
@@ -38,9 +38,14 @@ export interface VerificationInput {
         high: number;
         summary: string;
     };
+    brokenLinksAudit?: {
+        checkedCount: number;
+        brokenCount: number;
+        summary: string;
+    };
 }
 export interface VerificationCheck {
-    key: "build" | "e2e" | "lighthouse" | "viewport" | "visual" | "security" | "mobile-lh" | "console-errors";
+    key: "build" | "e2e" | "lighthouse" | "viewport" | "visual" | "security" | "mobile-lh" | "console-errors" | "broken-links";
     label: string;
     passed: boolean;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "laxy-verify",
-  "version": "1.1.23",
+  "version": "1.1.24",
   "description": "Frontend verification CLI for build checks, Lighthouse, E2E, and release readiness",
   "license": "MIT",
   "type": "commonjs",