@empline/preflight 1.1.11 → 1.1.13

package/dist/checks/workflows/all.js

@@ -0,0 +1,2688 @@
+#!/usr/bin/env tsx
+"use strict";
+/**
+ * All Workflow - Comprehensive validation using CONSOLIDATED MODULES ONLY
+ *
+ * This replaces the old system of workflows + additional checks + standalone checks.
+ * All validation now goes through consolidated modules in scripts/active/preflights/consolidated/.
+ *
+ * Consolidated Modules (10 categories):
+ *   1. imports.ts        - Import validation, hook imports, consistency
+ *   2. quality.ts        - Code quality, linting, file size
+ *   3. security.ts       - API routes, XSS prevention, external links
+ *   4. database.ts       - Schema validation, Prisma checks
+ *   5. ui-components.ts  - Component library, button-link pattern
+ *   6. ui-spacing.ts     - Layout, spacing, design tokens
+ *   7. ui-navigation.ts  - Sidebars, breadcrumbs, footers, navigation layout
+ *   8. ui-patterns.ts    - Category chips, consistent patterns
+ *   9. performance.ts    - Bundle size, image optimization, lazy loading
+ *   10. business.ts      - DRAFT status, cache-first, critical workflows
+ *
+ * Coverage Map (6 previously-mentioned checks):
+ *   - Import Validation (missing hook imports) → imports.ts
+ *   - Category Chips (non-standard labels) → ui-patterns.ts
+ *   - Navigation Layout (missing sidebars/breadcrumbs/footers) → ui-navigation.ts
+ *   - Button Link Pattern (incorrect asChild usage) → ui-components.ts
+ *   - Image Optimization (missing width/height) → performance.ts
+ *   - XSS Prevention (dangerouslySetInnerHTML) → security.ts
+ *
+ * Used by: pnpm build (via preflight:all)
+ */
+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 });
+const child_process_1 = require("child_process");
+const dotenv_1 = require("dotenv");
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const console_chars_1 = require("../../utils/console-chars");
+const universal_progress_reporter_1 = require("../system/universal-progress-reporter");
+function escapeRegExp(input) {
+    return input.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function parseFilterRegex() {
+    const args = process.argv.slice(2);
+    const idx = args.indexOf("--filter");
+    if (idx === -1)
+        return null;
+    const raw = args[idx + 1] ?? "";
+    if (!raw)
+        return { raw: "", regex: /$a/ };
+    try {
+        return { raw, regex: new RegExp(raw, "i") };
+    }
+    catch {
+        return { raw, regex: new RegExp(escapeRegExp(raw), "i") };
+    }
+}
+function parseIntArg(value) {
+    if (!value)
+        return undefined;
+    const n = Number.parseInt(value, 10);
+    return Number.isFinite(n) ? n : undefined;
+}
+function parseBool(value) {
+    if (!value)
+        return undefined;
+    const v = value.trim().toLowerCase();
+    if (["1", "true", "yes", "y", "on"].includes(v))
+        return true;
+    if (["0", "false", "no", "n", "off"].includes(v))
+        return false;
+    return undefined;
+}
+function escapeXml(value) {
+    return String(value)
+        .replace(/&/g, "&amp;")
+        .replace(/</g, "&lt;")
+        .replace(/>/g, "&gt;")
+        .replace(/\"/g, "&quot;")
+        .replace(/'/g, "&apos;");
+}
+function parseRunnerOptions() {
+    const args = process.argv.slice(2);
+    const timeoutIdx = args.indexOf("--timeout-ms");
+    const cliTimeoutMs = timeoutIdx !== -1 ? parseIntArg(args[timeoutIdx + 1]) : undefined;
+    const envTimeoutMs = parseIntArg(process.env.PREFLIGHT_TIMEOUT_MS);
+    const failFast = args.includes("--fail-fast") || parseBool(process.env.PREFLIGHT_FAIL_FAST) === true;
+    const junitIdx = args.indexOf("--junit");
+    const junitPath = junitIdx !== -1 ? args[junitIdx + 1] : process.env.PREFLIGHT_JUNIT;
+    const sarifIdx = args.indexOf("--sarif");
+    const sarifPath = sarifIdx !== -1 ? args[sarifIdx + 1] : process.env.PREFLIGHT_SARIF;
+    return {
+        timeoutMs: cliTimeoutMs ?? envTimeoutMs,
+        failFast,
+        junitPath,
+        sarifPath,
+    };
+}
+function makeOutputSnippet(opts) {
+    const parts = [];
+    const outLines = opts.stdoutLines ?? [];
+    const outTotal = opts.stdoutTotal ?? outLines.length;
+    if (outLines.length > 0) {
+        parts.push("--- stdout ---");
+        parts.push(...outLines);
+        if (outTotal > outLines.length)
+            parts.push(`... +${outTotal - outLines.length} more stdout lines`);
+    }
+    const errLines = opts.stderrLines ?? [];
+    const errTotal = opts.stderrTotal ?? errLines.length;
+    if (errLines.length > 0) {
+        parts.push("--- stderr ---");
+        parts.push(...errLines);
+        if (errTotal > errLines.length)
+            parts.push(`... +${errTotal - errLines.length} more stderr lines`);
+    }
+    const text = parts.join("\n").trim();
+    if (!text)
+        return "";
+    // Keep SARIF payload reasonably small.
+    return text.length <= 8000 ? text : text.slice(-8000);
+}
+function safeFileToken(name) {
+    return String(name ?? "check")
+        .trim()
+        .replace(/[^a-zA-Z0-9._-]+/g, "_")
+        .slice(0, 80);
+}
+function createFindingsPath(name) {
+    const dir = path.join(process.cwd(), "test-results", "preflight-findings");
+    try {
+        if (!fs.existsSync(dir))
+            fs.mkdirSync(dir, { recursive: true });
+    }
+    catch {
+        // ignore
+    }
+    const file = `${safeFileToken(name)}-${Date.now()}-${Math.random().toString(16).slice(2)}.json`;
+    const abs = path.join(dir, file);
+    try {
+        if (fs.existsSync(abs))
+            fs.unlinkSync(abs);
+    }
+    catch {
+        // ignore
+    }
+    return abs;
+}
+function ensureDir(relDir) {
+    const abs = path.join(process.cwd(), relDir);
+    if (!fs.existsSync(abs))
+        fs.mkdirSync(abs, { recursive: true });
+}
+function writeJson(relPath, data) {
+    ensureDir(path.dirname(relPath));
+    fs.writeFileSync(path.join(process.cwd(), relPath), JSON.stringify(data, null, 2) + "\n", "utf8");
+}
+function writeText(relPath, data) {
+    ensureDir(path.dirname(relPath));
+    fs.writeFileSync(path.join(process.cwd(), relPath), data, "utf8");
+}
+function normalizeSarifUri(file) {
+    const raw = String(file ?? "").trim();
+    if (!raw)
+        return raw;
+    // Normalize slashes first so later checks behave consistently.
+    const normalized = raw.replace(/\\/g, "/");
+    const cwd = process.cwd().replace(/\\/g, "/");
+    // Prefer repo-relative paths for GitHub Code Scanning.
+    // If the path is absolute and inside the repo, convert to a relative URI.
+    if (normalized.startsWith(cwd + "/")) {
+        return normalized.slice(cwd.length + 1);
+    }
+    // If it's an absolute path outside the repo, keep it as-is.
+    // If it's already relative, keep it.
+    return normalized;
+}
+function toJUnitXml(report, totalDurationSec) {
+    const suiteName = "preflight:all";
+    const tests = report.records.length;
+    const failures = report.records.filter((r) => r.kind === "failed").length;
+    const skipped = report.records.filter((r) => r.kind === "skipped" || r.kind === "warning").length;
+    const cases = report.records.map((r) => {
+        const tcTime = r.durationSec.toFixed(3);
+        const classname = r.group;
+        const name = r.name;
+        if (r.kind === "skipped") {
+            return `  <testcase classname="${escapeXml(classname)}" name="${escapeXml(name)}" time="${tcTime}">\n    <skipped message="skipped" />\n  </testcase>`;
+        }
+        if (r.kind === "warning") {
+            // Non-blocking warnings should not fail the test run.
+            return `  <testcase classname="${escapeXml(classname)}" name="${escapeXml(name)}" time="${tcTime}">\n    <skipped message="warning" />\n  </testcase>`;
+        }
+        if (r.kind === "passed") {
+            return `  <testcase classname="${escapeXml(classname)}" name="${escapeXml(name)}" time="${tcTime}" />`;
+        }
+        const msg = r.timedOut ? `Timed out (exit 124)` : `Failed (exit ${r.exitCode ?? 1})`;
+        return `  <testcase classname="${escapeXml(classname)}" name="${escapeXml(name)}" time="${tcTime}">\n    <failure message="${escapeXml(msg)}" />\n  </testcase>`;
+    });
+    return `<?xml version="1.0" encoding="UTF-8"?>\n<testsuite name="${escapeXml(suiteName)}" tests="${tests}" failures="${failures}" errors="0" skipped="${skipped}" time="${totalDurationSec.toFixed(3)}" timestamp="${escapeXml(report.createdAtIso)}">\n${cases.join("\n")}\n</testsuite>\n`;
+}
+function toSarif(report) {
+    const relevant = report.records.filter((r) => r.kind === "failed" || r.kind === "warning");
+    const rulesById = new Map();
+    const ensureRule = (id, name, level, props) => {
+        if (rulesById.has(id))
+            return;
+        rulesById.set(id, {
+            id,
+            name,
+            shortDescription: { text: name },
+            defaultConfiguration: { level },
+            properties: props,
+        });
+    };
+    for (const r of relevant) {
+        const baseId = `${r.group}:${r.name}`;
+        const level = r.blocking ? "error" : "warning";
+        ensureRule(baseId, `[${r.group}] ${r.name}`, level, {
+            group: r.group,
+            blocking: r.blocking,
+            kind: "preflight-step",
+        });
+        const findings = Array.isArray(r.findings) ? r.findings : [];
+        for (const f of findings.slice(0, 200)) {
+            const code = f.code ? String(f.code) : "";
+            if (!code)
+                continue;
+            const rid = `${baseId}:${code}`;
+            ensureRule(rid, `[${r.group}] ${r.name} — ${code}`, level, {
+                group: r.group,
+                blocking: r.blocking,
+                kind: "preflight-finding",
+                stepId: baseId,
+                findingCode: code,
+            });
+        }
+    }
+    const rules = Array.from(rulesById.values());
+    const results = [];
+    for (const r of relevant) {
+        const id = `${r.group}:${r.name}`;
+        const defaultLevel = r.blocking ? "error" : "warning";
+        const base = r.timedOut
+            ? `[${r.group}] ${r.name} timed out.`
+            : `[${r.group}] ${r.name} ${r.kind === "warning" ? "warning" : "failed"}.`;
+        const snippet = (r.outputSnippet ?? "").trim();
+        const findings = Array.isArray(r.findings) ? r.findings : [];
+        if (findings.length > 0) {
+            for (const f of findings.slice(0, 200)) {
+                const rid = f.code ? `${id}:${String(f.code)}` : id;
+                const loc = f.file
+                    ? {
+                        physicalLocation: {
+                            artifactLocation: { uri: normalizeSarifUri(f.file) },
+                            region: {
+                                startLine: f.startLine,
+                                startColumn: f.startColumn,
+                                endLine: f.endLine,
+                                endColumn: f.endColumn,
+                            },
+                        },
+                    }
+                    : undefined;
+                results.push({
+                    ruleId: rid,
+                    level: f.level ?? defaultLevel,
+                    message: {
+                        text: `${base}${f.message ? `\n\n${f.message}` : ""}${snippet ? `\n\n${snippet}` : ""}`,
+                    },
+                    locations: loc ? [loc] : undefined,
+                    properties: {
+                        stepId: id,
+                        group: r.group,
+                        blocking: r.blocking,
+                        timedOut: Boolean(r.timedOut),
+                        exitCode: r.exitCode,
+                        pathOrCmd: r.pathOrCmd,
+                        outputSnippet: snippet || undefined,
+                        findingCode: f.code,
+                    },
+                });
+            }
+            continue;
+        }
+        const text = snippet ? `${base}\n\n${snippet}` : base;
+        results.push({
+            ruleId: id,
+            level: defaultLevel,
+            message: { text },
+            properties: {
+                group: r.group,
+                blocking: r.blocking,
+                timedOut: Boolean(r.timedOut),
+                exitCode: r.exitCode,
+                pathOrCmd: r.pathOrCmd,
+                outputSnippet: snippet || undefined,
+            },
+        });
+    }
+    return {
+        $schema: "https://raw.githubusercontent.com/oasis-tcs/sarif-spec/master/Schemata/sarif-schema-2.1.0.json",
+        version: "2.1.0",
+        runs: [
+            {
+                tool: { driver: { name: "SuperCatch Preflight (all workflow)", rules } },
+                results,
+            },
+        ],
+    };
+}
+function readJsonIfExists(relPath) {
+    const abs = path.join(process.cwd(), relPath);
+    if (!fs.existsSync(abs))
+        return undefined;
+    try {
+        return JSON.parse(fs.readFileSync(abs, "utf8"));
+    }
+    catch {
+        return undefined;
+    }
+}
+function toNumberDurationSec(durationSec) {
+    const n = Number(durationSec);
+    return Number.isFinite(n) ? n : 0;
+}
+function baselineKey(r) {
+    // Use stable IDs so renaming the display name doesn't lose baseline history.
+    return `${r.group}:${r.pathOrCmd}`;
+}
+function buildChildEnv(extra) {
+    // Node 24+ can emit noisy MODULE_TYPELESS warnings when executing TS/ESM via loaders.
+    // Silence by default for preflight child processes to keep output readable.
+    // Opt-out: set PREFLIGHT_NODE_WARNINGS=1.
+    if (process.env.PREFLIGHT_NODE_WARNINGS === "1") {
+        return { ...process.env, ...(extra ?? {}) };
+    }
+    if (process.env.NODE_NO_WARNINGS) {
+        return { ...process.env, ...(extra ?? {}) };
+    }
+    return { ...process.env, NODE_NO_WARNINGS: "1", ...(extra ?? {}) };
+}
+function readFindingsFile(absPath) {
+    try {
+        if (!absPath)
+            return [];
+        if (!fs.existsSync(absPath))
+            return [];
+        const raw = fs.readFileSync(absPath, "utf8");
+        if (!raw.trim())
+            return [];
+        const parsed = JSON.parse(raw);
+        const items = Array.isArray(parsed)
+            ? parsed
+            : Array.isArray(parsed?.findings)
+                ? parsed.findings
+                : [];
+        if (!Array.isArray(items))
+            return [];
+        return items
+            .map((f) => {
+            const file = f.file ?? f.path;
+            const range = f.range ?? f.location ?? undefined;
+            const startLine = Number(range?.startLine ?? range?.line ?? f.line);
+            const startColumn = Number(range?.startColumn ?? range?.col ?? f.column);
+            const endLine = Number(range?.endLine ?? startLine);
+            const endColumn = Number(range?.endColumn ?? startColumn);
+            const severity = String(f.severity ?? "error").toLowerCase();
+            const level = severity === "warning" ? "warning" : "error";
+            const message = String(f.message ?? f.text ?? "").trim();
+            return {
+                message,
+                level,
+                file: file ? String(file).replace(/\\/g, "/") : undefined,
+                startLine: Number.isFinite(startLine) && startLine > 0 ? startLine : undefined,
+                startColumn: Number.isFinite(startColumn) && startColumn > 0 ? startColumn : undefined,
+                endLine: Number.isFinite(endLine) && endLine > 0 ? endLine : undefined,
+                endColumn: Number.isFinite(endColumn) && endColumn > 0 ? endColumn : undefined,
+                code: f.code ? String(f.code) : undefined,
+            };
+        })
+            .filter((x) => x.message);
+    }
+    catch {
+        return [];
+    }
+}
+function defaultConcurrency() {
+    // Keep defaults conservative to avoid pegging CPU during local dev.
+    // Override via PREFLIGHT_CONCURRENCY / PREFLIGHT_BLOCKING_CONCURRENCY / PREFLIGHT_SEO_CONCURRENCY.
+    return Math.max(1, Math.min(os.cpus().length, 4));
+}
+function parseConcurrency(envVarName, fallback = defaultConcurrency()) {
+    const raw = process.env[envVarName];
+    const n = raw ? Number(raw) : NaN;
+    if (Number.isFinite(n) && n > 0)
+        return Math.floor(n);
+    return fallback;
+}
+async function runShellCommand(cmd, opts) {
+    const start = Date.now();
+    return await new Promise((resolve) => {
+        const extraEnv = opts.findingsPath
+            ? { PREFLIGHT_FINDINGS_PATH: opts.findingsPath, PREFLIGHT_FINDINGS_FILE: opts.findingsPath }
+            : undefined;
+        const child = (0, child_process_1.spawn)(cmd, {
+            shell: true,
+            stdio: ["ignore", "pipe", "pipe"],
+            env: buildChildEnv(extraEnv),
+        });
+        let timedOut = false;
+        let timeoutHandle;
+        const killProcessTree = (pid) => {
+            if (!pid)
+                return;
+            if (process.platform === "win32") {
+                const killer = (0, child_process_1.spawn)("taskkill", ["/pid", String(pid), "/t", "/f"], {
+                    stdio: "ignore",
+                    windowsHide: true,
+                });
+                killer.on("error", () => { });
+                return;
+            }
+            try {
+                process.kill(-pid, "SIGKILL");
+                return;
+            }
+            catch {
+                // ignore
+            }
+            try {
+                process.kill(pid, "SIGKILL");
+            }
+            catch {
+                // ignore
+            }
+        };
+        if (typeof opts.timeoutMs === "number" &&
+            Number.isFinite(opts.timeoutMs) &&
+            opts.timeoutMs > 0) {
+            timeoutHandle = setTimeout(() => {
+                timedOut = true;
+                killProcessTree(child.pid);
+            }, opts.timeoutMs);
+            timeoutHandle.unref?.();
+        }
+        const stdoutLines = [];
+        const stderrLines = [];
+        let stdoutTotal = 0;
+        let stderrTotal = 0;
+        let stdoutBuf = "";
+        let stderrBuf = "";
+        const consume = (chunk, state) => {
+            state.buf += chunk.toString("utf8");
+            const parts = state.buf.split(/\r?\n/);
+            state.buf = parts.pop() ?? "";
+            for (const line of parts) {
+                if (!line)
+                    continue;
+                state.total += 1;
+                // Keep the *last* N lines so we surface the actual failure context.
+                if (state.max > 0) {
+                    if (state.lines.length >= state.max)
+                        state.lines.shift();
+                    state.lines.push(line);
+                }
+            }
+        };
+        child.stdout?.on("data", (chunk) => {
+            const s = {
+                buf: stdoutBuf,
+                lines: stdoutLines,
+                total: stdoutTotal,
+                max: opts.maxStdoutLines,
+            };
+            consume(chunk, s);
+            stdoutBuf = s.buf;
+            stdoutTotal = s.total;
+        });
+        child.stderr?.on("data", (chunk) => {
+            const s = {
+                buf: stderrBuf,
+                lines: stderrLines,
+                total: stderrTotal,
+                max: opts.maxStderrLines,
+            };
+            consume(chunk, s);
+            stderrBuf = s.buf;
+            stderrTotal = s.total;
+        });
+        child.on("close", (code) => {
+            if (timeoutHandle)
+                clearTimeout(timeoutHandle);
+            const flushLine = (buf, state) => {
+                const trimmed = buf.trim();
+                if (!trimmed)
+                    return state;
+                state.total += 1;
+                if (state.lines.length < state.max)
+                    state.lines.push(trimmed);
+                return state;
+            };
+            ({ total: stdoutTotal } = flushLine(stdoutBuf, {
+                lines: stdoutLines,
+                total: stdoutTotal,
+                max: opts.maxStdoutLines,
+            }));
+            ({ total: stderrTotal } = flushLine(stderrBuf, {
+                lines: stderrLines,
+                total: stderrTotal,
+                max: opts.maxStderrLines,
+            }));
+            const durationSec = ((Date.now() - start) / 1000).toFixed(1);
+            const findings = readFindingsFile(opts.findingsPath);
+            resolve({
+                exitCode: timedOut ? 124 : (code ?? 1),
+                durationSec,
+                stdoutLines,
+                stdoutTotal,
+                stderrLines,
+                stderrTotal,
+                timedOut,
+                findings,
+            });
+        });
+    });
+}
+async function mapWithConcurrency(items, limit, fn) {
+    const results = new Array(items.length);
+    let idx = 0;
+    const workers = Array.from({ length: Math.min(limit, items.length) }, async () => {
+        while (idx < items.length) {
+            const i = idx;
+            idx += 1;
+            if (i >= items.length) {
+                return;
+            }
+            results[i] = await fn(items[i]);
+        }
+    });
+    await Promise.all(workers);
+    return results;
+}
+const IS_CI_OR_VERCEL = process.env.CI === "1" ||
+    process.env.CI === "true" ||
+    process.env.VERCEL === "1" ||
+    process.env.VERCEL === "true";
+const CONSOLIDATED_MODULES = [
+    // Runtime safety checks (blocking)
+    {
+        name: "No process.env in client code",
+        path: "scripts/active/preflights/runtime/client-process-env-usage.ts",
+        blocking: true,
+        description: "Prevent Next.js 16 client-runtime crashes from process.env usage in client components/hooks",
+    },
+    {
+        name: "JSON.parse Safety",
+        path: "scripts/active/preflights/runtime/json-parse-safety.ts",
+        blocking: true,
+        description: "Block: JSON.parse(request.text()) must be guarded to prevent runtime crashes",
+    },
+    {
+        name: "publicEnv import required",
+        path: "scripts/active/preflights/runtime/missing-public-env-import.ts",
+        blocking: true,
+        description: "Prevent runtime ReferenceError by requiring publicEnv import when used in client code",
+    },
+    {
+        name: "Unsafe process stdio writes",
+        path: "scripts/active/preflights/runtime/process-stdio-usage.ts",
+        blocking: true,
+        description: "Prevent client-runtime crashes from process.stdout/stderr.write usage in shared code",
+    },
+    {
+        name: "Client Runtime Errors",
+        path: "scripts/active/preflights/runtime/client-runtime-errors.ts",
+        blocking: true,
+        description: "Detect unhandled Promise rejections and unsafe property access that cause runtime crashes",
+    },
+    {
+        name: "Runtime GTM Installation",
+        path: "scripts/active/preflights/runtime/gtm-installation.ts",
+        blocking: true,
+        description: "Ensure Google Tag Manager is installed (script + noscript) and gated by public env flags",
+    },
+    {
+        name: "Dev Error Monitoring",
+        path: "scripts/active/preflights/runtime/dev-error-monitoring-system.ts",
+        blocking: true,
+        description: "Enforce dev-only runtime error logging wiring: DevErrorBoundary -> /api/dev/errors -> runtime-errors.json -> /dev/errors dashboard",
+    },
+    {
+        name: "Server${chars.arrow}Client Decimal",
+        path: "scripts/active/preflights/runtime/server-client-decimal.ts",
+        blocking: true,
+        description: 'Prevent "Decimal objects are not supported" runtime error when passing Prisma data to Client Components',
+    },
+    {
+        name: "Runtime (Consolidated)",
+        path: "scripts/active/preflights/consolidated/runtime.ts",
+        blocking: true,
+        description: "Consolidated runtime checks: env usage, GTM, node deprecations, tailwind runtime, decimal safety",
+    },
+    // Environment hygiene (blocking)
+    {
+        name: "Env file hygiene",
+        path: "scripts/active/preflights/security/no-tracked-env-files.ts",
+        blocking: true,
+        description: "Warn on tracked .env.* files; block on high-risk tracked files like .env/.env.local",
+    },
+    {
+        name: "Env value leakage",
+        path: "scripts/active/preflights/security/env-value-leakage.ts",
+        blocking: true,
+        description: "Block: secret-looking env values outside .env files; warn on suspicious assignments",
+    },
+    {
+        name: "Env duplicates",
+        path: "scripts/active/preflights/environment/env-duplicates.ts",
+        blocking: true,
+        description: "Block: legacy/duplicate env var names (e.g., GOOGLE_ID vs GOOGLE_CLIENT_ID)",
+    },
+    {
+        name: "Production Config",
+        path: "scripts/active/preflights/deployment/production-config.ts",
+        blocking: IS_CI_OR_VERCEL,
+        description: "Validate production environment variables, security headers, and monitoring setup",
+    },
+    {
+        name: "Vercel Function Config",
+        path: "scripts/active/preflights/deployment/check-vercel-function-config.mjs",
+        blocking: true,
+        description: "Block: Long-running functions must have timeout bailout, AI operations must check VERCEL env",
+    },
+    // Next.js build compatibility (blocking)
+    {
+        name: "Dynamic Route Exports",
+        path: "scripts/active/preflights/nextjs/dynamic-route-exports.ts",
+        blocking: true,
+        description: "Block: export const dynamic incompatible with cacheComponents: true",
+    },
+    {
+        name: "Metadata API Placement",
+        path: "scripts/active/preflights/nextjs/metadata-api-placement.ts",
+        blocking: true,
+        description: "Block: generateSitemaps() in route handlers causes '__metadata_id__' vs '[id]' slug conflict",
+    },
+    {
+        name: "No ignoreBuildErrors",
+        path: "scripts/active/preflights/nextjs/ignore-build-errors.ts",
+        blocking: true,
+        description: "Block: ignoreBuildErrors must never be true - causes runtime errors from missed type checks",
+    },
+    {
+        name: "Essential Files",
+        path: "scripts/active/preflights/nextjs/essential-files-validation.ts",
+        blocking: true,
+        description: "Validate critical files exist: error pages (404, 500, error.tsx), layout, loading, config",
+    },
+    // Hardened checks (CRITICAL - iron-clad rules that block deployment)
+    {
+        name: "Hardened Checks",
+        path: "scripts/active/preflights/consolidated/hardened-checks.ts",
+        blocking: true,
+        description: "DRAFT status, CVA enforcement, async error handling, secrets, hooks, promises, type safety",
+    },
+    // Core checks
+    // IMPORTANT: Lint validation catches missing imports, unused vars, and code quality issues that cause runtime errors.
+    {
+        name: "Lint Validation",
+        path: "scripts/active/preflights/specialized/lint-validation.ts",
+        blocking: true,
+        description: "ESLint validation - catches missing imports and code quality issues",
+    },
+    // IMPORTANT: Prevents lint:fix from removing React type imports (HTMLAttributes, ChangeEvent, etc.)
+    // Also recognizes React.X namespace access as valid when React is imported as default.
+    {
+        name: "Critical Type Imports",
+        path: "scripts/active/preflights/quality/critical-type-imports.ts",
+        blocking: true,
+        description: "Validates React/CVA type imports aren't removed by ESLint unused-imports rule",
+    },
+    // NOTE: Detects React.X namespace usage and recommends direct type imports
+    // Non-blocking warning - existing code allowed, prefer direct imports for new code
+    {
+        name: "React Namespace Import",
+        path: "scripts/active/preflights/quality/react-namespace-import.ts",
+        blocking: false,
+        description: "Warns about React.X namespace usage (prefer direct type imports)",
+    },
+    // IMPORTANT: Catches duplicate JSX attributes (e.g., two className props)
+    // This commonly happens when ESLint auto-fix adds attributes that already exist
+    {
+        name: "Duplicate JSX Attributes",
+        path: "scripts/active/preflights/quality/duplicate-jsx-attributes.ts",
+        blocking: true,
+        description: "Detects JSX elements with duplicate attributes (TS17001)",
+    },
+    // IMPORTANT: Next build is configured to skip type validation, so we must block in CI/Vercel.
+    {
+        name: "TypeScript",
+        path: "scripts/active/preflights/consolidated/typescript.ts",
+        blocking: IS_CI_OR_VERCEL,
+        description: IS_CI_OR_VERCEL
+            ? "TypeScript reference/type check (blocking in CI/Vercel)"
+            : "TypeScript reference/type check (non-blocking warning)",
+    },
+    {
+        name: "Imports",
+        path: "scripts/active/preflights/consolidated/imports.ts",
+        blocking: true,
+        description: "Import validation, hook imports, source consistency",
+    },
+    {
+        name: "Enterprise Baseline",
+        path: "scripts/active/preflights/consolidated/enterprise-baseline.ts",
+        blocking: false,
+        description: "Secrets, raw <img>, missing loading/error/not-found, API zod/try-catch, cookie flags, large assets/JSON",
+    },
+    {
+        name: "Component Imports",
+        path: "scripts/active/preflights/component-imports.ts",
+        blocking: true,
+        description: "Enforce @/components/ui usage (no direct @supercatch/ui or MUI imports)",
+    },
+    {
+        name: "Primitive Enforcement",
+        path: "scripts/active/preflights/architecture/primitive-component-enforcement.ts",
+        blocking: true,
+        description: "Block duplicate primitive definitions outside packages/ui and components/ui",
+    },
+    {
+        name: "File Naming",
+        path: "scripts/active/preflights/file-naming-conventions.ts",
+        blocking: true,
+        description: "PascalCase components, kebab-case lib, camelCase hooks",
+    },
+    {
+        name: "File Hygiene",
+        path: "scripts/active/preflights/file-hygiene-validation.ts",
+        blocking: true,
+        description: "Block version suffixes (-v2), temp markers (-old, -new, -wip), route segment drift",
+    },
+    {
+        name: "Root File Hygiene",
+        path: "scripts/active/preflights/code-hygiene/root-file-hygiene.ts",
+        blocking: true,
+        description: "Block orphaned fix-*/cleanup-*/debug-*/check-*/test-* scripts in project root",
+    },
+    {
+        name: "Security",
+        path: "scripts/active/preflights/consolidated/security.ts",
+        blocking: true,
+        description: "API routes, XSS prevention, external links",
+    },
+    {
+        name: "Open Redirect Prevention",
+        path: "scripts/active/preflights/security/open-redirect-prevention.ts",
+        blocking: true,
+        description: "Block: redirect()/router navigation must not use user-controlled callbackUrl/returnTo without validation",
+    },
+    {
+        name: "Database",
+        path: "scripts/active/preflights/consolidated/database.ts",
+        blocking: true,
+        description: "Schema validation, Prisma checks",
+    },
+    {
+        name: "Prisma Field Names",
+        path: "scripts/active/preflights/prisma-field-validation.js",
+        blocking: true,
+        description: "Validate Prisma field names match schema (catches cardName vs name, etc.)",
+    },
+    {
+        name: "Prisma Over-Fetching",
+        path: "scripts/active/preflights/database/prisma-overfetch-detection.ts",
+        blocking: true,
+        description: "Detect queries without select clause on large tables (prevents SELECT *)",
+    },
+    {
+        name: "Unused Schema",
+        path: "scripts/active/preflights/database/unused-schema-detection.ts --strict",
+        blocking: true,
+        description: "Detect unused Prisma models/fields not referenced in codebase",
+    },
+    {
+        name: "Schema Best Practices",
+        path: "scripts/active/preflights/database/schema-best-practices.ts",
+        blocking: false,
+        description: "Validate schema has timestamps, FK indexes, and reasonable model sizes",
+    },
+    {
+        name: "TCG Seed Validation",
+        path: "scripts/active/preflights/database/tcg-seed-validation.ts",
+        blocking: true,
+        description: "Validate TCG card seed data has required fields for clickable products",
+    },
+    {
+        name: "Email Templates",
+        path: "scripts/active/preflights/email/email-template-validation.ts",
+        blocking: true,
+        description: "Validate local email templates: required types exist, naming conventions, no DB queries",
+    },
+    {
+        name: "Email Templates (DB)",
+        path: "scripts/active/preflights/email/email-template-db-verification.ts",
+        blocking: !IS_CI_OR_VERCEL,
+        description: "Verify v2 email templates are seeded in DB + wrapped correctly (skips in CI/Vercel if DATABASE_URL missing)",
+    },
+    {
+        name: "Email Flows",
+        path: "scripts/active/preflights/email/email-flow-validation.ts",
+        blocking: true,
+        description: "Validate email-based auth flows: password reset, team invitation, email verification have working routes",
+    },
+    {
+        name: "Dependency Health",
+        path: "scripts/active/preflights/dependencies/dependency-health-monitor.ts",
+        blocking: false,
+        description: "Dependency specifier risks + pnpm lockfile multi-version signals",
+    },
+    {
+        name: "Serverless Compatibility",
+        path: "scripts/active/preflights/dependencies/check-serverless-compatibility.mjs",
+        blocking: false,
+        description: "Warn: detect packages and patterns with known serverless issues (native modules, workers, filesystem)",
+    },
+    {
+        name: "Weekly Stable Updates",
+        path: "scripts/active/preflights/dependencies/weekly-stable-updates.ts",
+        blocking: true,
+        description: "Once-per-week stable dependency freshness check (skips if last success < interval)",
+    },
+    {
+        name: "Store Order Numbers",
+        path: "scripts/active/preflights/store-order-numbers.ts",
+        blocking: true,
+        description: "Store-scoped order number validation",
+    },
+    {
+        name: "Business",
+        path: "scripts/active/preflights/consolidated/business.ts",
+        blocking: false,
+        description: "DRAFT status, cache-first, critical workflows",
+    },
+    {
+        name: "Recognition Pipeline",
+        path: "scripts/active/preflights/ai/recognition-pipeline-validation.ts",
+        blocking: true,
+        description: "Cache-first pattern, enhancement integration, cost protection, error handling",
+    },
+    {
+        name: "Price Display Validation",
+        path: "scripts/active/preflights/business/price-display-validation.ts",
+        blocking: true,
+        description: "Block: UI must not format currency with $${amount.toFixed(2)}; use formatCurrency()",
+    },
+    {
+        name: "Regression Hygiene",
+        path: "scripts/active/preflights/consolidated/regression-hygiene.ts",
+        blocking: true,
+        description: "Static validation: regression test organization, skips/only, and domain coverage",
+    },
+    {
+        name: "Testing (Consolidated)",
+        path: "scripts/active/preflights/consolidated/testing.ts",
+        blocking: true,
+        description: "Consolidated testing checks: regression requirements, coverage, flake/timeout patterns",
+    },
+    // E2E Testing (CONSOLIDATED - replaces 15+ individual E2E preflights)
+    {
+        name: "E2E Validation",
+        path: "scripts/active/preflights/consolidated/e2e-validation.ts",
+        blocking: true,
+        description: "CONSOLIDATED: best practices, outcome validation, flake patterns, timeouts, performance, organization",
+    },
+    {
+        name: "E2E Regression Coverage",
+        path: "scripts/active/preflights/consolidated/e2e-regression-coverage.ts",
+        blocking: true,
+        description: "Static validation: required E2E regression specs exist (mobile basics) and are not skipped",
+    },
+    {
+        name: "E2E Checks (Consolidated)",
+        path: "scripts/active/preflights/consolidated/e2e-checks.ts",
+        blocking: true,
+        description: "Consolidated E2E checks: interaction coverage, performance patterns, redundancy scan, config validation",
+    },
+    {
+        name: "Integration E2E Depth",
+        path: "scripts/active/preflights/testing/integration-e2e-depth.ts",
+        blocking: true,
+        description: "Block: integration regression specs must have an in-app connect-flow E2E (not just API connectivity checks)",
+    },
+    {
+        name: "E2E Interaction Scan",
+        path: "scripts/active/preflights/e2e/e2e-interaction-coverage-scan.ts --actions",
+        blocking: true,
+        description: "Scan for interactive elements and ensure they are covered by E2E tests",
+    },
+    // Testing coverage enforcement (static / fast)
+    {
+        name: "Coverage Gap Analysis",
+        path: "scripts/active/preflights/coverage-gap-analysis.ts",
+        blocking: true,
+        description: "Static coverage contract: every app page has likely E2E coverage; dynamic routes have example URLs; critical routes cannot be smoke-only/low-signal-only",
+    },
+    {
+        name: "Playwright Feature Coverage Gaps",
+        path: "scripts/active/preflights/testing/playwright-feature-coverage-gaps.ts --warn",
+        blocking: false,
+        description: "Proactively discovers missing E2E test scenarios by scanning source code for APIs, actions, forms and comparing against test coverage",
+    },
+    {
+        name: "Action Regression Coverage",
+        path: "scripts/active/preflights/testing/action-regression.ts",
+        blocking: true,
+        description: "Enforce: every app/actions/* has a corresponding regression/E2E test",
+    },
+    {
+        name: "Data Entry Requires Regression",
+        path: "scripts/active/preflights/testing/data-entry-regression-required.ts",
+        blocking: true,
+        description: "Enforce: data-entry UI changes require regression test changes in the diff",
+    },
+    {
+        name: "Test Patterns",
+        path: "scripts/active/preflights/testing/test-patterns.ts",
+        blocking: true,
+        description: "Validate test naming/placement and Playwright hook signatures",
+    },
+    {
+        name: "Decimal Serialization",
+        path: "scripts/active/preflights/specialized/decimal-serialization.ts --warn",
+        blocking: false,
+        description: "Check Decimal type serialization to prevent precision loss",
+    },
+    {
+        name: "ID Format Validation",
+        path: "scripts/active/preflights/specialized/database-id-format.js --warn",
+        blocking: false,
+        description: "Validate ID format standards (no numeric IDs, proper typing)",
+    },
+    {
+        name: "AI Code Quality",
+        path: "scripts/active/preflights/ai/code-quality-ai.ts",
+        blocking: false,
+        description: "AI-powered detection of complexity, race conditions, and security issues",
+    },
+    {
+        name: "Runtime Performance Regression",
+        path: "scripts/active/preflights/performance/runtime-regression.ts",
+        blocking: true,
+        description: "Monitor bundle size, Core Web Vitals, and performance regressions",
+    },
+    {
+        name: "Core Web Vitals Budget",
+        path: "scripts/active/preflights/performance/core-web-vitals.ts",
+        blocking: IS_CI_OR_VERCEL,
+        description: "Enforce Core Web Vitals performance budgets (LCP, FID, CLS) and Lighthouse scores",
+    },
+    {
+        name: "Preflight Performance Optimizer",
+        path: "scripts/active/preflights/system/preflight-performance-optimizer.ts",
+        blocking: false,
+        description: "Optimize preflight execution through caching and smart dependency analysis",
+    },
+    {
+        name: "Preflight Concurrency Support",
+        path: "scripts/active/preflights/system/preflight-concurrency-support.ts",
+        blocking: false,
+        description: "Validate all consolidated preflights support PREFLIGHT_CONCURRENCY env var",
+    },
+    {
+        name: "Preflight Reporting Standards",
+        path: "scripts/active/preflights/system/preflight-reporting-standards.ts",
+        blocking: false,
+        description: "Warn: consistent reporting UI and progress across all preflights",
+    },
+    {
+        name: "Preflight Redundancy",
+        path: "scripts/active/preflights/system/preflight-redundancy-detection.ts",
+        blocking: true,
+        description: "Detect redundant preflights: duplicate patterns, error codes, high overlap",
+    },
+    {
+        name: "Lint-Preflight Consistency",
+        path: "scripts/active/preflights/system/lint-preflight-consistency.ts",
+        blocking: true,
+        description: "Detect contradictions between ESLint config and preflight rules",
+    },
+    {
+        name: "Orphaned Preflights",
+        path: "scripts/active/preflights/system/find-orphaned-preflights.ts",
+        blocking: true,
+        description: "Detect orphaned preflights not used in any workflow - blocks if any found",
+    },
+    {
+        name: "Preflight Organization",
+        path: "scripts/active/preflights/system/preflight-organization.ts",
+        blocking: true,
+        description: "Ensure all preflights are referenced and categorized (UI/UX, Security, Business, DB/Data, Performance, Build/Runtime, Testing)",
+    },
+    {
+        name: "Orphaned Scripts (warn)",
+        path: "scripts/active/preflights/system/orphaned-scripts-detection.ts",
+        blocking: false,
+        description: "Warn: detect unreferenced scripts in scripts/active/ that may need archiving",
+    },
+    {
+        name: "Orphaned Pages",
+        path: "scripts/active/preflights/architecture/orphaned-pages-detection.ts --warn",
+        blocking: false,
+        description: "Detect pages not linked from navigation - warns if orphaned pages found",
+    },
+    {
+        name: "Styling Standards",
+        path: "scripts/active/preflights/ui/styling-standards.ts",
+        blocking: false,
+        description: "Tailwind + CVA architecture, MUI emulation detection",
+    },
+    {
+        name: "SX Prop Deprecation",
+        path: "scripts/active/preflights/consolidated/sx-prop-deprecation.ts --blocking",
+        blocking: true,
+        description: "No sx prop allowed - use Tailwind className",
+    },
+    {
+        name: "Architecture",
+        path: "scripts/active/preflights/architecture/component-architecture.ts",
+        blocking: true,
+        description: "Component organization, no duplicates, no root sprawl",
+    },
+    {
+        name: "Shared Components",
+        path: "scripts/active/preflights/specialized/shared-components-migration.ts",
+        blocking: true,
+        description: "Detect regressions: duplicates and bypassing shared components/utilities",
+    },
+    {
+        name: "Shared Utility Gaps",
+        path: "scripts/active/preflights/code-quality/shared-utility-gaps.ts",
+        blocking: false,
+        description: "Detect native confirm(), inline price/date formatting, inline error display",
+    },
+    {
+        name: "Unified Components",
+        path: "scripts/active/preflights/unified-components-check.js",
+        blocking: false,
+        description: "Detect duplicate component patterns (sidebars, cards, tables, filters)",
+    },
+    {
+        name: "Shared Component Drift",
+        path: "scripts/active/preflights/shared-component-drift.js",
+        blocking: false,
+        description: "Detect UI inconsistencies across shared components (FilterBar, SearchInput, etc.)",
+    },
+    {
+        name: "Consolidation Opportunities",
+        path: "scripts/active/preflights/architecture/component-consolidation-opportunities.ts",
+        blocking: true,
+        description: "Detect patterns that should use shared components (blocks on anti-patterns)",
+    },
+    // UI checks (blocking)
+    // NOTE: button-consistency.ts was removed - functionality consolidated elsewhere
+    // {
+    //   name: "Button Consistency",
+    //   path: "scripts/active/preflights/ui/button-consistency.ts",
+    //   blocking: true,
+    //   description: "Use AnimatedButton for user-facing buttons, no mixed usage",
+    // },
+    {
+        name: "UI Uniformity",
+        path: "scripts/active/preflights/governance/check-ui-uniformity.ts",
+        blocking: true,
+        description: "Detect non-uniform action buttons (should use AdminActions)",
+    },
+    {
+        name: "UI Checks (Consolidated)",
+        path: "scripts/active/preflights/consolidated/ui-checks.ts",
+        blocking: false, // Changed to non-blocking - many pre-existing issues need incremental fixes
+        description: "Consolidated UI checks: accessibility, spacing, chips, headers, cards, images, skeletons, typography",
+    },
+    {
+        name: "Filter UI Patterns",
+        path: "scripts/active/preflights/ui/filter-ui-patterns.js",
+        blocking: true,
+        description: "Enforces consistent filter/search layout and UnifiedEmptyState",
+    },
+    {
+        name: "UI Components",
+        path: "scripts/active/preflights/consolidated/ui-components.ts",
+        blocking: true,
+        description: "Component library, button-link pattern",
+    },
+    {
+        name: "JS Responsive Visibility",
+        path: "scripts/active/preflights/ui/js-responsive-visibility.ts",
+        blocking: true,
+        description: "Block JS state-based responsive visibility (useState + matchMedia + return null) - use CSS classes instead",
+    },
+    {
+        name: "Dead Action Detector",
+        path: "scripts/active/preflights/ui/dead-action-detector.ts",
+        blocking: false,
+        description: "Detect UI buttons/actions with no onClick handler or empty placeholder handlers",
+    },
+    {
+        name: "Notification Feedback",
+        path: "scripts/active/preflights/ui/notification-feedback-check.ts",
+        blocking: false,
+        description: "Async operations must have toast feedback (useStatus), inline alerts for form validation only",
+    },
+    {
+        name: "UI Navigation",
+        path: "scripts/active/preflights/consolidated/ui-navigation.ts",
+        blocking: true,
+        description: "Sidebars, breadcrumbs, footers, navigation layout",
+    },
+    {
+        name: "Breadcrumb Consistency",
+        path: "scripts/active/preflights/ui/breadcrumb-consistency.ts",
+        blocking: false,
+        description: "Breadcrumb positioning consistency across pages",
+    },
+    {
+        name: "UI Patterns",
+        path: "scripts/active/preflights/consolidated/ui-patterns.ts",
+        blocking: false,
+        description: "Category chips, consistent patterns",
+    },
+    {
+        name: "UI Spacing",
+        path: "scripts/active/preflights/consolidated/ui-spacing.ts",
+        blocking: false,
+        description: "Layout, spacing, design tokens",
+    },
+    {
+        name: "UI Spacing Standards",
+        path: "scripts/active/preflights/consolidated/ui-spacing-standards.ts",
+        blocking: true,
+        description: "Card container gap-4, page header spacing-3, layout spacing chain",
+    },
+    // NOTE: button-after-grid-spacing.ts was removed - functionality consolidated elsewhere
+    // {
+    //   name: "Button After Grid Spacing",
+    //   path: "scripts/active/preflights/ui/button-after-grid-spacing.ts",
+    //   blocking: true,
+    //   description: "Buttons/action containers after grids must have mt-6 spacing",
+    // },
+    {
+        name: "CSS Grid Gap",
+        path: "scripts/active/preflights/ui/css-grid-gap-check.ts",
+        blocking: true,
+        description: "CSS grid layouts must have gap property to prevent form fields without spacing",
+    },
+    {
+        name: "Form Control Layout",
+        path: "scripts/active/preflights/ui/form-control-layout-check.ts",
+        blocking: true,
+        description: "FormControlLabel must not have className=block (breaks toggle layout), siblings need Stack wrapper",
+    },
+    {
+        name: "Form Field Consistency",
+        path: "scripts/active/preflights/ui/form-field-consistency.ts",
+        blocking: true,
+        description: "Ensure consistent form field styling: TextField with slotProps={{ inputLabel: { shrink: true } }} for embedded labels",
+    },
+    // NOTE: formfield-placeholder-overlap.js was removed - functionality consolidated elsewhere
+    // {
+    //   name: "FormField Placeholder Overlap",
+    //   path: "scripts/active/preflights/ui/formfield-placeholder-overlap.js",
+    //   blocking: true,
+    //   description: "FormField with placeholder causes label overlap - use TextField directly",
+    // },
+    {
+        name: "Flex Icon-Text Gap",
+        path: "scripts/active/preflights/ui/flex-icon-text-gap.ts",
+        blocking: false,
+        description: "Flex containers with icon + text or stat rows must have gap property",
+    },
+    {
+        name: "Margin in Gap Container",
+        path: "scripts/active/preflights/ui/margin-in-gap-container.ts",
+        blocking: false, // Changed to non-blocking - 72 violations need gradual cleanup
+        description: "IRON-CLAD: No margin classes on children inside Stack/flex-gap containers",
+    },
+    {
+        name: "Dashboard UI",
+        path: "scripts/active/preflights/ui/dashboard-ui.ts",
+        blocking: true,
+        description: "IRON-CLAD: No margin on layout children + all content must be in Card (consolidated)",
+    },
+    {
+        name: "Dashboard Section Patterns",
+        path: "scripts/active/preflights/ui/dashboard-section-patterns.ts",
+        blocking: true,
+        description: "IRON-CLAD: Enforce Card > CardContent(p-0) > Box(px-4 pt-3 pb-0) + Divider pattern, shadow on nested boxes, gap-4 in card grids",
+    },
+    {
+        name: "Page Layout Spacing",
+        path: "scripts/active/preflights/ui/page-layout-spacing.ts",
+        blocking: true,
+        description: "IRON-CLAD: Uniform 12px spacing in layout chain (breadcrumbs → content → header)",
+    },
+    {
+        name: "Doubled Padding Detection",
+        path: "scripts/active/preflights/ui/doubled-padding-check.ts",
+        blocking: true,
+        description: "Detect doubled padding: nested pt-X classes AND inline style paddingTop + child pt-X",
+    },
+    {
+        name: "Label-Description Spacing",
+        path: "scripts/active/preflights/ui/label-description-spacing.ts",
+        blocking: true,
+        description: "Detect negative margins pulling labels too close to description text",
+    },
+    {
+        name: "Header Actions Detection",
+        path: "scripts/active/preflights/ui/header-actions-detection.js",
+        blocking: true,
+        description: "UnifiedHeader actions should only contain buttons/badges, not toggles/text",
+    },
+    {
+        name: "Header Action Text Color",
+        path: "scripts/active/preflights/ui/header-action-text-color.ts",
+        blocking: true,
+        description: "UnifiedHeader PageHeader actions must have white text override for buttons on blue gradient background",
+    },
+    {
+        name: "UI Accessibility",
+        path: "scripts/active/preflights/consolidated/ui-accessibility.ts",
+        blocking: true,
+        description: "WCAG checks: labels, duplicate labels, ARIA, focus, touch",
+    },
+    {
+        name: "Accessibility Critical",
+        path: "scripts/active/preflights/ui/accessibility-critical.ts",
+        blocking: true,
+        description: "Critical a11y: alt text, ARIA labels, text-foreground on colored backgrounds",
+    },
+    {
+        name: "Tailwind Contrast",
+        path: "scripts/active/preflights/ui/tailwind-contrast-check.ts",
+        blocking: true,
+        description: "WCAG contrast: text-muted-foreground on colored backgrounds",
+    },
+    {
+        name: "UI Loading Skeletons",
+        path: "scripts/active/preflights/consolidated/ui-loading-skeletons.ts",
+        blocking: true,
+        description: "Route-level loading.tsx must use skeletons (no spinners)",
+    },
+    {
+        name: "Skeleton Size Consistency",
+        path: "scripts/active/preflights/ui/skeleton-size-consistency.ts",
+        blocking: false,
+        description: "Skeleton dimensions must match actual component dimensions to prevent layout shift",
+    },
+    {
+        name: "UI Forms",
+        path: "scripts/active/preflights/consolidated/ui-forms.ts",
+        blocking: false,
+        description: "Form field validation, spacing, sizing, padding",
+    },
+    {
+        name: "UI Tokens",
+        path: "scripts/active/preflights/consolidated/ui-tokens.ts",
+        blocking: false,
+        description: "Token enforcement (colors, spacing, z-index, shadows, animation)",
+    },
+    {
+        name: "UI Style Validation",
+        path: "scripts/active/preflights/consolidated/ui-style-validation.ts",
+        blocking: false,
+        description: "Invalid DOM props, Tailwind enforcement, style conflicts",
+    },
+    // UI Layout is intentionally non-blocking here until the codebase is fully compliant
+    {
+        name: "UI Layout",
+        path: "scripts/active/preflights/consolidated/ui-layout.ts",
+        blocking: false,
+        description: "Page templates, centering, header spacing, excessive spacing",
+    },
+    {
+        name: "UI Advanced Spacing",
+        path: "scripts/active/preflights/consolidated/ui-advanced-spacing.ts",
+        blocking: false,
+        description: "Tables, dialogs, tabs, empty/loading states spacing patterns",
+    },
+    {
+        name: "UI Typography",
+        path: "scripts/active/preflights/consolidated/ui-typography.ts",
+        blocking: false,
+        description: "Typography hierarchy and consistency",
+    },
+    {
+        name: "UI Responsive",
+        path: "scripts/active/preflights/consolidated/ui-responsive.ts",
+        blocking: false,
+        description: "Responsive layout and breakpoint consistency",
+    },
+    {
+        name: "UI Media",
+        path: "scripts/active/preflights/consolidated/ui-media.ts",
+        blocking: false,
+        description: "Images/media usage and responsive behavior",
+    },
+    {
+        name: "UI Loading State Skeletons",
+        path: "scripts/active/preflights/consolidated/ui-loading-state-skeletons.ts",
+        blocking: false,
+        description: "Warn when page-level spinners are used for loading states",
+    },
+    // Organization checks (CSS is blocking due to global reset danger)
+    {
+        name: "CSS Organization",
+        path: "scripts/active/preflights/consolidated/css-organization.ts",
+        blocking: true,
+        description: "CSS architecture, dangerous global resets detection",
+    },
+    {
+        name: "CSS Runtime",
+        path: "scripts/active/preflights/consolidated/css-runtime-validation.ts",
+        blocking: true,
+        description: "CSS runtime validation, Tailwind override detection",
+    },
+    {
+        name: "CSS Variables",
+        path: "scripts/active/preflights/consolidated/css-variable-validation.ts",
+        blocking: true,
+        description: "CSS variable typos and undefined variables",
+    },
+    {
+        name: "Tailwind Classes",
+        path: "scripts/active/preflights/consolidated/tailwind-class-validation.ts",
+        blocking: true,
+        description: "Invalid Tailwind class names and typos",
+    },
+    {
+        name: "CSS Advanced",
+        path: "scripts/active/preflights/consolidated/css-advanced-validation.ts",
+        blocking: false,
+        description: "Z-index, colors, breakpoints, animations, specificity",
+    },
+    {
+        name: "Dark Mode",
+        path: "scripts/active/preflights/consolidated/dark-mode-consistency.ts",
+        blocking: false,
+        description: "Dark mode variant consistency",
+    },
+    {
+        name: "Inline Style Conflicts",
+        path: "scripts/active/preflights/consolidated/inline-style-conflicts.ts",
+        blocking: false,
+        description: "Tailwind vs inline style conflicts in TSX",
+    },
+    {
+        name: "UI Consistency Extended",
+        path: "scripts/active/preflights/consolidated/ui-consistency-extended.ts",
+        blocking: false,
+        description: "Icon sizes, button sizes, loading states, shadows",
+    },
+    {
+        name: "UI Consistency Advanced",
+        path: "scripts/active/preflights/consolidated/ui-consistency-advanced.ts",
+        blocking: true,
+        description: "Tooltips, modals, pagination, avatars, badges, dividers, transitions, overflow",
+    },
+    {
+        name: "UI Motion Accessibility",
+        path: "scripts/active/preflights/consolidated/ui-motion-accessibility.ts",
+        blocking: true,
+        description: "WCAG motion/accessibility: reduced motion support and safe animation patterns",
+    },
+    {
+        name: "UI Microcopy Consistency",
+        path: "scripts/active/preflights/consolidated/ui-microcopy-consistency.ts",
+        blocking: true,
+        description: "Blocking: UX microcopy standards (Close/Cancel/Delete/Remove/etc)",
+    },
+    {
+        name: "UI Interactive States",
+        path: "scripts/active/preflights/consolidated/ui-interactive-states.ts",
+        blocking: true,
+        description: "Blocking: hover/active/focus/disabled state consistency",
+    },
+    {
+        name: "Product Image Animations",
+        path: "scripts/active/preflights/ui/product-image-animations.ts",
+        blocking: true,
+        description: "Blocking: product cards/images must not use hover animations",
+    },
+    {
+        name: "UI Consistency Comprehensive",
+        path: "scripts/active/preflights/consolidated/ui-consistency-comprehensive.ts",
+        blocking: true,
+        description: "Card elevation, inputs, animations, z-index, breakpoints, colors, fonts, borders",
+    },
+    {
+        name: "Lib Organization",
+        path: "scripts/active/preflights/consolidated/lib-organization.ts",
+        blocking: false,
+        description: "Lib directory structure, barrel exports",
+    },
+    // UX checks (non-blocking)
+    {
+        name: "Homepage UX",
+        path: "scripts/active/preflights/consolidated/homepage-ux.ts",
+        blocking: false,
+        description: "Search bar, pagination, loading states",
+    },
+    // UI Standards Enforcement (blocking)
+    {
+        name: "UI Standards",
+        path: "scripts/active/preflights/consolidated/ui-standards-enforcement.ts",
+        blocking: true,
+        description: "Card shadows, typography, button sizes, icon sizes, alert spacing, form density",
+    },
+    // Quality checks (non-blocking) - includes duplicate logic & type safety
+    {
+        name: "Quality",
+        path: "scripts/active/preflights/consolidated/quality.ts",
+        blocking: false,
+        description: "Code quality, linting, file size, duplicate logic, type safety",
+    },
+    {
+        name: "Performance",
+        path: "scripts/active/preflights/consolidated/performance.ts",
+        blocking: false,
+        description: "Bundle size, image optimization, lazy loading, N+1 queries",
+    },
+    {
+        name: "Script Performance",
+        path: "scripts/active/preflights/consolidated/script-performance.ts",
+        blocking: false,
+        description: "Warn when heavy scripts lack parallelism (e.g., --workers) or default to low concurrency",
+    },
+    // Framework-specific checks
+    {
+        name: "Turbopack Enforcement",
+        path: "scripts/active/preflights/framework/turbopack-enforcement.ts",
+        blocking: true,
+        description: "Ensure dev/build use Turbopack (--turbo) for 10x faster HMR",
+    },
+    {
+        name: "React",
+        path: "scripts/active/preflights/consolidated/react.ts",
+        blocking: false,
+        description: "React patterns, hooks usage",
+    },
+    {
+        name: "React Best Practices",
+        path: "scripts/active/preflights/react/component-best-practices.ts",
+        blocking: false,
+        description: "Duplicate JSX attributes, inline objects, missing keys, component size",
+    },
+    {
+        name: "Next.js",
+        path: "scripts/active/preflights/consolidated/nextjs.ts",
+        blocking: false,
+        description: "Next.js patterns, routing",
+    },
+    {
+        name: "Next.js Image",
+        path: "scripts/active/preflights/nextjs/nextjs-image-validation.ts",
+        blocking: false,
+        description: 'Image aspect ratio, LCP optimization, loading="eager"',
+    },
+    // Additional checks
+    {
+        name: "Images",
+        path: "scripts/active/preflights/consolidated/images.ts",
+        blocking: false,
+        description: "Image optimization, width/height, priority prop",
+    },
+    {
+        name: "Code Quality",
+        path: "scripts/active/preflights/consolidated/code-quality.ts",
+        blocking: false,
+        description: "ESLint, strict mode",
+    },
+    {
+        name: "Unicode Console Compatibility",
+        path: "scripts/active/preflights/code-hygiene/unicode-console-compatibility.ts",
+        blocking: false,
+        description: "Detect Unicode chars that break on Windows CMD (█░▓▒)",
+    },
+    {
+        name: "UI Cleanup",
+        path: "scripts/active/preflights/consolidated/ui-cleanup.ts",
+        blocking: false,
+        description: "MUI overrides, scrollbar consistency, semantic HTML",
+    },
+    // Shipping integration
+    {
+        name: "Shipping Integration",
+        path: "scripts/active/preflights/shipping-integration-validation.ts",
+        blocking: true,
+        description: "Shipping rules wired to checkout, all types handled",
+    },
+    // Hardcoded options detection
+    {
+        name: "Hardcoded Options",
+        path: "scripts/active/preflights/hardcoded-options-validation.js",
+        blocking: true,
+        description: "Detect hardcoded category/status arrays that should use constants",
+    },
+    // Store profile normalization
+    {
+        name: "Store Specialties Normalization",
+        path: "scripts/active/preflights/specialized/store-specialties-normalization.ts",
+        blocking: true,
+        description: "Prevent drift: specialties constants must be canonical (normalized) values",
+    },
+    // Code hygiene checks
+    {
+        name: "Console Chars Sync",
+        path: "scripts/active/preflights/code-hygiene/console-chars-sync.ts",
+        blocking: false, // Non-blocking - JS shim sync is nice-to-have, not critical
+        description: "Ensure console-chars TS/JS files stay in sync",
+    },
+    {
+        name: "Empty Catch Blocks",
+        path: "scripts/active/preflights/code-hygiene/empty-catch-detection.ts",
+        blocking: true,
+        description: "Detect empty catch blocks that silently swallow errors",
+    },
+    {
+        name: "API Error Handling",
+        path: "scripts/active/preflights/code-hygiene/api-error-handling.ts",
+        blocking: false,
+        description: "Ensure API routes have proper try-catch error handling",
+    },
+    {
+        name: "Log Level Misuse",
+        path: "scripts/active/preflights/code-hygiene/log-level-misuse.ts",
+        blocking: true,
+        description: "Detect logger.warn used for info/debug messages",
+    },
+    {
+        name: "Missing Logger Import",
+        path: "scripts/active/preflights/code-hygiene/missing-logger-import.ts",
+        blocking: true,
+        description: "Detect files using logger without importing it",
+    },
+    {
+        name: "Console.log Detection",
+        path: "scripts/active/preflights/code-hygiene/console-log-detection.ts --warning",
+        blocking: false,
+        description: "Detect console.log statements in production code",
+    },
+    {
+        name: "Log Message Casing",
+        path: "scripts/active/preflights/specialized/log-message-casing.mjs",
+        blocking: false,
+        description: "Consistent Title Case in console.log messages (no ALL_CAPS enums)",
+    },
+    {
+        name: "Any Type Detection",
+        path: "scripts/active/preflights/code-hygiene/any-type-detection.ts --warning",
+        blocking: false,
+        description: "Detect any type usage that bypasses TypeScript safety",
+    },
+    {
+        name: "Dead Code Detection",
+        path: "scripts/active/preflights/code-hygiene/dead-code-detection.ts",
+        blocking: true,
+        description: "Detect unused variables and parameters (noUnusedLocals/noUnusedParameters)",
+    },
+    {
+        name: "Comment Hygiene",
+        path: "scripts/active/preflights/code-hygiene/comment-hygiene.ts",
+        blocking: true,
+        description: "Detect commented-out code and excessive comment ratios (>30%)",
+    },
+    {
+        name: "Decorative Separators",
+        path: "scripts/active/preflights/code-hygiene/decorative-separators.ts",
+        blocking: true,
+        description: "Detect wasteful decorative separators (===, ---, box-drawing chars)",
+    },
+    {
+        name: "Broken Template Literals",
+        path: "scripts/active/preflights/code-hygiene/broken-template-literals.ts",
+        blocking: true,
+        description: "Detect template literal syntax in regular strings that never resolve",
+    },
+    {
+        name: "Dead CSS Detection",
+        path: "scripts/active/preflights/css/dead-css-detection.ts",
+        blocking: false,
+        description: "Detects unused CSS classes and variables that bloat bundles",
+    },
+    {
+        name: "TODO Tracking",
+        path: "scripts/active/preflights/code-hygiene/todo-tracking.ts",
+        blocking: false,
+        description: "Track TODO/FIXME comments for visibility",
+    },
+    {
+        name: "No Console in Production",
+        path: "scripts/active/preflights/code-quality/no-console-production.ts",
+        blocking: true,
+        description: "Block console.log statements in production code paths",
+    },
+    {
+        name: "Magic Number Detection",
+        path: "scripts/active/preflights/code-quality/magic-number-detection.ts",
+        blocking: false,
+        description: "Detect hardcoded magic numbers that should be named constants",
+    },
+    {
+        name: "Feature Flag Hygiene",
+        path: "scripts/active/preflights/code-quality/feature-flag-hygiene.ts",
+        blocking: false,
+        description: "Detect stale feature flags and tech debt accumulation",
+    },
+    // Business logic validation (CRITICAL - prevents financial/inventory bugs)
+    {
+        name: "Price Calculation Safety",
+        path: "scripts/active/preflights/business/price-calculation-validation.ts",
+        blocking: true,
+        description: "Detect floating point arithmetic on prices (use Decimal.js)",
+    },
+    {
+        name: "Currency Precision",
+        path: "scripts/active/preflights/business/currency-precision.ts",
+        blocking: true,
+        description: "Validate monetary calculations use proper precision",
+    },
+    {
+        name: "Order State Machine",
+        path: "scripts/active/preflights/business/order-state-machine-validation.ts",
+        blocking: false,
+        description: "Validate order status transitions follow state machine",
+    },
+    {
+        name: "Inventory Atomicity",
+        path: "scripts/active/preflights/business/inventory-atomicity-validation.ts",
+        blocking: true,
+        description: "Detect race conditions in inventory operations",
+    },
+    // Security validation (CRITICAL - prevents security vulnerabilities)
+    {
+        name: "Rate Limiting",
+        path: "scripts/active/preflights/security/rate-limiting-validation.ts",
+        blocking: true,
+        description: "Ensure auth endpoints have rate limiting",
+    },
+    {
+        name: "Webhook Security",
+        path: "scripts/active/preflights/security/webhook-security-validation.ts",
+        blocking: true,
+        description: "Validate webhook signature verification",
+    },
+    {
+        name: "Path Traversal",
+        path: "scripts/active/preflights/security/path-traversal-prevention.ts",
+        blocking: true,
+        description: "Prevent file path traversal attacks",
+    },
+    {
+        name: "SQL Injection",
+        path: "scripts/active/preflights/security/sql-injection-prevention.ts",
+        blocking: true,
+        description: "Detect SQL injection vulnerabilities in raw queries",
+    },
+    {
+        name: "Unvalidated Route Params",
+        path: "scripts/active/preflights/security/unvalidated-route-params.ts",
+        blocking: true,
+        description: "Detect route params used without validation (SQL injection risk)",
+    },
+    {
+        name: "Sensitive Data",
+        path: "scripts/active/preflights/security/sensitive-data-exposure.ts",
+        blocking: true,
+        description: "Prevent sensitive data exposure in API responses",
+    },
+    {
+        name: "Security SLA Enforcement",
+        path: "scripts/active/preflights/security/security-sla-enforcement.ts",
+        blocking: true,
+        description: "Enforce patching SLAs: critical 24h, high 7d, moderate 30d",
+    },
+    {
+        name: "CSRF Protection",
+        path: "scripts/active/preflights/security/csrf-protection.ts",
+        blocking: false,
+        description: "Validate CSRF protection on state-changing routes",
+    },
+    {
+        name: "Session Update Safety",
+        path: "scripts/active/preflights/auth/session-update-safety.ts",
+        blocking: true,
+        description: "Prevent login redirects from unsafe update() calls, idle refresh patterns, render-path updates",
+    },
+    {
+        name: "Auth Page Redirects",
+        path: "scripts/active/preflights/auth/authenticated-redirect.ts",
+        blocking: true,
+        description: "Ensure login/register pages redirect authenticated users away (UX best practice)",
+    },
+    {
+        name: "Store Access Delegation",
+        path: "scripts/active/preflights/auth/store-access-delegation.ts",
+        blocking: true,
+        description: "Ensure store access checks include delegated access (team membership), not just ownership. Catches getUserStore() usage and missing hasStoreAccess checks.",
+    },
+    {
+        name: "Session Provider Wrapper",
+        path: "scripts/active/preflights/auth/session-provider-wrapper.ts",
+        blocking: true,
+        description: "Ensure useSession() is in SessionProvider tree, detect deprecated getSession(), conditional providers, missing 'use client'",
+    },
+    // Database integrity
+    {
+        name: "Transaction Integrity",
+        path: "scripts/active/preflights/database/transaction-integrity.ts",
+        blocking: true,
+        description: "Ensure multi-table operations use transactions",
+    },
+    {
+        name: "Migration Reversibility",
+        path: "scripts/active/preflights/database/migration-reversibility.ts",
+        blocking: true,
+        description: "Ensure DB migrations have reversible down scripts",
+    },
+    {
+        name: "Migration Integrity",
+        path: "scripts/active/preflights/database/migration-integrity.ts",
+        blocking: true,
+        description: "Validate migration files exist, aren't modified after apply, no orphaned records",
+    },
+    {
+        name: "Prisma Upsert Safety",
+        path: "scripts/active/preflights/database/prisma-upsert-safety.ts",
+        blocking: true,
+        description: "Detect unsafe upsert patterns that cause duplicate records (fallback IDs, temp_ prefixes)",
+    },
+    {
+        name: "Soft Delete Consistency",
+        path: "scripts/active/preflights/database/soft-delete-consistency.ts",
+        blocking: false,
+        description: "Ensure queries filter soft-deleted records",
+    },
+    // Business logic validation
+    {
+        name: "Idempotency Keys",
+        path: "scripts/active/preflights/business/idempotency-key-validation.ts",
+        blocking: true,
+        description: "Ensure critical operations have idempotency protection",
+    },
+    {
+        name: "Timezone Handling",
+        path: "scripts/active/preflights/business/timezone-handling.ts",
+        blocking: false,
+        description: "Detect timezone handling issues",
+    },
+    // API validation
+    {
+        name: "Pagination Validation",
+        path: "scripts/active/preflights/api/pagination-validation.ts --warning",
+        blocking: false,
+        description: "Validate pagination parameter handling",
+    },
+    {
+        name: "API Response Consistency",
+        path: "scripts/active/preflights/api/response-consistency.ts",
+        blocking: true,
+        description: "Ensure consistent API response patterns",
+    },
+    {
+        name: "API Response Schema",
+        path: "scripts/active/preflights/api/response-schema-validation.ts",
+        blocking: true,
+        description: "Validate API responses have consistent schema (no raw primitives/arrays)",
+    },
+    {
+        name: "Variant Switching Integrity",
+        path: "scripts/active/preflights/api/variant-switching-integrity.ts",
+        blocking: true,
+        description: "Ensure variant switching feature maintains required components (API variants, types, card props)",
+    },
+    // React validation
+    {
+        name: "Memory Leak Detection",
+        path: "scripts/active/preflights/react/memory-leak-detection.ts",
+        blocking: true,
+        description: "Detect memory leaks in React components",
+    },
+    {
+        name: "Memory Leak Patterns",
+        path: "scripts/active/preflights/react/memory-leak-patterns.ts",
+        blocking: true,
+        description: "Comprehensive memory leak detection: closures, subscriptions, timers",
+    },
+    {
+        name: "Error Boundary Coverage",
+        path: "scripts/active/preflights/react/error-boundary-coverage.ts",
+        blocking: false,
+        description: "Ensure all routes/pages have error boundaries",
+    },
+    // AI recognition validation
+    {
+        name: "Series/Subset Hierarchy",
+        path: "scripts/active/preflights/ai/series-subset-hierarchy.ts",
+        blocking: true,
+        description: "Ensure AI correctly distinguishes series (product line) from subset (insert sets)",
+    },
+    // Drift prevention checks (NEW - prevent architectural drift)
+    {
+        name: "State Management Patterns",
+        path: "scripts/active/preflights/drift-prevention/state-management-patterns.ts",
+        blocking: true,
+        description: "Prevent React state management drift: memory leaks, stale closures, mutations",
+    },
+    {
+        name: "API Contract Consistency",
+        path: "scripts/active/preflights/drift-prevention/api-contract-consistency.ts",
+        blocking: true,
+        description: "Prevent API route drift: missing auth, error handling, validation patterns",
+    },
+    {
+        name: "Component Prop Consistency",
+        path: "scripts/active/preflights/drift-prevention/component-prop-consistency.ts",
+        blocking: false,
+        description: "Prevent component API drift: prop naming, types, required props",
+    },
+    {
+        name: "Database Query Patterns",
+        path: "scripts/active/preflights/drift-prevention/database-query-patterns.ts",
+        blocking: true,
+        description: "Prevent database drift: N+1 queries, missing transactions, SQL injection",
+    },
+    {
+        name: "Design System Consistency",
+        path: "scripts/active/preflights/drift-prevention/design-system-consistency.ts",
+        blocking: false,
+        description: "Prevent design drift: hardcoded values, inconsistent variants, accessibility",
+    },
+    {
+        name: "Size Convention Consistency",
+        path: "scripts/active/preflights/drift-prevention/size-convention-consistency.ts",
+        blocking: true,
+        description: "Enforce consistent size prop conventions: xs/sm/md vs small/medium/large",
+    },
+    {
+        name: "Performance Regression Detection",
+        path: "scripts/active/preflights/drift-prevention/performance-regression-detection.ts",
+        blocking: false,
+        description: "Prevent performance drift: bundle size, memory leaks, blocking operations",
+    },
+    {
+        name: "Breaking Change Detection",
+        path: "scripts/active/preflights/drift-prevention/breaking-change-detection.ts",
+        blocking: true,
+        description: "Detect breaking changes in exports, props, schemas before release",
+    },
+    // File organization validation
+    {
+        name: "File Organization",
+        path: "scripts/active/preflights/organization/file-organization-validation.ts",
+        blocking: true,
+        description: "E2E test structure, markdown files, docs organization",
+    },
+    {
+        name: "Preflight TypeScript",
+        path: "scripts/active/preflights/organization/preflight-typescript-validation.ts",
+        blocking: false,
+        description: "Type-check preflight implementation (warning-only until clean)",
+    },
+    {
+        name: "Preflight System",
+        path: "scripts/active/preflights/organization/preflight-system-validation.ts",
+        blocking: true,
+        description: "Validate preflight workflow references + prevent duplicate runs",
+    },
+    {
+        name: "Preflight Progress Consistency",
+        path: "scripts/active/preflights/organization/preflight-progress-consistency.ts",
+        blocking: true,
+        description: "Ensure all workflows use consistent real-time progress indicators",
+    },
+    {
+        name: "Agent Steering",
+        path: "scripts/active/preflights/organization/agent-steering-validation.ts",
+        blocking: true,
+        description: "Validate agent steering naming + stale references (Kiro + GitHub Copilot)",
+    },
+    {
+        name: "Route Structure",
+        path: "scripts/active/preflights/organization/route-structure-validation.ts",
+        blocking: true,
+        description: "Route aliases are re-exports, no duplicate implementations",
+    },
+    {
+        name: "File Cleanup",
+        path: "scripts/active/preflights/organization/file-cleanup-validation.ts",
+        blocking: true,
+        description: "Temporary files, old backups, empty directories, build artifacts",
+    },
+    {
+        name: "Steering Bloat Prevention",
+        path: "scripts/active/preflights/organization/steering-bloat-prevention.ts",
+        blocking: true,
+        description: "Prevent token-heavy patterns in steering files (ASCII art, verbose code, wrong inclusion)",
+    },
+    {
+        name: "NPM Script Bloat Prevention",
+        path: "scripts/active/preflights/organization/npm-script-bloat-prevention.ts",
+        blocking: true,
+        description: "Prevent package.json script bloat (max 200 scripts, consolidation opportunities)",
+    },
+    {
+        name: "API Route Naming",
+        path: "scripts/active/preflights/organization/api-route-naming-validation.ts",
+        blocking: true,
+        description: "Enforce actor namespace + pluralization (forbid /api/seller*, require /api/store; scans code + docs)",
+    },
+    {
+        name: "Store vs Seller Route Naming",
+        path: "scripts/active/preflights/governance/store-seller-route-names.ts",
+        blocking: true,
+        description: "Prevent drift: /store/* is canonical workspace; block introducing new /seller/* routes/links",
+    },
+    {
+        name: "CODEOWNERS Coverage",
+        path: "scripts/active/preflights/governance/codeowners-coverage.ts",
+        blocking: true,
+        description: "Ensure all critical files have designated code owners",
+    },
+    // Data integrity validation
+    {
+        name: "Cart Data Integrity",
+        path: "scripts/active/preflights/data-integrity/cart-data-integrity.ts",
+        blocking: true,
+        description: "Validate cart state management, price calculations, and data flow patterns",
+    },
+    {
+        name: "Notification Template Alignment",
+        path: "scripts/active/preflights/data-integrity/notification-template-alignment.ts",
+        blocking: false,
+        description: "Validate seller/buyer notification preferences align with email templates",
+    },
+    // Framework compatibility (future-proofing)
+    {
+        name: "Node 25 Compatibility (warn)",
+        path: "scripts/active/preflights/runtime/node25-compatibility.ts --mode=warn",
+        blocking: false,
+        description: "Warn: dependencies with engines.node ranges that appear to exclude Node 25",
+    },
+    {
+        name: "Next.js 16+ Compatibility",
+        path: "scripts/active/preflights/nextjs/nextjs16-compatibility.ts",
+        blocking: true,
+        description: "Async request APIs, deprecated patterns, React Compiler readiness",
+    },
+    {
+        name: "Static Generation Conflicts",
+        path: "scripts/active/preflights/nextjs/static-generation-check.ts",
+        blocking: true,
+        description: "Detect pages using generateStaticParams with headers()/cookies() - causes Vercel build failures",
+    },
+    {
+        name: "Prisma 7+ Compatibility",
+        path: "scripts/active/preflights/prisma/prisma7-compatibility.ts",
+        blocking: true,
+        description: "Null syntax, driver adapters, raw query safety, transaction patterns",
+    },
+    {
+        name: "React 19+ Compatibility",
+        path: "scripts/active/preflights/react/react19-compatibility.ts",
+        blocking: true,
+        description: "forwardRef deprecation, useActionState, Context.Provider, propTypes",
+    },
+    {
+        name: "Zod 4+ Compatibility",
+        path: "scripts/active/preflights/zod/zod4-compatibility.ts",
+        blocking: true,
+        description: "Error customization, errorMap→error, format/flatten deprecated",
+    },
+    {
+        name: "TanStack Query v5+ Compatibility",
+        path: "scripts/active/preflights/tanstack/tanstack-query-compatibility.ts",
+        blocking: true,
+        description: "Single object params, isPending, gcTime, removed callbacks",
+    },
+    {
+        name: "Tailwind CSS v4+ Compatibility",
+        path: "scripts/active/preflights/tailwind/tailwind4-compatibility.ts",
+        blocking: true,
+        description: "CSS-first config, @import, @theme directive, ESM only",
+    },
+    {
+        name: "Node Deprecations (warn)",
+        path: "scripts/active/preflights/runtime/node-deprecations.ts",
+        blocking: false,
+        description: "Warn: detect known Node deprecation sources (e.g., Next.js url.parse DEP0169)",
+    },
+    // Quality & i18n validation
+    {
+        name: "i18n Hardcoded Strings",
+        path: "scripts/active/preflights/quality/i18n-hardcoded-strings.ts",
+        blocking: false,
+        description: "Detect hardcoded user-facing strings that should be internationalized",
+    },
+    {
+        name: "Docs-Code Sync",
+        path: "scripts/active/preflights/quality/docs-code-sync.ts",
+        blocking: false,
+        description: "Validate API documentation matches implementation",
+    },
+    // Testing validation
+    {
+        name: "Test Flakiness Score",
+        path: "scripts/active/preflights/testing/test-flakiness-score.ts",
+        blocking: false,
+        description: "Track and quarantine consistently flaky tests",
+    },
+    // Deployment validation
+    {
+        name: "Rollback Compatibility",
+        path: "scripts/active/preflights/deployment/rollback-compatibility.ts",
+        blocking: false,
+        description: "Ensure code can gracefully degrade on rollback",
+    },
+    // Performance budgets
+    {
+        name: "Mobile Performance Budget",
+        path: "scripts/active/preflights/performance/mobile-performance-budget.ts",
+        blocking: false,
+        description: "Separate performance budgets for mobile/slow networks",
+    },
+    // Platform Integrations
+    {
+        name: "Platform Feed Integrity",
+        path: "scripts/active/preflights/integrations/platform-feed-integrity.ts",
+        blocking: true,
+        description: "Validate Amazon/eBay/TCGPlayer feed services, DB schema, email templates, UI components",
+    },
+];
+// SEO checks (standalone scripts, run separately)
+const SEO_CHECKS = [
+    {
+        name: "Hardcoded URLs",
+        cmd: "node scripts/active/preflights/seo/hardcoded-urls.js",
+        blocking: true,
+    },
+    {
+        name: "Category FAQ Schema",
+        cmd: "node scripts/active/preflights/seo/category-faq-schema-validation.js",
+        blocking: true,
+    },
+    {
+        name: "Missing Metadata",
+        cmd: "tsx scripts/active/preflights/seo/missing-metadata.ts",
+        blocking: false,
+    },
+];
+// MAIN EXECUTION
+async function main() {
+    const reporter = (0, universal_progress_reporter_1.createUniversalProgressReporter)(path.basename(__filename, ".ts"));
+    const runnerOpts = parseRunnerOptions();
+    let stopScheduling = false;
+    // Preflights are executed via Node/tsx and do NOT automatically load Next.js .env files.
+    // Load local dotenv early so PREFLIGHT_* environment variables can be set in .env.local.
+    // This is a no-op if the files don't exist.
+    process.env.DOTENV_CONFIG_QUIET ??= "true";
+    (0, dotenv_1.config)({ path: ".env" });
+    (0, dotenv_1.config)({ path: ".env.local" });
+    console.log(`${console_chars_1.emoji.search} Running ALL Preflights (Consolidated Modules Only)`);
+    console.log((0, console_chars_1.createDivider)(70, "heavy"));
+    console.log("");
+    console.log(`${console_chars_1.emoji.package} Using consolidated modules from scripts/active/preflights/consolidated/`);
+    console.log("   No standalone checks - all validation through consolidated modules");
+    console.log("");
+    const filter = parseFilterRegex();
+    if (filter) {
+        console.log(`${console_chars_1.emoji.magnifier} Filter enabled: ${filter.raw}`);
+        console.log("");
+    }
+    let failed = 0;
+    let passed = 0;
+    let skipped = 0;
+    let warnings = 0;
+    const startTime = Date.now();
+    const records = [];
+    const blockingModules = [];
+    const nonBlockingModules = [];
+    CONSOLIDATED_MODULES.forEach((mod) => {
+        if (mod.blocking) {
+            blockingModules.push(mod);
+        }
+        else {
+            nonBlockingModules.push(mod);
+        }
+    });
+    if (filter) {
+        const matchesModule = (m) => filter.regex.test(m.name) || filter.regex.test(m.path);
+        blockingModules.splice(0, blockingModules.length, ...blockingModules.filter(matchesModule));
+        nonBlockingModules.splice(0, nonBlockingModules.length, ...nonBlockingModules.filter(matchesModule));
+    }
+    // Run blocking modules first
+    console.log((0, console_chars_1.createDivider)(70, "double"));
+    console.log(`${console_chars_1.emoji.stop} BLOCKING CHECKS (must pass for build)`);
+    console.log((0, console_chars_1.createDivider)(70, "double"));
+    const blockingConcurrency = parseConcurrency("PREFLIGHT_BLOCKING_CONCURRENCY", parseConcurrency("PREFLIGHT_CONCURRENCY", defaultConcurrency()));
+    console.log(`Blocking concurrency: ${blockingConcurrency} (set PREFLIGHT_BLOCKING_CONCURRENCY to override)`);
+    // Track in-progress checks for real-time status updates
+    const inProgressBlocking = new Set();
+    let completedBlocking = 0;
+    const updateBlockingProgress = () => {
+        const running = Array.from(inProgressBlocking);
+        if (running.length > 0) {
+            const progress = `[${completedBlocking}/${blockingModules.length}]`;
+            const runningList = running.length <= 3
+                ? running.join(", ")
+                : `${running.slice(0, 3).join(", ")} +${running.length - 3} more`;
+            process.stdout.write(`\r${console_chars_1.emoji.hourglass} ${progress} Running: ${runningList}`.padEnd(100) + "\r");
+        }
+    };
+    const blockingResults = await mapWithConcurrency(blockingModules, blockingConcurrency, async (mod) => {
+        if (runnerOpts.failFast && stopScheduling) {
+            completedBlocking++;
+            return { kind: "skipped" };
+        }
+        const moduleFile = mod.path.split(" ")[0];
+        if (!fs.existsSync(moduleFile)) {
+            completedBlocking++;
+            return { kind: "skipped" };
+        }
+        // Show this check as in-progress
+        inProgressBlocking.add(mod.name);
+        updateBlockingProgress();
+        const res = await runShellCommand(`tsx ${mod.path}`, {
+            maxStdoutLines: 30,
+            maxStderrLines: 10,
+            timeoutMs: runnerOpts.timeoutMs,
+            findingsPath: createFindingsPath(`blocking-${mod.name}`),
+        });
+        // Remove from in-progress and update counter
+        inProgressBlocking.delete(mod.name);
+        completedBlocking++;
+        updateBlockingProgress();
+        if (runnerOpts.failFast && (res.timedOut || res.exitCode !== 0)) {
+            stopScheduling = true;
+        }
+        return {
+            kind: res.exitCode === 0 ? "passed" : "failed",
+            durationSec: res.durationSec,
+            stdoutLines: res.stdoutLines,
+            stdoutTotal: res.stdoutTotal,
+            stderrLines: res.stderrLines,
+            stderrTotal: res.stderrTotal,
+            exitCode: res.exitCode,
+            timedOut: res.timedOut,
+            findings: res.findings,
+        };
+    });
+    // Clear the progress line before printing results
+    process.stdout.write("\r" + " ".repeat(100) + "\r");
+    for (let i = 0; i < blockingModules.length; i += 1) {
+        const mod = blockingModules[i];
+        const result = blockingResults[i];
+        if (result.kind === "skipped") {
+            console.log(`${console_chars_1.emoji.skip}  ${mod.name.padEnd(20)} (skipped - file not found)`);
+            skipped++;
+            records.push({
+                name: mod.name,
+                group: "blocking",
+                blocking: true,
+                pathOrCmd: mod.path,
+                kind: "skipped",
+                durationSec: 0,
+                exitCode: 0,
+            });
+            continue;
+        }
+        if (result.kind === "passed") {
+            console.log(`${console_chars_1.emoji.success} ${mod.name.padEnd(20)} ${result.durationSec}s`);
+            passed++;
+            records.push({
+                name: mod.name,
+                group: "blocking",
+                blocking: true,
+                pathOrCmd: mod.path,
+                kind: "passed",
+                durationSec: toNumberDurationSec(result.durationSec),
+                stdoutTotal: result.stdoutTotal,
+                stderrTotal: result.stderrTotal,
+                exitCode: 0,
+            });
+            continue;
+        }
+        console.log(`${console_chars_1.emoji.error} ${mod.name.padEnd(20)} FAILED`);
+        result.stdoutLines.forEach((line) => console.log(`   ${line}`));
+        if (result.stdoutTotal > result.stdoutLines.length) {
+            console.log(`   ... +${result.stdoutTotal - result.stdoutLines.length} more lines`);
+        }
+        result.stderrLines.forEach((line) => console.log(`   ${line}`));
+        if (result.stderrTotal > result.stderrLines.length) {
+            console.log(`   ... +${result.stderrTotal - result.stderrLines.length} more lines`);
+        }
+        failed++;
+        records.push({
+            name: mod.name,
+            group: "blocking",
+            blocking: true,
+            pathOrCmd: mod.path,
+            kind: "failed",
+            durationSec: toNumberDurationSec(result.durationSec),
+            stdoutTotal: result.stdoutTotal,
+            stderrTotal: result.stderrTotal,
+            timedOut: result.timedOut,
+            exitCode: result.exitCode,
+            outputSnippet: makeOutputSnippet({
+                stdoutLines: result.stdoutLines,
+                stdoutTotal: result.stdoutTotal,
+                stderrLines: result.stderrLines,
+                stderrTotal: result.stderrTotal,
+            }),
+            findings: result.findings,
+        });
+    }
+    // Run SEO checks (blocking)
+    console.log("\n" + (0, console_chars_1.createDivider)(70, "double"));
+    console.log(`${console_chars_1.emoji.stop} SEO CHECKS (blocking)`);
+    console.log((0, console_chars_1.createDivider)(70, "double"));
+    const seoChecks = filter
+        ? SEO_CHECKS.filter((c) => filter.regex.test(c.name) || filter.regex.test(c.cmd))
+        : SEO_CHECKS;
+    const seoConcurrency = parseConcurrency("PREFLIGHT_SEO_CONCURRENCY", Math.min(seoChecks.length, parseConcurrency("PREFLIGHT_CONCURRENCY", defaultConcurrency())));
+    console.log(`SEO concurrency: ${seoConcurrency} (set PREFLIGHT_SEO_CONCURRENCY to override)`);
+    // Track in-progress SEO checks for real-time status updates
+    const inProgressSeo = new Set();
+    let completedSeo = 0;
+    const updateSeoProgress = () => {
+        const running = Array.from(inProgressSeo);
+        if (running.length > 0) {
+            const progress = `[${completedSeo}/${seoChecks.length}]`;
+            const runningList = running.join(", ");
+            process.stdout.write(`\r${console_chars_1.emoji.hourglass} ${progress} Running: ${runningList}`.padEnd(100) + "\r");
+        }
+    };
+    const seoResults = await mapWithConcurrency(seoChecks, seoConcurrency, async (check) => {
+        if (runnerOpts.failFast && stopScheduling) {
+            return { kind: "skipped", durationSec: "0.0", exitCode: 0, timedOut: false };
+        }
+        // Show this check as in-progress
+        inProgressSeo.add(check.name);
+        updateSeoProgress();
+        const res = await runShellCommand(check.cmd, {
+            maxStdoutLines: 20,
+            maxStderrLines: 10,
+            timeoutMs: runnerOpts.timeoutMs,
+            findingsPath: createFindingsPath(`seo-${check.name}`),
+        });
+        // Remove from in-progress and update counter
+        inProgressSeo.delete(check.name);
+        completedSeo++;
+        updateSeoProgress();
+        if (runnerOpts.failFast && check.blocking && (res.timedOut || res.exitCode !== 0)) {
+            stopScheduling = true;
+        }
+        if (res.exitCode === 0) {
+            return { kind: "passed", durationSec: res.durationSec, exitCode: 0, timedOut: false };
+        }
+        return {
+            kind: check.blocking ? "failed" : "warning",
+            durationSec: res.durationSec,
+            stdoutLines: res.stdoutLines,
+            stdoutTotal: res.stdoutTotal,
+            stderrLines: res.stderrLines,
+            stderrTotal: res.stderrTotal,
+            exitCode: res.exitCode,
+            timedOut: res.timedOut,
+            findings: res.findings,
+        };
+    });
+    // Clear the progress line before printing results
+    process.stdout.write("\r" + " ".repeat(100) + "\r");
+    for (let i = 0; i < seoChecks.length; i += 1) {
+        const check = seoChecks[i];
+        const result = seoResults[i];
+        if (result.kind === "skipped") {
+            console.log(`${console_chars_1.emoji.skip}  ${check.name.padEnd(20)} (skipped - fail-fast)`);
+            skipped++;
+            records.push({
+                name: check.name,
+                group: "seo",
+                blocking: check.blocking,
+                pathOrCmd: check.cmd,
+                kind: "skipped",
+                durationSec: 0,
+                exitCode: 0,
+            });
+            continue;
+        }
+        if (result.kind === "passed") {
+            console.log(`${console_chars_1.emoji.success} ${check.name.padEnd(20)} ${result.durationSec}s`);
+            passed++;
+            records.push({
+                name: check.name,
+                group: "seo",
+                blocking: check.blocking,
+                pathOrCmd: check.cmd,
+                kind: "passed",
+                durationSec: toNumberDurationSec(result.durationSec),
+                exitCode: result.exitCode,
+                timedOut: result.timedOut,
+            });
+            continue;
+        }
+        if (result.kind === "warning") {
+            console.log(`${console_chars_1.emoji.warning}  ${check.name.padEnd(20)} (warnings)`);
+            warnings++;
+            records.push({
+                name: check.name,
+                group: "seo",
+                blocking: check.blocking,
+                pathOrCmd: check.cmd,
+                kind: "warning",
+                durationSec: toNumberDurationSec(result.durationSec),
+                stdoutTotal: result.stdoutTotal,
+                stderrTotal: result.stderrTotal,
+                exitCode: result.exitCode,
+                timedOut: result.timedOut,
+                outputSnippet: makeOutputSnippet({
+                    stdoutLines: result.stdoutLines,
+                    stdoutTotal: result.stdoutTotal,
+                    stderrLines: result.stderrLines,
+                    stderrTotal: result.stderrTotal,
+                }),
+                findings: result.findings,
+            });
+            continue;
+        }
+        console.log(`${console_chars_1.emoji.error} ${check.name.padEnd(20)} FAILED`);
+        result.stdoutLines.forEach((line) => console.log(`   ${line}`));
+        if (result.stdoutTotal > result.stdoutLines.length) {
+            console.log(`   ... +${result.stdoutTotal - result.stdoutLines.length} more lines`);
+        }
+        result.stderrLines.forEach((line) => console.log(`   ${line}`));
+        if (result.stderrTotal > result.stderrLines.length) {
+            console.log(`   ... +${result.stderrTotal - result.stderrLines.length} more lines`);
+        }
+        failed++;
+        records.push({
+            name: check.name,
+            group: "seo",
+            blocking: check.blocking,
+            pathOrCmd: check.cmd,
+            kind: "failed",
+            durationSec: toNumberDurationSec(result.durationSec),
+            stdoutTotal: result.stdoutTotal,
+            stderrTotal: result.stderrTotal,
+            exitCode: result.exitCode,
+            timedOut: result.timedOut,
+            outputSnippet: makeOutputSnippet({
+                stdoutLines: result.stdoutLines,
+                stdoutTotal: result.stdoutTotal,
+                stderrLines: result.stderrLines,
+                stderrTotal: result.stderrTotal,
+            }),
+            findings: result.findings,
+        });
+    }
+    // Run non-blocking modules
+    console.log("\n" + (0, console_chars_1.createDivider)(70, "double"));
+    console.log(`${console_chars_1.emoji.warning} NON-BLOCKING CHECKS (warnings only)`);
+    console.log((0, console_chars_1.createDivider)(70, "double"));
+    function toLineInfo(lines, total, max) {
+        if (total <= max)
+            return { lines };
+        return { lines, suffix: `... +${total - max} more lines` };
+    }
+    const nonBlockingConcurrency = parseConcurrency("PREFLIGHT_CONCURRENCY", defaultConcurrency());
+    console.log(`Concurrency: ${nonBlockingConcurrency} (set PREFLIGHT_CONCURRENCY to override)`);
+    // Track in-progress checks for real-time status updates
+    const inProgressChecks = new Set();
+    let completedNonBlocking = 0;
+    const updateProgressStatus = () => {
+        const running = Array.from(inProgressChecks);
+        if (running.length > 0) {
+            const progress = `[${completedNonBlocking}/${nonBlockingModules.length}]`;
+            const runningList = running.length <= 3
+                ? running.join(", ")
+                : `${running.slice(0, 3).join(", ")} +${running.length - 3} more`;
+            process.stdout.write(`\r${console_chars_1.emoji.hourglass} ${progress} Running: ${runningList}`.padEnd(100) + "\r");
+        }
+    };
+    const nonBlockingResults = await mapWithConcurrency(nonBlockingModules, nonBlockingConcurrency, async (mod) => {
+        if (runnerOpts.failFast && stopScheduling) {
+            completedNonBlocking++;
+            return { kind: "skipped", durationSec: "0.0", exitCode: 0, timedOut: false };
+        }
+        const moduleFile = mod.path.split(" ")[0];
+        if (!fs.existsSync(moduleFile)) {
+            completedNonBlocking++;
+            return { kind: "skipped", durationSec: "0.0", exitCode: 0, timedOut: false };
+        }
+        // Show this check as in-progress
+        inProgressChecks.add(mod.name);
+        updateProgressStatus();
+        const res = await runShellCommand(`tsx ${mod.path}`, {
+            maxStdoutLines: 20,
+            maxStderrLines: 10,
+            timeoutMs: runnerOpts.timeoutMs,
+            findingsPath: createFindingsPath(`non-blocking-${mod.name}`),
+        });
+        // Remove from in-progress and update counter
+        inProgressChecks.delete(mod.name);
+        completedNonBlocking++;
+        updateProgressStatus();
+        const kind = res.exitCode === 0 ? "passed" : "warning";
+        return {
+            kind,
+            durationSec: res.durationSec,
+            stdoutLines: res.stdoutLines,
+            stdoutTotal: res.stdoutTotal,
+            stderrLines: res.stderrLines,
+            stderrTotal: res.stderrTotal,
+            exitCode: res.exitCode,
+            timedOut: res.timedOut,
+            findings: res.findings,
+        };
+    });
+    // Clear the progress line before printing results
+    process.stdout.write("\r" + " ".repeat(100) + "\r");
+    for (let i = 0; i < nonBlockingModules.length; i += 1) {
+        const mod = nonBlockingModules[i];
+        const result = nonBlockingResults[i];
+        if (result.kind === "skipped") {
+            console.log(`${console_chars_1.emoji.skip}  ${mod.name.padEnd(20)} (skipped - file not found)`);
+            skipped++;
+            records.push({
+                name: mod.name,
+                group: "non-blocking",
+                blocking: false,
+                pathOrCmd: mod.path,
+                kind: "skipped",
+                durationSec: 0,
+                exitCode: 0,
+            });
+            continue;
+        }
+        if (result.kind === "passed") {
+            console.log(`${console_chars_1.emoji.success} ${mod.name.padEnd(20)} ${result.durationSec}s`);
+            passed++;
+            records.push({
+                name: mod.name,
+                group: "non-blocking",
+                blocking: false,
+                pathOrCmd: mod.path,
+                kind: "passed",
+                durationSec: toNumberDurationSec(result.durationSec),
+                stdoutTotal: result.stdoutTotal,
+                stderrTotal: result.stderrTotal,
+                exitCode: 0,
+            });
+            continue;
+        }
+        console.log(`${console_chars_1.emoji.warning}  ${mod.name.padEnd(20)} (warnings)`);
+        warnings++;
+        records.push({
+            name: mod.name,
+            group: "non-blocking",
+            blocking: false,
+            pathOrCmd: mod.path,
+            kind: "warning",
+            durationSec: toNumberDurationSec(result.durationSec),
+            stdoutTotal: result.stdoutTotal,
+            stderrTotal: result.stderrTotal,
+            exitCode: result.exitCode,
+            timedOut: result.timedOut,
+            outputSnippet: makeOutputSnippet({
+                stdoutLines: result.stdoutLines,
+                stdoutTotal: result.stdoutTotal,
+                stderrLines: result.stderrLines,
+                stderrTotal: result.stderrTotal,
+            }),
+            findings: result.findings,
+        });
+        const outInfo = toLineInfo(result.stdoutLines, result.stdoutTotal, 20);
+        outInfo.lines.forEach((line) => console.log(`   ${line}`));
+        if (outInfo.suffix)
+            console.log(`   ${outInfo.suffix}`);
+        const errInfo = toLineInfo(result.stderrLines, result.stderrTotal, 10);
+        errInfo.lines.forEach((line) => console.log(`   ${line}`));
+        if (errInfo.suffix)
+            console.log(`   ${errInfo.suffix}`);
+    }
+    // Summary
+    const totalDuration = ((Date.now() - startTime) / 1000).toFixed(1);
+    const total = CONSOLIDATED_MODULES.length + SEO_CHECKS.length;
+    console.log("\n" + (0, console_chars_1.createDivider)(70, "double"));
+    console.log(`${console_chars_1.emoji.chart} PREFLIGHT RESULTS (Consolidated Modules + SEO)`);
+    console.log((0, console_chars_1.createDivider)(70, "double"));
+    console.log(`   ${console_chars_1.emoji.success} Passed:   ${passed}/${total - skipped} modules`);
+    console.log(`   ${console_chars_1.emoji.error} Failed:   ${failed} (blocking)`);
+    console.log(`   ${console_chars_1.emoji.warning}  Warnings: ${warnings} (non-blocking)`);
+    console.log(`   ${console_chars_1.emoji.skip}  Skipped:  ${skipped} (not found)`);
+    console.log(`   ${console_chars_1.emoji.clock}  Time:     ${totalDuration}s`);
+    console.log((0, console_chars_1.createDivider)(70, "double"));
+    // MACHINE-READABLE REPORT + PERFORMANCE BASELINE (non-blocking)
+    const reportDir = "reports/preflight";
+    const reportPath = `${reportDir}/preflight-results.json`;
+    const lastRunPath = `${reportDir}/last-run.json`;
+    const baselinePath = `${reportDir}/baseline.json`;
+    const report = {
+        version: 1,
+        createdAtIso: new Date().toISOString(),
+        node: process.version,
+        platform: process.platform,
+        arch: process.arch,
+        concurrency: {
+            blocking: blockingConcurrency,
+            nonBlocking: nonBlockingConcurrency,
+            seo: seoConcurrency,
+        },
+        totals: { passed, failed, warnings, skipped },
+        timedOut: records.some((r) => r.timedOut || r.exitCode === 124),
+        records,
+    };
+    if (runnerOpts.junitPath) {
+        try {
+            const xml = toJUnitXml(report, Number(totalDuration));
+            writeText(runnerOpts.junitPath, xml);
+            console.log(`\n${console_chars_1.emoji.testTube} Wrote JUnit report: ${runnerOpts.junitPath}`);
+        }
+        catch {
+            console.log(`\n${console_chars_1.emoji.warning}  Could not write JUnit report: ${runnerOpts.junitPath}`);
+        }
+    }
+    if (runnerOpts.sarifPath) {
+        try {
+            const sarif = toSarif(report);
+            writeText(runnerOpts.sarifPath, JSON.stringify(sarif, null, process.env.CI ? 0 : 2) + "\n");
+            console.log(`${console_chars_1.emoji.memo} Wrote SARIF report: ${runnerOpts.sarifPath}`);
+        }
+        catch {
+            console.log(`${console_chars_1.emoji.warning}  Could not write SARIF report: ${runnerOpts.sarifPath}`);
+        }
+    }
+    if (records.some((r) => r.exitCode === 124 || r.timedOut)) {
+        console.log(`\n${console_chars_1.emoji.hourglass} BUILD TIMED OUT - One or more steps exceeded timeout`);
+        process.exit(124);
+    }
+    try {
+        writeJson(reportPath, report);
+        writeJson(lastRunPath, report);
+        console.log(`\n${console_chars_1.emoji.memo} Wrote report: ${reportPath}`);
+    }
+    catch {
+        console.log(`\n${console_chars_1.emoji.warning}  Could not write report: ${reportPath}`);
+    }
+    const baselineWarnPct = Number(process.env.PREFLIGHT_BASELINE_WARN_PCT ?? "50");
+    const baselineWarnAbsSec = Number(process.env.PREFLIGHT_BASELINE_WARN_ABS_SEC ?? "2");
+    const baseline = readJsonIfExists(baselinePath);
+    if (process.env.PREFLIGHT_BASELINE_UPDATE === "1") {
+        const durationsSecByKey = {};
+        for (const r of records) {
+            if (r.kind === "skipped")
+                continue;
+            durationsSecByKey[baselineKey(r)] = r.durationSec;
+        }
+        const nextBaseline = {
+            version: 1,
+            updatedAtIso: new Date().toISOString(),
+            node: process.version,
+            durationsSecByKey,
+        };
+        try {
+            writeJson(baselinePath, nextBaseline);
+            console.log(`${console_chars_1.emoji.memo} Updated baseline: ${baselinePath}`);
+        }
+        catch {
+            console.log(`${console_chars_1.emoji.warning}  Could not update baseline: ${baselinePath}`);
+        }
+    }
+    else if (baseline?.durationsSecByKey) {
+        const regressions = [];
+        for (const r of records) {
+            if (r.kind === "skipped")
+                continue;
+            const key = baselineKey(r);
+            const prev = baseline.durationsSecByKey[key];
+            if (typeof prev !== "number" || !Number.isFinite(prev) || prev <= 0)
+                continue;
+            const absDelta = r.durationSec - prev;
+            const pctDelta = (absDelta / prev) * 100;
+            if (absDelta >= baselineWarnAbsSec && pctDelta >= baselineWarnPct) {
+                regressions.push({ name: r.name, prev, now: r.durationSec });
+            }
+        }
+        if (regressions.length > 0) {
+            console.log(`\n${console_chars_1.emoji.clock}  PREFLIGHT PERFORMANCE REGRESSIONS (warning)`);
+            console.log(`   Threshold: +${baselineWarnAbsSec}s AND +${baselineWarnPct}%`);
+            regressions
+                .sort((a, b) => b.now - b.prev - (a.now - a.prev))
+                .slice(0, 12)
+                .forEach((r) => {
+                const delta = (r.now - r.prev).toFixed(1);
+                const pct = (((r.now - r.prev) / r.prev) * 100).toFixed(0);
+                console.log(` - ${r.name}: ${r.prev.toFixed(1)}s ${console_chars_1.chars.arrow} ${r.now.toFixed(1)}s (+${delta}s, +${pct}%)`);
+            });
+            if (regressions.length > 12)
+                console.log(`   ... +${regressions.length - 12} more`);
+            console.log(`   Baseline: ${baselinePath} (set PREFLIGHT_BASELINE_UPDATE=1 to update)`);
+        }
+    }
+    else {
+        console.log(`\n${console_chars_1.emoji.info}  No baseline found at ${baselinePath} (set PREFLIGHT_BASELINE_UPDATE=1 to create)`);
+    }
+    if (failed > 0) {
+        console.log(`\n${console_chars_1.emoji.error} BUILD BLOCKED - Fix blocking errors before proceeding`);
+        console.log("");
+        console.log("Consolidated modules with errors:");
+        console.log("   Run individual modules: pnpm tsx scripts/active/preflights/consolidated/<module>.ts");
+        console.log("");
+        process.exit(1);
+    }
+    if (warnings > 0) {
+        console.log(`\n${console_chars_1.emoji.warning}  BUILD PASSED (with warnings)`);
+    }
+    else {
+        console.log(`\n${console_chars_1.emoji.success} ALL PREFLIGHTS PASSED`);
+    }
+    console.log("");
+    console.log("Coverage (14 key checks via consolidated modules):");
+    console.log(`   ${console_chars_1.chars.check} Import Validation       ${console_chars_1.chars.arrow} imports.ts`);
+    console.log(`   ${console_chars_1.chars.check} Category Chips          ${console_chars_1.chars.arrow} ui-patterns.ts`);
+    console.log(`   ${console_chars_1.chars.check} Navigation Layout       ${console_chars_1.chars.arrow} ui-navigation.ts`);
+    console.log(`   ${console_chars_1.chars.check} Button Link Pattern     ${console_chars_1.chars.arrow} ui-components.ts`);
+    console.log(`   ${console_chars_1.chars.check} Image Optimization      ${console_chars_1.chars.arrow} performance.ts + images.ts`);
+    console.log(`   ${console_chars_1.chars.check} XSS Prevention          ${console_chars_1.chars.arrow} security.ts`);
+    console.log(`   ${console_chars_1.chars.check} Duplicate Logic         ${console_chars_1.chars.arrow} quality.ts (data fetching patterns)`);
+    console.log(`   ${console_chars_1.chars.check} TypeScript Type Safety  ${console_chars_1.chars.arrow} quality.ts (any cast detection)`);
+    console.log(`   ${console_chars_1.chars.check} N+1 Query Detection     ${console_chars_1.chars.arrow} performance.ts (database efficiency)`);
+    console.log(`   ${console_chars_1.chars.check} Homepage UX             ${console_chars_1.chars.arrow} homepage-ux.ts (search, pagination)`);
+    console.log(`   ${console_chars_1.chars.check} CSS Organization        ${console_chars_1.chars.arrow} css-organization.ts (modular CSS)`);
+    console.log(`   ${console_chars_1.chars.check} LCP Image Priority      ${console_chars_1.chars.arrow} performance.ts (above-fold images)`);
+    console.log(`   ${console_chars_1.chars.check} Styling Standards       ${console_chars_1.chars.arrow} styling-standards.ts (Tailwind + CVA)`);
+    console.log(`   ${console_chars_1.chars.check} Component Architecture  ${console_chars_1.chars.arrow} architecture/component-architecture.ts`);
+    console.log(`   ${console_chars_1.chars.check} Hardcoded URLs          ${console_chars_1.chars.arrow} seo/hardcoded-urls.js (SITE_URL usage)`);
+    console.log(`   ${console_chars_1.chars.check} Category FAQ Schema     ${console_chars_1.chars.arrow} seo/category-faq-schema-validation.js`);
+    console.log("");
+    process.exit(0);
+}
+main().catch((err) => {
+    console.error(err);
+    process.exit(1);
+});
+//# sourceMappingURL=all.js.map