laxy-verify 1.1.13 → 1.1.15

package/README.md

@@ -1,150 +1,189 @@
-# laxy-verify
-
-CLI verification for frontend apps.
-
-`laxy-verify` runs production build checks, Lighthouse, tiered verify E2E, and plan-gated verification features for Free, Pro, and Pro+ accounts.
-
-```bash
-npx laxy-verify --init --run
-npx laxy-verify .
-npx laxy-verify login
-npx laxy-verify whoami
-npx laxy-verify --help
-```
-
-## Quick Start
-
-### 1. Initialize
-
-```bash
-cd your-project
-npx laxy-verify --init
-```
-
-This generates `.laxy.yml` and a GitHub Actions workflow.
-
-### 2. Run locally
-
-```bash
-npx laxy-verify .
-```
-
-### 3. Add to CI
-
-Commit the generated workflow. Each PR gets a verification run, grade output, and optional GitHub reporting.
-
-## Verification Tiers
-
-| Plan | Question it answers |
-|------|---------------------|
-| Free | Is this likely to break right now? |
-| Pro | Is this strong enough to send to a client? |
-| Pro+ | Can I call this release-ready with confidence? |
-
-## Grades
-
-| Grade | Meaning |
-|-------|---------|
-| Gold | Build passed + E2E passed + Lighthouse passed + Pro+ viewport evidence passed |
-| Silver | Build passed + E2E passed |
-| Bronze | Build passed |
-| Unverified | Build failed |
-
-## Paid Features
-
-Log in with your Laxy account to unlock paid plan features.
-
-```bash
-npx laxy-verify login
-npx laxy-verify whoami
-npx laxy-verify logout
-```
-
+# laxy-verify
+
+CLI verification for frontend apps.
+
+`laxy-verify` runs production build checks, Lighthouse, tiered verify E2E, and plan-gated verification features for Free, Pro, and Pro+ accounts.
+It is designed around three user questions:
+
+- Free: "Is this likely to break right now?"
+- Pro: "Is this strong enough to send to a client?"
+- Pro+: "Can I call this release-ready with confidence?"
+
+```bash
+npx laxy-verify --init --run
+npx laxy-verify .
+npx laxy-verify login
+npx laxy-verify whoami
+npx laxy-verify --help
+```
+
+## Quick Start
+
+### 1. Initialize
+
+```bash
+cd your-project
+npx laxy-verify --init
+```
+
+This generates `.laxy.yml` and a GitHub Actions workflow.
+
+### 2. Run locally
+
+```bash
+npx laxy-verify .
+```
+
+### 3. Add to CI
+
+Commit the generated workflow. Each PR gets a verification run, grade output, and optional GitHub reporting.
+
+## Verification Tiers
+
+| Plan | Question it answers |
+|------|---------------------|
+| Free | Is this likely to break right now? |
+| Pro | Is this strong enough to send to a client? |
+| Pro+ | Can I call this release-ready with confidence? |
+
+## Grades
+
+| Grade | Meaning |
+|-------|---------|
+| Gold | Build passed + E2E passed + Lighthouse passed + Pro+ viewport evidence passed |
+| Silver | Build passed + E2E passed |
+| Bronze | Build passed |
+| Unverified | Build failed |
+
+## Paid Features
+
+Log in with your Laxy account to unlock paid plan features.
+
+```bash
+npx laxy-verify login
+npx laxy-verify whoami
+npx laxy-verify logout
+```
+
 | Feature | Free | Pro | Pro+ |
 |---------|------|-----|------|
 | Build verification | Yes | Yes | Yes |
 | Lighthouse | 1 run | 3 runs | 3 runs |
 | Verify E2E | Smoke | Deeper client-send checks | Deeper client-send checks |
 | Detailed report view | No | Yes | Yes |
-| Report export | No | Yes | Yes |
+| `laxy-verify-report.md` export | No | Yes | Yes |
 | Multi-viewport verification | No | No | Yes |
 | Visual diff | No | No | Yes |
 | Failure analysis signals | No | No | Yes |
+
+Pro is for delivery verification.
+Pro+ is for release-confidence verification with extra evidence before you say "ship it."
+
+For CI, set `LAXY_TOKEN` instead of using interactive login.
+
+```yaml
+env:
+  LAXY_TOKEN: ${{ secrets.LAXY_TOKEN }}
+```
+
+## Configuration
+
+All fields are optional in `.laxy.yml`.
+
+```yaml
+framework: "auto"
+build_command: ""
+dev_command: ""
+package_manager: "auto"
+port: 3000
+build_timeout: 300
+dev_timeout: 60
+lighthouse_runs: 1
+
+thresholds:
+  performance: 70
+  accessibility: 85
+  seo: 80
+  best_practices: 80
+
+fail_on: "bronze"
+```
+
+## CLI Options
+
+```text
+npx laxy-verify [project-dir]
+
+Options:
+  --format console|json
+  --ci
+  --config <path>
+  --fail-on unverified|bronze|silver|gold
+  --skip-lighthouse
+  --badge
+  --init
+  --multi-viewport
+  --help
+
+Subcommands:
+  login [email]
+  logout
+  whoami
+```
+
+## Result Files
 
-For CI, set `LAXY_TOKEN` instead of using interactive login.
-
-```yaml
-env:
-  LAXY_TOKEN: ${{ secrets.LAXY_TOKEN }}
-```
-
-## Configuration
-
-All fields are optional in `.laxy.yml`.
-
-```yaml
-framework: "auto"
-build_command: ""
-dev_command: ""
-package_manager: "auto"
-port: 3000
-build_timeout: 300
-dev_timeout: 60
-lighthouse_runs: 1
-
-thresholds:
-  performance: 70
-  accessibility: 85
-  seo: 80
-  best_practices: 80
-
-fail_on: "bronze"
-```
-
-## CLI Options
-
-```text
-npx laxy-verify [project-dir]
-
-Options:
-  --format console|json
-  --ci
-  --config <path>
-  --fail-on unverified|bronze|silver|gold
-  --skip-lighthouse
-  --badge
-  --init
-  --multi-viewport
-  --help
-
-Subcommands:
-  login [email]
-  logout
-  whoami
-```
+Each run writes `.laxy-result.json`.
 
-## Result File
+Paid plans also write a readable markdown summary to `laxy-verify-report.md`.
 
-Each run writes `.laxy-result.json`.
+- `Pro`: blocker-focused delivery report
+- `Pro+`: release-readiness report with viewport and visual evidence
 
 ```json
 {
-  "grade": "Silver",
-  "timestamp": "2026-04-09T09:00:00Z",
-  "build": { "success": true, "durationMs": 12000, "errors": [] },
-  "e2e": { "passed": 4, "failed": 0, "total": 4, "results": [] },
-  "lighthouse": { "performance": 82, "accessibility": 94, "seo": 90, "bestPractices": 92, "runs": 3 },
-  "exitCode": 0,
-  "_plan": "pro"
+  "grade": "Gold",
+  "timestamp": "2026-04-09T09:00:00Z",
+  "build": { "success": true, "durationMs": 12000, "errors": [] },
+  "e2e": { "passed": 5, "failed": 0, "total": 5, "results": [] },
+  "lighthouse": { "performance": 82, "accessibility": 94, "seo": 90, "bestPractices": 92, "runs": 3 },
+  "multiViewport": {
+    "allPassed": true,
+    "summary": "Desktop, tablet, and mobile checks passed."
+  },
+  "visualDiff": {
+    "verdict": "pass",
+    "differencePercentage": 0
+  },
+  "verification": {
+    "tier": "pro_plus",
+    "report": { "verdict": "release-ready" }
+  },
+  "exitCode": 0,
+  "_plan": "pro_plus"
 }
 ```
 
-## Limitations
-
-- Monorepos require targeting the app subdirectory explicitly.
-- Dev-server-based Lighthouse can differ from production hosting.
-- Pro+ visual diff and viewport checks increase runtime.
-
-## License
-
-MIT
+### `laxy-verify-report.md`
+
+For Pro and Pro+ runs, the markdown report is designed to be easy to read and easy to paste into an AI coding tool.
+
+It includes:
+
+- the main decision in plain English
+- what passed
+- blockers and warnings
+- exact verification evidence
+- failed E2E scenarios
+- a `Copy For AI` section you can paste directly into Codex, Cursor, Claude, or ChatGPT
+
+## Limitations
+
+- Monorepos require targeting the app subdirectory explicitly.
+- Dev-server-based Lighthouse can differ from production hosting.
+- Pro+ visual diff and viewport checks increase runtime.
+- Local verification is most stable on current LTS Node releases.
+
+## License
+
+MIT

package/dist/cli.js

@@ -53,6 +53,7 @@ const auth_js_1 = require("./auth.js");
 const entitlement_js_1 = require("./entitlement.js");
 const multi_viewport_js_1 = require("./multi-viewport.js");
 const e2e_js_1 = require("./e2e.js");
+const report_markdown_js_1 = require("./report-markdown.js");
 const visual_diff_js_1 = require("./visual-diff.js");
 const index_js_1 = require("./verification-core/index.js");
 const package_json_1 = __importDefault(require("../package.json"));
@@ -209,6 +210,9 @@ function consoleOutput(result) {
             console.log(`  Status check: ${result.github.grade}`);
     }
     console.log("  Result: .laxy-result.json");
+    if (result.markdownReportPath) {
+        console.log(`  Report: ${path.basename(result.markdownReportPath)}`);
+    }
     console.log(`  Exit code: ${result.exitCode}`);
     if ((result.grade === "Silver" || result.grade === "Bronze") && (!result._plan || result._plan === "free")) {
         console.log("\n  Unlock deeper verification and Gold-grade confidence with Pro or Pro+:");
@@ -218,43 +222,43 @@ function consoleOutput(result) {
 async function run() {
     const args = parseArgs();
     if (args.help) {
-        console.log(`
-  laxy-verify v${package_json_1.default.version}
-  Frontend quality gate: build + Lighthouse verification
-
-  Usage:
-    npx laxy-verify [project-dir] [options]
-    npx laxy-verify <subcommand>
-
-  Subcommands:
-    login [email]     Log in to unlock Pro/Pro+ features
-    logout            Remove saved credentials
-    whoami            Show current login status
-
-  Options:
-    --init            Generate .laxy.yml + GitHub workflow file
-    --init --run      Generate config and immediately run verification
-    --format          console | json  (default: console)
-    --ci              CI mode: -10 Performance threshold, runs=3
-    --config <path>   Path to .laxy.yml
-    --fail-on         unverified | bronze | silver | gold
-    --skip-lighthouse Skip Lighthouse but still run build and E2E
-    --multi-viewport  Pro+: Lighthouse on desktop/tablet/mobile
-    --badge           Print shields.io badge markdown
-    --help            Show this help
-
-  Exit codes:
-    0   Grade meets or exceeds fail_on threshold
-    1   Grade worse than fail_on, or build failed
-    2   Configuration error
-
-  Examples:
-    npx laxy-verify --init --run        # Setup + first verification
-    npx laxy-verify .                   # Run in current directory
-    npx laxy-verify . --ci              # CI mode
-    npx laxy-verify . --fail-on silver  # Require Silver or better
-
-  Docs: https://github.com/psungmin24/laxy-verify
+        console.log(`
+  laxy-verify v${package_json_1.default.version}
+  Frontend quality gate: build + Lighthouse verification
+
+  Usage:
+    npx laxy-verify [project-dir] [options]
+    npx laxy-verify <subcommand>
+
+  Subcommands:
+    login [email]     Log in to unlock Pro/Pro+ features
+    logout            Remove saved credentials
+    whoami            Show current login status
+
+  Options:
+    --init            Generate .laxy.yml + GitHub workflow file
+    --init --run      Generate config and immediately run verification
+    --format          console | json  (default: console)
+    --ci              CI mode: -10 Performance threshold, runs=3
+    --config <path>   Path to .laxy.yml
+    --fail-on         unverified | bronze | silver | gold
+    --skip-lighthouse Skip Lighthouse but still run build and E2E
+    --multi-viewport  Pro+: Lighthouse on desktop/tablet/mobile
+    --badge           Print shields.io badge markdown
+    --help            Show this help
+
+  Exit codes:
+    0   Grade meets or exceeds fail_on threshold
+    1   Grade worse than fail_on, or build failed
+    2   Configuration error
+
+  Examples:
+    npx laxy-verify --init --run        # Setup + first verification
+    npx laxy-verify .                   # Run in current directory
+    npx laxy-verify . --ci              # CI mode
+    npx laxy-verify . --fail-on silver  # Require Silver or better
+
+  Docs: https://github.com/psungmin24/laxy-verify
 `);
         exitGracefully(0);
         return;
@@ -511,6 +515,15 @@ async function run() {
             view: verificationView,
         },
     };
+    const markdownReportPath = (0, report_markdown_js_1.getMarkdownReportPath)(args.projectDir);
+    if ((0, report_markdown_js_1.shouldWriteMarkdownReport)(resultObj)) {
+        const markdownReport = (0, report_markdown_js_1.buildMarkdownReport)(args.projectDir, resultObj);
+        fs.writeFileSync(markdownReportPath, markdownReport, "utf-8");
+        resultObj.markdownReportPath = markdownReportPath;
+    }
+    else if (fs.existsSync(markdownReportPath)) {
+        fs.rmSync(markdownReportPath, { force: true });
+    }
     const inGitHubActions = !!process.env.GITHUB_ACTIONS;
     if (inGitHubActions) {
         try {

package/dist/init.js

@@ -56,17 +56,17 @@ function runInit(dir) {
         catch {
             // Keep defaults when auto-detection fails.
         }
-        const ymlContent = `# Generated by laxy-verify --init
-# See https://github.com/psungmin24/laxy-verify for full docs
-framework: ${detectedFramework}   # auto-detected
-port: ${detectedPort}
-fail_on: bronze
-
-thresholds:
-  performance: 70
-  accessibility: 85
-  seo: 80
-  best_practices: 80
+        const ymlContent = `# Generated by laxy-verify --init
+# See https://github.com/psungmin24/laxy-verify for full docs
+framework: ${detectedFramework}   # auto-detected
+port: ${detectedPort}
+fail_on: bronze
+
+thresholds:
+  performance: 70
+  accessibility: 85
+  seo: 80
+  best_practices: 80
 `;
         fs.writeFileSync(laxyYmlPath, ymlContent, "utf-8");
         console.log("Created .laxy.yml");
@@ -76,25 +76,25 @@ thresholds:
     }
     else {
         fs.mkdirSync(workflowDir, { recursive: true });
-        const workflowContent = `name: Laxy Verify
-on:
-  pull_request:
-    branches: [main, master]
-  push:
-    branches: [main, master]
-
-permissions:
-  pull-requests: write
-  statuses: write
-
-jobs:
-  verify:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - uses: psungmin24/laxy-verify@v1
-        with:
-          github-token: \${{ secrets.GITHUB_TOKEN }}
+        const workflowContent = `name: Laxy Verify
+on:
+  pull_request:
+    branches: [main, master]
+  push:
+    branches: [main, master]
+
+permissions:
+  pull-requests: write
+  statuses: write
+
+jobs:
+  verify:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: psungmin24/laxy-verify@v1
+        with:
+          github-token: \${{ secrets.GITHUB_TOKEN }}
 `;
         fs.writeFileSync(workflowPath, workflowContent, "utf-8");
         console.log("Created .github/workflows/laxy-verify.yml");

package/dist/lighthouse.js

@@ -63,38 +63,38 @@ async function removeDirWithRetries(dirPath, retries = 5) {
     }
 }
 function writeRunnerScript(runnerPath) {
-    const source = `import fs from "node:fs/promises";
-import lighthouse from "lighthouse";
-import { launch } from "chrome-launcher";
-
-const [url, reportPath, chromeDir] = process.argv.slice(2);
-
-const chrome = await launch({
-  logLevel: "error",
-  chromeFlags: [
-    "--headless=new",
-    "--no-sandbox",
-    "--disable-dev-shm-usage",
-    \`--user-data-dir=\${chromeDir}\`,
-  ],
-});
-
-try {
-  const result = await lighthouse(url, {
-    port: chrome.port,
-    output: "json",
-    logLevel: "error",
-    onlyCategories: ["performance", "accessibility", "seo", "best-practices"],
-  });
-
-  if (!result?.lhr) {
-    throw new Error("Lighthouse returned no report.");
-  }
-
-  await fs.writeFile(reportPath, JSON.stringify(result.lhr), "utf8");
-} finally {
-  await chrome.kill();
-}
+    const source = `import fs from "node:fs/promises";
+import lighthouse from "lighthouse";
+import { launch } from "chrome-launcher";
+
+const [url, reportPath, chromeDir] = process.argv.slice(2);
+
+const chrome = await launch({
+  logLevel: "error",
+  chromeFlags: [
+    "--headless=new",
+    "--no-sandbox",
+    "--disable-dev-shm-usage",
+    \`--user-data-dir=\${chromeDir}\`,
+  ],
+});
+
+try {
+  const result = await lighthouse(url, {
+    port: chrome.port,
+    output: "json",
+    logLevel: "error",
+    onlyCategories: ["performance", "accessibility", "seo", "best-practices"],
+  });
+
+  if (!result?.lhr) {
+    throw new Error("Lighthouse returned no report.");
+  }
+
+  await fs.writeFile(reportPath, JSON.stringify(result.lhr), "utf8");
+} finally {
+  await chrome.kill();
+}
 `;
     fs.writeFileSync(runnerPath, source, "utf-8");
 }

package/dist/multi-viewport.js

@@ -81,49 +81,49 @@ async function removeDirWithRetries(dirPath, retries = 5) {
     }
 }
 function writeViewportRunnerScript(runnerPath) {
-    const source = `import fs from "node:fs/promises";
-import lighthouse from "lighthouse";
-import { launch } from "chrome-launcher";
-
-const [url, reportPath, chromeDir, formFactor, screenJson] = process.argv.slice(2);
-const screen = JSON.parse(screenJson);
-
-const chrome = await launch({
-  logLevel: "error",
-  chromeFlags: [
-    "--headless=new",
-    "--no-sandbox",
-    "--disable-dev-shm-usage",
-    \`--user-data-dir=\${chromeDir}\`,
-  ],
-});
-
-try {
-  const result = await lighthouse(
-    url,
-    {
-      port: chrome.port,
-      output: "json",
-      logLevel: "error",
-      onlyCategories: ["performance", "accessibility", "seo", "best-practices"],
-    },
-    {
-      extends: "lighthouse:default",
-      settings: {
-        formFactor,
-        screenEmulation: screen,
-      },
-    }
-  );
-
-  if (!result?.lhr) {
-    throw new Error("Lighthouse returned no report.");
-  }
-
-  await fs.writeFile(reportPath, JSON.stringify(result.lhr), "utf8");
-} finally {
-  await chrome.kill();
-}
+    const source = `import fs from "node:fs/promises";
+import lighthouse from "lighthouse";
+import { launch } from "chrome-launcher";
+
+const [url, reportPath, chromeDir, formFactor, screenJson] = process.argv.slice(2);
+const screen = JSON.parse(screenJson);
+
+const chrome = await launch({
+  logLevel: "error",
+  chromeFlags: [
+    "--headless=new",
+    "--no-sandbox",
+    "--disable-dev-shm-usage",
+    \`--user-data-dir=\${chromeDir}\`,
+  ],
+});
+
+try {
+  const result = await lighthouse(
+    url,
+    {
+      port: chrome.port,
+      output: "json",
+      logLevel: "error",
+      onlyCategories: ["performance", "accessibility", "seo", "best-practices"],
+    },
+    {
+      extends: "lighthouse:default",
+      settings: {
+        formFactor,
+        screenEmulation: screen,
+      },
+    }
+  );
+
+  if (!result?.lhr) {
+    throw new Error("Lighthouse returned no report.");
+  }
+
+  await fs.writeFile(reportPath, JSON.stringify(result.lhr), "utf8");
+} finally {
+  await chrome.kill();
+}
 `;
     fs.writeFileSync(runnerPath, source, "utf-8");
 }

package/dist/report-markdown.d.ts

@@ -0,0 +1,39 @@
+import type { E2EScenarioResult } from "./e2e.js";
+import type { LighthouseScores } from "./grade.js";
+import type { TierVerificationView, VerificationReport } from "./verification-core/index.js";
+import type { VisualDiffResult } from "./visual-diff.js";
+export interface MarkdownReportResult {
+    grade: string;
+    timestamp: string;
+    build: {
+        success: boolean;
+        durationMs: number;
+        errors: string[];
+    };
+    e2e?: {
+        passed: number;
+        failed: number;
+        total: number;
+        results: E2EScenarioResult[];
+    };
+    lighthouse: (LighthouseScores & {
+        runs: number;
+    }) | null;
+    visualDiff?: VisualDiffResult | null;
+    thresholds: {
+        performance: number;
+        accessibility: number;
+        seo: number;
+        bestPractices: number;
+    };
+    framework: string | null;
+    _plan?: string;
+    verification?: {
+        tier: VerificationReport["tier"];
+        report: VerificationReport;
+        view: TierVerificationView;
+    };
+}
+export declare function shouldWriteMarkdownReport(result: MarkdownReportResult): boolean;
+export declare function getMarkdownReportPath(projectDir: string): string;
+export declare function buildMarkdownReport(projectDir: string, result: MarkdownReportResult): string;

package/dist/report-markdown.js

@@ -0,0 +1,269 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.shouldWriteMarkdownReport = shouldWriteMarkdownReport;
+exports.getMarkdownReportPath = getMarkdownReportPath;
+exports.buildMarkdownReport = buildMarkdownReport;
+const path = __importStar(require("node:path"));
+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";
+    }
+}
+function titleCaseVerdict(verdict) {
+    return verdict
+        .split("-")
+        .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+        .join(" ");
+}
+function formatTimestamp(iso) {
+    const date = new Date(iso);
+    if (Number.isNaN(date.getTime()))
+        return iso;
+    return date.toISOString().replace("T", " ").replace(".000Z", " UTC");
+}
+function sentenceForVerdict(view) {
+    switch (view.verdict) {
+        case "release-ready":
+            return "Yes. This run collected enough evidence to support a release-ready call.";
+        case "hold":
+            return "No. This run found blockers that should be fixed before release.";
+        case "investigate":
+            return "Not yet. The project is standing, but there is not enough confidence to call it release-ready.";
+        case "build-failed":
+            return "No. The production build failed, so the release should be held immediately.";
+        default:
+            return "This run did not find an immediate hard blocker, but it is still a shallow verification pass.";
+    }
+}
+function defaultNextActions(result) {
+    const view = result.verification?.view;
+    if (!view)
+        return ["Rerun verification after the project changes are applied."];
+    if (view.nextActions.length > 0)
+        return view.nextActions;
+    switch (view.verdict) {
+        case "release-ready":
+            return ["Ship this version, or archive this report as release evidence."];
+        case "investigate":
+            return ["Collect the missing verification evidence, then rerun the command before release."];
+        case "build-failed":
+            return ["Fix the production build first, then rerun the verification command."];
+        case "quick-pass":
+            return ["Run a deeper Pro verification before sending this to a client."];
+        default:
+            return ["Rerun verification after the blockers are fixed."];
+    }
+}
+function renderChecklist(title, items) {
+    if (items.length === 0) {
+        return `## ${title}\n\n- None.\n`;
+    }
+    return `## ${title}\n\n${items.map((item) => `- ${item}`).join("\n")}\n`;
+}
+function renderBuildErrors(errors) {
+    if (errors.length === 0)
+        return "";
+    const trimmed = errors.slice(0, 5).map((error) => error.trim()).filter(Boolean);
+    if (trimmed.length === 0)
+        return "";
+    return [
+        "## Build Errors",
+        "",
+        "```text",
+        ...trimmed,
+        "```",
+        "",
+    ].join("\n");
+}
+function renderE2EFailures(result) {
+    const failedScenarios = result.e2e?.results.filter((scenario) => !scenario.passed).slice(0, 5) ?? [];
+    if (failedScenarios.length === 0) {
+        return "";
+    }
+    const lines = ["## Failed E2E Scenarios", ""];
+    for (const scenario of failedScenarios) {
+        lines.push(`### ${scenario.name}`);
+        if (scenario.error) {
+            lines.push("", `- Error: ${scenario.error}`);
+        }
+        const failedSteps = scenario.steps.filter((step) => !step.passed).slice(0, 3);
+        if (failedSteps.length > 0) {
+            lines.push("", "- Failing steps:");
+            for (const step of failedSteps) {
+                const detail = step.error ? ` - ${step.error}` : "";
+                lines.push(`  - ${step.description}${detail}`);
+            }
+        }
+        lines.push("");
+    }
+    return `${lines.join("\n")}\n`;
+}
+function renderMetrics(result) {
+    const lines = ["## Verification Evidence", ""];
+    lines.push("| Check | Result |");
+    lines.push("|---|---|");
+    lines.push(`| Build | ${result.build.success ? "Passed" : "Failed"} in ${result.build.durationMs}ms |`);
+    if (result.lighthouse) {
+        lines.push(`| Lighthouse | P ${result.lighthouse.performance}, A ${result.lighthouse.accessibility}, SEO ${result.lighthouse.seo}, BP ${result.lighthouse.bestPractices} over ${result.lighthouse.runs} run(s) |`);
+    }
+    else {
+        lines.push("| Lighthouse | Skipped |");
+    }
+    if (result.e2e) {
+        lines.push(`| E2E | ${result.e2e.passed}/${result.e2e.total} passed |`);
+    }
+    const reportInput = result.verification?.report.evidence.input;
+    if (typeof reportInput?.viewportIssues === "number" || typeof reportInput?.multiViewportPassed === "boolean") {
+        lines.push(`| Multi-viewport | ${reportInput.multiViewportPassed ? "Passed" : "Needs work"}${reportInput.multiViewportSummary ? `, ${reportInput.multiViewportSummary}` : ""} |`);
+    }
+    if (result.visualDiff) {
+        lines.push(`| Visual diff | ${result.visualDiff.hasBaseline ? `${result.visualDiff.diffPercentage}% (${result.visualDiff.verdict})` : "Baseline seeded"} |`);
+    }
+    lines.push("");
+    return `${lines.join("\n")}\n`;
+}
+function renderCopyForAI(result) {
+    const view = result.verification?.view;
+    if (!view)
+        return "";
+    const blockers = view.blockers.map((blocker) => `- ${blocker.title}: ${blocker.action}`);
+    const warnings = view.warnings.map((warning) => `- ${warning.title}: ${warning.action}`);
+    const evidence = view.failureEvidence.map((item) => `- ${item}`);
+    const closingLine = view.verdict === "release-ready"
+        ? "Use this as release evidence, or rerun after any code change that could affect quality."
+        : view.verdict === "investigate" && view.blockers.length === 0
+            ? "Collect the missing verification evidence, then rerun the command and compare the new report."
+            : "Please fix the blockers first, then rerun the verification command and compare the new report.";
+    return [
+        "## Copy For AI",
+        "",
+        "```text",
+        "Use this verification report to fix the project.",
+        "",
+        `Plan: ${titleCasePlan(result._plan)}`,
+        `Question: ${view.question}`,
+        `Verdict: ${titleCaseVerdict(view.verdict)}`,
+        "",
+        "Priority blockers:",
+        ...(blockers.length > 0 ? blockers : ["- None listed."]),
+        "",
+        "Warnings to review after blockers:",
+        ...(warnings.length > 0 ? warnings : ["- None listed."]),
+        "",
+        "Evidence from the verification run:",
+        ...(evidence.length > 0 ? evidence : ["- No extra evidence recorded."]),
+        "",
+        closingLine,
+        "```",
+        "",
+    ].join("\n");
+}
+function shouldWriteMarkdownReport(result) {
+    return result.verification?.view.showReportExport === true;
+}
+function getMarkdownReportPath(projectDir) {
+    return path.join(projectDir, "laxy-verify-report.md");
+}
+function buildMarkdownReport(projectDir, result) {
+    const projectName = path.basename(path.resolve(projectDir));
+    const plan = titleCasePlan(result._plan);
+    const view = result.verification?.view;
+    if (!view) {
+        return [
+            "# Laxy Verify Report",
+            "",
+            `Project: ${projectName}`,
+            `Generated: ${formatTimestamp(result.timestamp)}`,
+            "",
+            "No detailed verification report was available for this run.",
+            "",
+        ].join("\n");
+    }
+    const blockers = view.blockers.map((blocker) => `**${blocker.title}**\n  Why it matters: ${blocker.description}\n  What to do: ${blocker.action}`);
+    const warnings = view.warnings.map((warning) => `**${warning.title}**\n  Why it matters: ${warning.description}\n  What to do: ${warning.action}`);
+    const passes = view.passes.map((check) => `${check.passed ? "Passed" : "Failed"}: ${check.label}`);
+    const nextActions = defaultNextActions(result);
+    return [
+        "# Laxy Verify Report",
+        "",
+        `Project: ${projectName}`,
+        `Generated: ${formatTimestamp(result.timestamp)}`,
+        `Plan: ${plan}`,
+        `Framework: ${result.framework ?? "unknown"}`,
+        "",
+        "## At A Glance",
+        "",
+        `Short answer: ${sentenceForVerdict(view)}`,
+        `Why: ${view.summary}`,
+        `Recommended next move: ${nextActions[0]}`,
+        "",
+        "## Decision",
+        "",
+        `Question: ${view.question}`,
+        `Answer: ${titleCaseVerdict(view.verdict)}`,
+        `Verdict: ${titleCaseVerdict(view.verdict)}`,
+        `Confidence: ${view.confidence}`,
+        `Grade: ${result.grade}`,
+        "",
+        renderMetrics(result).trimEnd(),
+        "",
+        renderChecklist("What Passed", passes).trimEnd(),
+        "",
+        renderChecklist("Blockers", blockers).trimEnd(),
+        "",
+        renderChecklist("Warnings", warnings).trimEnd(),
+        "",
+        renderChecklist("Next Actions", nextActions).trimEnd(),
+        "",
+        renderChecklist("Recorded Evidence", view.failureEvidence).trimEnd(),
+        "",
+        renderBuildErrors(result.build.errors).trimEnd(),
+        renderE2EFailures(result).trimEnd(),
+        renderCopyForAI(result).trimEnd(),
+        "",
+    ]
+        .filter(Boolean)
+        .join("\n");
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "laxy-verify",
-  "version": "1.1.13",
-  "description": "Frontend quality gate: build + Lighthouse verification",
+  "version": "1.1.15",
+  "description": "Frontend quality gate: build, Lighthouse, tiered E2E, and release-confidence verification",
   "license": "MIT",
   "type": "commonjs",
   "bin": {