@lumenflow/cli 2.2.1 → 2.3.1

package/dist/gates.js

@@ -1,4 +1,5 @@
 #!/usr/bin/env node
+/* eslint-disable no-console -- Gates runner uses console for status output; refactoring to logger is tracked for future work */
 /**
  * Quality Gates Runner
  *
@@ -32,11 +33,11 @@
  * - Standard WUs: changed tests + safety-critical tests
  *
  * Usage:
- *   node tools/gates.mjs                        # Tiered gates (default)
- *   node tools/gates.mjs --docs-only            # Docs-only gates
- *   node tools/gates.mjs --full-lint            # Full lint (bypass incremental)
- *   node tools/gates.mjs --full-tests           # Full tests (bypass incremental)
- *   node tools/gates.mjs --coverage-mode=block  # Coverage gate in block mode
+ *   node tools/gates.ts                        # Tiered gates (default)
+ *   node tools/gates.ts --docs-only            # Docs-only gates
+ *   node tools/gates.ts --full-lint            # Full lint (bypass incremental)
+ *   node tools/gates.ts --full-tests           # Full tests (bypass incremental)
+ *   node tools/gates.ts --coverage-mode=block  # Coverage gate in block mode
  */
 import { execSync, spawnSync } from 'node:child_process';
 import { closeSync, mkdirSync, openSync, readSync, statSync, writeSync } from 'node:fs';
@@ -44,18 +45,27 @@ import { access } from 'node:fs/promises';
 import path from 'node:path';
 import { emitGateEvent, getCurrentWU, getCurrentLane } from '@lumenflow/core/dist/telemetry.js';
 import { die } from '@lumenflow/core/dist/error-handler.js';
-import { getChangedLintableFiles, convertToPackageRelativePaths, } from '@lumenflow/core/dist/incremental-lint.js';
-import { isCodeFilePath } from '@lumenflow/core/dist/incremental-test.js';
+import { getChangedLintableFiles, isLintableFile } from '@lumenflow/core/dist/incremental-lint.js';
+import { buildVitestChangedArgs, isCodeFilePath } from '@lumenflow/core/dist/incremental-test.js';
 import { getGitForCwd } from '@lumenflow/core/dist/git-adapter.js';
 import { runCoverageGate, COVERAGE_GATE_MODES } from '@lumenflow/core/dist/coverage-gate.js';
 import { buildGatesLogPath, shouldUseGatesAgentMode, updateGatesLatestSymlink, } from '@lumenflow/core/dist/gates-agent-mode.js';
 // WU-2062: Import risk detector for tiered test execution
-// eslint-disable-next-line no-unused-vars -- Pre-existing: SAFETY_CRITICAL_TEST_PATTERNS imported for future use
-import { detectRiskTier, RISK_TIERS, } from '@lumenflow/core/dist/risk-detector.js';
+import { detectRiskTier, RISK_TIERS } from '@lumenflow/core/dist/risk-detector.js';
 // WU-2252: Import invariants runner for first-check validation
 import { runInvariants } from '@lumenflow/core/dist/invariants-runner.js';
 import { createWUParser } from '@lumenflow/core/dist/arg-parser.js';
-import { BRANCHES, PACKAGES, PKG_MANAGER, PKG_FLAGS, ESLINT_FLAGS, ESLINT_COMMANDS, ESLINT_DEFAULTS, SCRIPTS, CACHE_STRATEGIES, DIRECTORIES, GATE_NAMES, GATE_COMMANDS, TOOL_PATHS, CLI_MODES, EXIT_CODES, FILE_SYSTEM, PRETTIER_ARGS, PRETTIER_FLAGS, } from '@lumenflow/core/dist/wu-constants.js';
+import { validateBacklogSync } from '@lumenflow/core/dist/validators/backlog-sync.js';
+import { runSupabaseDocsLinter } from '@lumenflow/core/dist/validators/supabase-docs-linter.js';
+import { runSystemMapValidation } from '@lumenflow/core/dist/system-map-validator.js';
+// WU-1067: Config-driven gates support (partial implementation - unused imports removed)
+// WU-1191: Lane health gate configuration
+// WU-1262: Coverage config from methodology policy
+// WU-1280: Test policy for tests_required (warn vs block on test failures)
+import { loadLaneHealthConfig, resolveTestPolicy, } from '@lumenflow/core/dist/gates-config.js';
+// WU-1191: Lane health check
+import { runLaneHealthCheck } from './lane-health.js';
+import { BRANCHES, PACKAGES, PKG_MANAGER, ESLINT_FLAGS, ESLINT_COMMANDS, ESLINT_DEFAULTS, SCRIPTS, CACHE_STRATEGIES, DIRECTORIES, GATE_NAMES, GATE_COMMANDS, CLI_MODES, EXIT_CODES, FILE_SYSTEM, PRETTIER_ARGS, PRETTIER_FLAGS, } from '@lumenflow/core/dist/wu-constants.js';
 /**
  * WU-1087: Gates-specific option definitions for createWUParser.
  * Exported for testing and consistency with other CLI commands.
@@ -138,6 +148,7 @@ export function parseGatesOptions() {
  * @deprecated Use parseGatesOptions() instead (WU-1087)
  * Kept for backward compatibility during migration.
  */
+// eslint-disable-next-line @typescript-eslint/no-unused-vars -- Pre-existing: argv kept for backwards compatibility
 function parseGatesArgs(argv = process.argv) {
     return parseGatesOptions();
 }
@@ -154,6 +165,91 @@ function pnpmRun(script, ...args) {
     const argsStr = args.length > 0 ? ` ${args.join(' ')}` : '';
     return `${PKG_MANAGER} ${SCRIPTS.RUN} ${script}${argsStr}`;
 }
+const PRETTIER_CONFIG_FILES = new Set([
+    '.prettierrc',
+    '.prettierrc.json',
+    '.prettierrc.yaml',
+    '.prettierrc.yml',
+    '.prettierrc.js',
+    '.prettierrc.cjs',
+    '.prettierrc.ts',
+    'prettier.config.js',
+    'prettier.config.cjs',
+    'prettier.config.ts',
+    'prettier.config.mjs',
+    '.prettierignore',
+]);
+const TEST_CONFIG_BASENAMES = new Set(['turbo.json', 'pnpm-lock.yaml', 'package.json']);
+const TEST_CONFIG_PATTERNS = [/^vitest\.config\.(ts|mts|js|mjs|cjs)$/i, /^tsconfig(\..+)?\.json$/i];
+function normalizePath(filePath) {
+    return filePath.replace(/\\/g, '/');
+}
+function getBasename(filePath) {
+    const normalized = normalizePath(filePath);
+    const parts = normalized.split('/');
+    return parts[parts.length - 1] || normalized;
+}
+function quoteShellArgs(files) {
+    return files.map((file) => `"${file}"`).join(' ');
+}
+export function isPrettierConfigFile(filePath) {
+    if (!filePath)
+        return false;
+    const basename = getBasename(filePath);
+    return PRETTIER_CONFIG_FILES.has(basename);
+}
+export function isTestConfigFile(filePath) {
+    if (!filePath)
+        return false;
+    const basename = getBasename(filePath);
+    if (TEST_CONFIG_BASENAMES.has(basename)) {
+        return true;
+    }
+    return TEST_CONFIG_PATTERNS.some((pattern) => pattern.test(basename));
+}
+/* eslint-disable sonarjs/no-duplicate-string -- Pre-existing: format check reasons are intentionally distinct string literals */
+export function resolveFormatCheckPlan({ changedFiles, fileListError = false, }) {
+    if (fileListError) {
+        return { mode: 'full', files: [], reason: 'file-list-error' };
+    }
+    if (changedFiles.some(isPrettierConfigFile)) {
+        return { mode: 'full', files: [], reason: 'prettier-config' };
+    }
+    if (changedFiles.length === 0) {
+        return { mode: 'skip', files: [] };
+    }
+    return { mode: 'incremental', files: changedFiles };
+}
+export function resolveLintPlan({ isMainBranch, changedFiles, }) {
+    if (isMainBranch) {
+        return { mode: 'full', files: [] };
+    }
+    const lintTargets = changedFiles.filter((filePath) => {
+        const normalized = normalizePath(filePath);
+        return ((normalized.startsWith('apps/') || normalized.startsWith('packages/')) &&
+            isLintableFile(normalized));
+    });
+    if (lintTargets.length === 0) {
+        return { mode: 'skip', files: [] };
+    }
+    return { mode: 'incremental', files: lintTargets };
+}
+/* eslint-enable sonarjs/no-duplicate-string */
+export function resolveTestPlan({ isMainBranch, hasUntrackedCode, hasConfigChange, fileListError, }) {
+    if (fileListError) {
+        return { mode: 'full', reason: 'file-list-error' };
+    }
+    if (hasUntrackedCode) {
+        return { mode: 'full', reason: 'untracked-code' };
+    }
+    if (hasConfigChange) {
+        return { mode: 'full', reason: 'test-config' };
+    }
+    if (isMainBranch) {
+        return { mode: 'full' };
+    }
+    return { mode: 'incremental' };
+}
 export function parsePrettierListOutput(output) {
     if (!output)
         return [];
@@ -171,6 +267,10 @@ export function buildPrettierWriteCommand(files) {
     const base = pnpmCmd(SCRIPTS.PRETTIER, PRETTIER_FLAGS.WRITE);
     return quotedFiles ? `${base} ${quotedFiles}` : base;
 }
+function buildPrettierCheckCommand(files) {
+    const filesArg = files.length > 0 ? quoteShellArgs(files) : '.';
+    return pnpmCmd(SCRIPTS.PRETTIER, PRETTIER_ARGS.CHECK, filesArg);
+}
 export function formatFormatCheckGuidance(files) {
     if (!files.length)
         return [];
@@ -186,8 +286,10 @@ export function formatFormatCheckGuidance(files) {
         '',
     ];
 }
-function collectPrettierListDifferent(cwd) {
-    const cmd = pnpmCmd(SCRIPTS.PRETTIER, PRETTIER_ARGS.LIST_DIFFERENT, '.');
+function collectPrettierListDifferent(cwd, files = []) {
+    const filesArg = files.length > 0 ? quoteShellArgs(files) : '.';
+    const cmd = pnpmCmd(SCRIPTS.PRETTIER, PRETTIER_ARGS.LIST_DIFFERENT, filesArg);
+    // eslint-disable-next-line sonarjs/os-command -- Pre-existing: executes trusted pnpm prettier command
     const result = spawnSync(cmd, [], {
         shell: true,
         cwd,
@@ -196,11 +298,11 @@ function collectPrettierListDifferent(cwd) {
     const output = `${result.stdout || ''}\n${result.stderr || ''}`;
     return parsePrettierListOutput(output);
 }
-function emitFormatCheckGuidance({ agentLog, useAgentMode, }) {
-    const files = collectPrettierListDifferent(process.cwd());
-    if (!files.length)
+function emitFormatCheckGuidance({ agentLog, useAgentMode, files, }) {
+    const formattedFiles = collectPrettierListDifferent(process.cwd(), files ?? []);
+    if (!formattedFiles.length)
         return;
-    const lines = formatFormatCheckGuidance(files);
+    const lines = formatFormatCheckGuidance(formattedFiles);
     const logLine = useAgentMode && agentLog
         ? (line) => writeSync(agentLog.logFd, `${line}\n`)
         : (line) => console.log(line);
@@ -208,12 +310,6 @@ function emitFormatCheckGuidance({ agentLog, useAgentMode, }) {
         logLine(line);
     }
 }
-/**
- * Build a pnpm --filter command string
- */
-function pnpmFilter(pkg, script) {
-    return `${PKG_MANAGER} ${PKG_FLAGS.FILTER} ${pkg} ${script}`;
-}
 function readLogTail(logPath, { maxLines = 40, maxBytes = 64 * 1024 } = {}) {
     try {
         const stats = statSync(logPath);
@@ -258,6 +354,7 @@ function run(cmd, { agentLog } = {}) {
     if (!agentLog) {
         console.log(`\n> ${cmd}\n`);
         try {
+            // eslint-disable-next-line sonarjs/os-command -- Pre-existing: cmd is built from trusted constants
             execSync(cmd, { stdio: 'inherit', encoding: FILE_SYSTEM.ENCODING });
             return { ok: true, duration: Date.now() - start };
         }
@@ -266,6 +363,7 @@ function run(cmd, { agentLog } = {}) {
         }
     }
     writeSync(agentLog.logFd, `\n> ${cmd}\n\n`);
+    // eslint-disable-next-line sonarjs/os-command -- Pre-existing: cmd is built from trusted constants
     const result = spawnSync(cmd, [], {
         shell: true,
         stdio: ['ignore', agentLog.logFd, agentLog.logFd],
@@ -274,6 +372,184 @@ function run(cmd, { agentLog } = {}) {
     });
     return { ok: result.status === EXIT_CODES.SUCCESS, duration: Date.now() - start };
 }
+function makeGateLogger({ agentLog, useAgentMode }) {
+    return (line) => {
+        if (!useAgentMode) {
+            console.log(line);
+            return;
+        }
+        if (agentLog) {
+            writeSync(agentLog.logFd, `${line}\n`);
+        }
+    };
+}
+async function runBacklogSyncGate({ agentLog, useAgentMode }) {
+    const start = Date.now();
+    const logLine = makeGateLogger({ agentLog, useAgentMode });
+    logLine('\n> Backlog sync\n');
+    const result = await validateBacklogSync({ cwd: process.cwd() });
+    if (result.errors.length > 0) {
+        logLine('❌ Backlog sync errors:');
+        result.errors.forEach((error) => logLine(`  - ${error}`));
+    }
+    if (result.warnings.length > 0) {
+        logLine('⚠️  Backlog sync warnings:');
+        result.warnings.forEach((warning) => logLine(`  - ${warning}`));
+    }
+    logLine(`Backlog sync summary: WU files=${result.wuCount}, Backlog refs=${result.backlogCount}`);
+    return { ok: result.valid, duration: Date.now() - start };
+}
+async function runSupabaseDocsGate({ agentLog, useAgentMode }) {
+    const start = Date.now();
+    const logLine = makeGateLogger({ agentLog, useAgentMode });
+    logLine('\n> Supabase docs linter\n');
+    const result = await runSupabaseDocsLinter({ cwd: process.cwd(), logger: { log: logLine } });
+    if (result.skipped) {
+        logLine(`⚠️  ${result.message ?? 'Supabase docs linter skipped.'}`);
+    }
+    else if (!result.ok) {
+        logLine('❌ Supabase docs linter failed.');
+        (result.errors ?? []).forEach((error) => logLine(`  - ${error}`));
+    }
+    else {
+        logLine(result.message ?? 'Supabase docs linter passed.');
+    }
+    return { ok: result.ok, duration: Date.now() - start };
+}
+async function runSystemMapGate({ agentLog, useAgentMode }) {
+    const start = Date.now();
+    const logLine = makeGateLogger({ agentLog, useAgentMode });
+    logLine('\n> System map validation\n');
+    const result = await runSystemMapValidation({
+        cwd: process.cwd(),
+        logger: { log: logLine, warn: logLine, error: logLine },
+    });
+    if (!result.valid) {
+        logLine('❌ System map validation failed');
+        (result.pathErrors ?? []).forEach((error) => logLine(`  - ${error}`));
+        (result.orphanDocs ?? []).forEach((error) => logLine(`  - ${error}`));
+        (result.audienceErrors ?? []).forEach((error) => logLine(`  - ${error}`));
+        (result.queryErrors ?? []).forEach((error) => logLine(`  - ${error}`));
+        (result.classificationErrors ?? []).forEach((error) => logLine(`  - ${error}`));
+    }
+    else {
+        logLine('System map validation passed.');
+    }
+    return { ok: result.valid, duration: Date.now() - start };
+}
+/**
+ * WU-1191: Run lane health check gate
+ *
+ * Checks lane configuration for overlaps and coverage gaps.
+ * Mode is configurable via gates.lane_health in .lumenflow.config.yaml:
+ * - 'warn': Log warnings but don't fail (default)
+ * - 'error': Fail the gate if issues detected
+ * - 'off': Skip the check entirely
+ */
+async function runLaneHealthGate({ agentLog, useAgentMode, mode, }) {
+    const start = Date.now();
+    const logLine = makeGateLogger({ agentLog, useAgentMode });
+    // Skip if mode is 'off'
+    if (mode === 'off') {
+        logLine('\n> Lane health check (skipped - mode: off)\n');
+        return { ok: true, duration: Date.now() - start };
+    }
+    logLine(`\n> Lane health check (mode: ${mode})\n`);
+    const report = runLaneHealthCheck({ projectRoot: process.cwd() });
+    if (!report.healthy) {
+        logLine('⚠️  Lane health issues detected:');
+        if (report.overlaps.hasOverlaps) {
+            logLine(`  - ${report.overlaps.overlaps.length} overlapping code_paths`);
+        }
+        if (report.gaps.hasGaps) {
+            logLine(`  - ${report.gaps.uncoveredFiles.length} uncovered files`);
+        }
+        logLine(`  Run 'pnpm lane:health' for full report.`);
+        if (mode === 'error') {
+            return { ok: false, duration: Date.now() - start };
+        }
+        // mode === 'warn': report but don't fail
+        logLine('  (mode: warn - not blocking)');
+    }
+    else {
+        logLine('Lane health check passed.');
+    }
+    return { ok: true, duration: Date.now() - start };
+}
+async function filterExistingFiles(files) {
+    const existingFiles = await Promise.all(files.map(async (file) => {
+        try {
+            await access(file);
+            return file;
+        }
+        catch {
+            return null;
+        }
+    }));
+    return existingFiles.filter((file) => Boolean(file));
+}
+async function runFormatCheckGate({ agentLog, useAgentMode }) {
+    const start = Date.now();
+    const logLine = makeGateLogger({ agentLog, useAgentMode });
+    let git;
+    let isMainBranch = false;
+    try {
+        git = getGitForCwd();
+        const currentBranch = await git.getCurrentBranch();
+        isMainBranch = currentBranch === BRANCHES.MAIN || currentBranch === BRANCHES.MASTER;
+    }
+    catch (error) {
+        logLine(`⚠️  Failed to determine branch for format check: ${error.message}`);
+        const result = run(pnpmCmd(SCRIPTS.FORMAT_CHECK), { agentLog });
+        return { ...result, duration: Date.now() - start, fileCount: -1 };
+    }
+    if (isMainBranch) {
+        logLine('📋 On main branch - running full format check');
+        const result = run(pnpmCmd(SCRIPTS.FORMAT_CHECK), { agentLog });
+        return { ...result, duration: Date.now() - start, fileCount: -1 };
+    }
+    let changedFiles = [];
+    let fileListError = false;
+    try {
+        changedFiles = await getChangedFilesForIncremental({ git });
+    }
+    catch (error) {
+        fileListError = true;
+        logLine(`⚠️  Failed to determine changed files for format check: ${error.message}`);
+    }
+    const plan = resolveFormatCheckPlan({ changedFiles, fileListError });
+    if (plan.mode === 'skip') {
+        logLine('\n> format:check (incremental)\n');
+        logLine('✅ No files changed - skipping format check');
+        return { ok: true, duration: Date.now() - start, fileCount: 0, filesChecked: [] };
+    }
+    if (plan.mode === 'full') {
+        /* eslint-disable sonarjs/no-nested-conditional -- Pre-existing: simple reason mapping, readable as-is */
+        const reason = plan.reason === 'prettier-config'
+            ? ' (prettier config changed)'
+            : plan.reason === 'file-list-error'
+                ? ' (file list unavailable)'
+                : '';
+        /* eslint-enable sonarjs/no-nested-conditional */
+        logLine(`📋 Running full format check${reason}`);
+        const result = run(pnpmCmd(SCRIPTS.FORMAT_CHECK), { agentLog });
+        return { ...result, duration: Date.now() - start, fileCount: -1 };
+    }
+    const existingFiles = await filterExistingFiles(plan.files);
+    if (existingFiles.length === 0) {
+        logLine('\n> format:check (incremental)\n');
+        logLine('✅ All changed files were deleted - skipping format check');
+        return { ok: true, duration: Date.now() - start, fileCount: 0, filesChecked: [] };
+    }
+    logLine(`\n> format:check (incremental: ${existingFiles.length} files)\n`);
+    const result = run(buildPrettierCheckCommand(existingFiles), { agentLog });
+    return {
+        ...result,
+        duration: Date.now() - start,
+        fileCount: existingFiles.length,
+        filesChecked: existingFiles,
+    };
+}
 /**
  * Run incremental ESLint on changed files only
  * Falls back to full lint if on main branch or if incremental fails
@@ -288,56 +564,36 @@ async function runIncrementalLint({ agentLog, } = {}) {
         }
         writeSync(agentLog.logFd, `${line}\n`);
     };
-    // WU-1006: Skip incremental lint if apps/web doesn't exist (repo-agnostic)
-    const webDir = path.join(process.cwd(), DIRECTORIES.APPS_WEB);
-    try {
-        await access(webDir);
-    }
-    catch {
-        logLine('\n> ESLint (incremental) skipped (apps/web not present)\n');
-        return { ok: true, duration: Date.now() - start, fileCount: 0 };
-    }
     try {
         // Check if we're on main branch
         const git = getGitForCwd();
         const currentBranch = await git.getCurrentBranch();
-        if (currentBranch === BRANCHES.MAIN || currentBranch === BRANCHES.MASTER) {
+        const isMainBranch = currentBranch === BRANCHES.MAIN || currentBranch === BRANCHES.MASTER;
+        if (isMainBranch) {
             logLine('📋 On main branch - running full lint');
-            const result = run(pnpmFilter(PACKAGES.WEB, SCRIPTS.LINT), { agentLog });
+            const result = run(pnpmCmd(SCRIPTS.LINT), { agentLog });
             return { ...result, fileCount: -1 };
         }
-        // Get changed files in apps/web
-        const changedFiles = await getChangedLintableFiles({
-            git,
-            filterPath: DIRECTORIES.APPS_WEB,
-        });
-        if (changedFiles.length === 0) {
+        const changedFiles = await getChangedLintableFiles({ git });
+        const plan = resolveLintPlan({ isMainBranch, changedFiles });
+        if (plan.mode === 'skip') {
             logLine('\n> ESLint (incremental)\n');
             logLine('✅ No lintable files changed - skipping lint');
             return { ok: true, duration: Date.now() - start, fileCount: 0 };
         }
-        // Filter to files that still exist (in case of deletions)
-        const existingFiles = (await Promise.all(changedFiles.map(async (f) => {
-            try {
-                await access(f);
-                return f;
-            }
-            catch {
-                return null;
-            }
-        }))).filter(Boolean);
+        if (plan.mode === 'full') {
+            logLine('📋 Running full lint (incremental plan forced full)');
+            const result = run(pnpmCmd(SCRIPTS.LINT), { agentLog });
+            return { ...result, fileCount: -1 };
+        }
+        const existingFiles = await filterExistingFiles(plan.files);
         if (existingFiles.length === 0) {
             logLine('\n> ESLint (incremental)\n');
             logLine('✅ All changed files were deleted - skipping lint');
             return { ok: true, duration: Date.now() - start, fileCount: 0 };
         }
-        // WU-2571: Convert repo-relative paths to package-relative paths
-        // ESLint runs from apps/web/ where repo-relative paths don't exist
-        const packageRelativeFiles = convertToPackageRelativePaths(existingFiles, DIRECTORIES.APPS_WEB);
-        logLine(`\n> ESLint (incremental: ${packageRelativeFiles.length} files)\n`);
-        logLine(`Files to lint:\n  ${packageRelativeFiles.join('\n  ')}\n`);
-        // WU-2571: Run ESLint from apps/web directory with package-relative paths
-        const webDir = path.join(process.cwd(), DIRECTORIES.APPS_WEB);
+        logLine(`\n> ESLint (incremental: ${existingFiles.length} files)\n`);
+        logLine(`Files to lint:\n  ${existingFiles.join('\n  ')}\n`);
         const result = spawnSync(PKG_MANAGER, [
             ESLINT_COMMANDS.ESLINT,
             ESLINT_FLAGS.MAX_WARNINGS,
@@ -349,28 +605,28 @@ async function runIncrementalLint({ agentLog, } = {}) {
             ESLINT_FLAGS.CACHE_LOCATION,
             '.eslintcache',
             ESLINT_FLAGS.PASS_ON_UNPRUNED,
-            ...packageRelativeFiles,
+            ...existingFiles,
         ], agentLog
             ? {
                 stdio: ['ignore', agentLog.logFd, agentLog.logFd],
                 encoding: FILE_SYSTEM.ENCODING,
-                cwd: webDir,
+                cwd: process.cwd(),
             }
             : {
                 stdio: 'inherit',
                 encoding: FILE_SYSTEM.ENCODING,
-                cwd: webDir,
+                cwd: process.cwd(),
             });
         const duration = Date.now() - start;
         return {
             ok: result.status === EXIT_CODES.SUCCESS,
             duration,
-            fileCount: packageRelativeFiles.length,
+            fileCount: existingFiles.length,
         };
     }
     catch (error) {
         console.error('⚠️  Incremental lint failed, falling back to full lint:', error.message);
-        const result = run(pnpmFilter(PACKAGES.WEB, SCRIPTS.LINT), { agentLog });
+        const result = run(pnpmCmd(SCRIPTS.LINT), { agentLog });
         return { ...result, fileCount: -1 };
     }
 }
@@ -393,29 +649,53 @@ async function runChangedTests({ agentLog, } = {}) {
     try {
         const git = getGitForCwd();
         const currentBranch = await git.getCurrentBranch();
-        if (currentBranch === BRANCHES.MAIN || currentBranch === BRANCHES.MASTER) {
+        const isMainBranch = currentBranch === BRANCHES.MAIN || currentBranch === BRANCHES.MASTER;
+        if (isMainBranch) {
             logLine('📋 On main branch - running full test suite');
             const result = run(pnpmCmd('turbo', 'run', 'test'), { agentLog });
             return { ...result, isIncremental: false };
         }
+        let changedFiles = [];
+        let fileListError = false;
+        try {
+            changedFiles = await getChangedFilesForIncremental({ git });
+        }
+        catch (error) {
+            fileListError = true;
+            logLine(`⚠️  Failed to determine changed files for tests: ${error.message}`);
+        }
+        const hasConfigChange = !fileListError && changedFiles.some(isTestConfigFile);
         const untrackedOutput = await git.raw(['ls-files', '--others', '--exclude-standard']);
         const untrackedFiles = untrackedOutput
             .split(/\r?\n/)
             .map((f) => f.trim())
             .filter(Boolean);
         const untrackedCodeFiles = untrackedFiles.filter(isCodeFilePath);
-        if (untrackedCodeFiles.length > 0) {
-            const preview = untrackedCodeFiles.slice(0, 5).join(', ');
-            logLine(`⚠️  Untracked code files detected (${untrackedCodeFiles.length}): ${preview}${untrackedCodeFiles.length > 5 ? '...' : ''}`);
+        const hasUntrackedCode = untrackedCodeFiles.length > 0;
+        const plan = resolveTestPlan({
+            isMainBranch,
+            hasUntrackedCode,
+            hasConfigChange,
+            fileListError,
+        });
+        if (plan.mode === 'full') {
+            if (plan.reason === 'untracked-code') {
+                const preview = untrackedCodeFiles.slice(0, 5).join(', ');
+                logLine(`⚠️  Untracked code files detected (${untrackedCodeFiles.length}): ${preview}${untrackedCodeFiles.length > 5 ? '...' : ''}`);
+            }
+            else if (plan.reason === 'test-config') {
+                logLine('⚠️  Test config changes detected - running full test suite');
+            }
+            else if (plan.reason === 'file-list-error') {
+                logLine('⚠️  Changed file list unavailable - running full test suite');
+            }
             logLine('📋 Running full test suite to avoid missing coverage');
             const result = run(pnpmCmd('turbo', 'run', 'test'), { agentLog });
             return { ...result, duration: Date.now() - start, isIncremental: false };
         }
-        // WU-1006: Use turbo for tests (repo-agnostic)
-        // Previously used --project tools and test:changed which don't exist in all repos
-        logLine('\n> Running tests (turbo run test)\n');
-        const result = run(pnpmCmd('turbo', 'run', 'test'), { agentLog });
-        return { ...result, duration: Date.now() - start, isIncremental: false };
+        logLine('\n> Running tests (vitest --changed)\n');
+        const result = run(pnpmCmd('vitest', 'run', ...buildVitestChangedArgs({ baseBranch: 'origin/main' })), { agentLog });
+        return { ...result, duration: Date.now() - start, isIncremental: true };
     }
     catch (error) {
         console.error('⚠️  Changed tests failed, falling back to full suite:', error.message);
@@ -545,55 +825,85 @@ async function runIntegrationTests({ agentLog, } = {}) {
         return { ok: false, duration: Date.now() - start };
     }
 }
+async function getChangedFilesForIncremental({ git, baseBranch = 'origin/main', }) {
+    const mergeBase = await git.mergeBase('HEAD', baseBranch);
+    const committedOutput = await git.raw(['diff', '--name-only', `${mergeBase}...HEAD`]);
+    const committedFiles = committedOutput
+        .split('\n')
+        .map((f) => f.trim())
+        .filter(Boolean);
+    const unstagedOutput = await git.raw(['diff', '--name-only']);
+    const unstagedFiles = unstagedOutput
+        .split('\n')
+        .map((f) => f.trim())
+        .filter(Boolean);
+    const untrackedOutput = await git.raw(['ls-files', '--others', '--exclude-standard']);
+    const untrackedFiles = untrackedOutput
+        .split('\n')
+        .map((f) => f.trim())
+        .filter(Boolean);
+    return [...new Set([...committedFiles, ...unstagedFiles, ...untrackedFiles])];
+}
 async function getAllChangedFiles(options = {}) {
     const { git = getGitForCwd() } = options;
     try {
-        // Get merge base
-        const mergeBase = await git.mergeBase('HEAD', 'origin/main');
-        // Get committed changes
-        const committedOutput = await git.raw(['diff', '--name-only', `${mergeBase}...HEAD`]);
-        const committedFiles = committedOutput
-            .split('\n')
-            .map((f) => f.trim())
-            .filter(Boolean);
-        // Get unstaged changes
-        const unstagedOutput = await git.raw(['diff', '--name-only']);
-        const unstagedFiles = unstagedOutput
-            .split('\n')
-            .map((f) => f.trim())
-            .filter(Boolean);
-        // Get untracked files
-        const untrackedOutput = await git.raw(['ls-files', '--others', '--exclude-standard']);
-        const untrackedFiles = untrackedOutput
-            .split('\n')
-            .map((f) => f.trim())
-            .filter(Boolean);
-        // Combine and deduplicate
-        return [...new Set([...committedFiles, ...unstagedFiles, ...untrackedFiles])];
+        return await getChangedFilesForIncremental({ git });
     }
     catch (error) {
         console.error('⚠️  Failed to get changed files:', error.message);
         return [];
     }
 }
-// Get context for telemetry
-const wu_id = getCurrentWU();
-const lane = getCurrentLane();
-const useAgentMode = shouldUseGatesAgentMode({ argv: process.argv.slice(2), env: process.env });
-const agentLog = useAgentMode ? createAgentLogContext({ wuId: wu_id, lane }) : null;
+export async function runGates(options = {}) {
+    const originalCwd = process.cwd();
+    const targetCwd = options.cwd ?? originalCwd;
+    if (targetCwd !== originalCwd) {
+        process.chdir(targetCwd);
+    }
+    try {
+        return await executeGates({
+            ...options,
+            coverageMode: options.coverageMode ?? COVERAGE_GATE_MODES.BLOCK,
+        });
+    }
+    catch {
+        return false;
+    }
+    finally {
+        if (targetCwd !== originalCwd) {
+            process.chdir(originalCwd);
+        }
+    }
+}
 // Main execution
 // eslint-disable-next-line sonarjs/cognitive-complexity -- Pre-existing: main() orchestrates multi-step gate workflow
-async function main() {
-    const opts = parseGatesArgs();
+async function executeGates(opts) {
+    const argv = opts.argv ?? process.argv.slice(2);
+    // Get context for telemetry
+    const wu_id = getCurrentWU();
+    const lane = getCurrentLane();
+    const useAgentMode = shouldUseGatesAgentMode({ argv, env: process.env });
+    const agentLog = useAgentMode ? createAgentLogContext({ wuId: wu_id, lane }) : null;
     // Parse command line arguments (now via Commander)
     const isDocsOnly = opts.docsOnly || false;
     const isFullLint = opts.fullLint || false;
     const isFullTests = opts.fullTests || false;
     // WU-2244: Full coverage flag forces full test suite and coverage gate (deterministic)
     const isFullCoverage = opts.fullCoverage || false;
+    // WU-1262: Resolve coverage config from methodology policy
+    // This derives coverage threshold and mode from methodology.testing setting
+    // WU-1280: Use resolveTestPolicy to also get tests_required for test failure handling
+    const resolvedTestPolicy = resolveTestPolicy(process.cwd());
     // WU-1433: Coverage gate mode (warn or block)
     // WU-2334: Default changed from WARN to BLOCK for TDD enforcement
-    const coverageMode = opts.coverageMode || COVERAGE_GATE_MODES.BLOCK;
+    // WU-1262: CLI flag overrides resolved policy, which overrides methodology defaults
+    const coverageMode = opts.coverageMode || resolvedTestPolicy.mode || COVERAGE_GATE_MODES.BLOCK;
+    const coverageThreshold = resolvedTestPolicy.threshold;
+    // WU-1280: Determine if tests are required (affects whether test failures block or warn)
+    // When tests_required=false (methodology.testing: none), test failures produce warnings only
+    const testsRequired = resolvedTestPolicy.tests_required;
+    // WU-1191: Lane health gate mode (warn, error, or off)
+    const laneHealthMode = loadLaneHealthConfig(process.cwd());
     if (useAgentMode) {
         console.log(`🧾 gates (agent mode): output -> ${agentLog.logPath} (use --verbose for streaming)\n`);
     }
@@ -631,27 +941,33 @@ async function main() {
         ? [
             // WU-2252: Invariants check runs first (non-bypassable)
             { name: GATE_NAMES.INVARIANTS, cmd: GATE_COMMANDS.INVARIANTS },
-            { name: GATE_NAMES.FORMAT_CHECK, cmd: pnpmCmd(SCRIPTS.FORMAT_CHECK) },
+            { name: GATE_NAMES.FORMAT_CHECK, run: runFormatCheckGate },
             { name: GATE_NAMES.SPEC_LINTER, cmd: pnpmRun(SCRIPTS.SPEC_LINTER) },
             {
                 name: GATE_NAMES.PROMPTS_LINT,
                 cmd: pnpmRun(SCRIPTS.PROMPTS_LINT, CLI_MODES.LOCAL, '--quiet'),
             },
-            { name: GATE_NAMES.BACKLOG_SYNC, cmd: TOOL_PATHS.VALIDATE_BACKLOG_SYNC },
+            { name: GATE_NAMES.BACKLOG_SYNC, run: runBacklogSyncGate },
             // WU-2315: System map validation (warn-only until orphan docs are indexed)
             {
                 name: GATE_NAMES.SYSTEM_MAP_VALIDATE,
-                cmd: TOOL_PATHS.SYSTEM_MAP_VALIDATE,
+                run: runSystemMapGate,
                 warnOnly: true,
             },
+            // WU-1191: Lane health check (configurable: warn/error/off)
+            {
+                name: GATE_NAMES.LANE_HEALTH,
+                run: (ctx) => runLaneHealthGate({ ...ctx, mode: laneHealthMode }),
+                warnOnly: laneHealthMode !== 'error',
+            },
         ]
         : [
             // WU-2252: Invariants check runs first (non-bypassable)
             { name: GATE_NAMES.INVARIANTS, cmd: GATE_COMMANDS.INVARIANTS },
-            { name: GATE_NAMES.FORMAT_CHECK, cmd: pnpmCmd(SCRIPTS.FORMAT_CHECK) },
+            { name: GATE_NAMES.FORMAT_CHECK, run: runFormatCheckGate },
             {
                 name: GATE_NAMES.LINT,
-                cmd: isFullLint ? pnpmFilter(PACKAGES.WEB, SCRIPTS.LINT) : GATE_COMMANDS.INCREMENTAL,
+                cmd: isFullLint ? pnpmCmd(SCRIPTS.LINT) : GATE_COMMANDS.INCREMENTAL,
             },
             { name: GATE_NAMES.TYPECHECK, cmd: pnpmCmd(SCRIPTS.TYPECHECK) },
             { name: GATE_NAMES.SPEC_LINTER, cmd: pnpmRun(SCRIPTS.SPEC_LINTER) },
@@ -659,27 +975,47 @@ async function main() {
                 name: GATE_NAMES.PROMPTS_LINT,
                 cmd: pnpmRun(SCRIPTS.PROMPTS_LINT, CLI_MODES.LOCAL, '--quiet'),
             },
-            { name: GATE_NAMES.BACKLOG_SYNC, cmd: TOOL_PATHS.VALIDATE_BACKLOG_SYNC },
-            { name: GATE_NAMES.SUPABASE_DOCS_LINTER, cmd: TOOL_PATHS.SUPABASE_DOCS_LINTER },
+            { name: GATE_NAMES.BACKLOG_SYNC, run: runBacklogSyncGate },
+            { name: GATE_NAMES.SUPABASE_DOCS_LINTER, run: runSupabaseDocsGate },
             // WU-2315: System map validation (warn-only until orphan docs are indexed)
             {
                 name: GATE_NAMES.SYSTEM_MAP_VALIDATE,
-                cmd: TOOL_PATHS.SYSTEM_MAP_VALIDATE,
+                run: runSystemMapGate,
                 warnOnly: true,
             },
+            // WU-1191: Lane health check (configurable: warn/error/off)
+            {
+                name: GATE_NAMES.LANE_HEALTH,
+                run: (ctx) => runLaneHealthGate({ ...ctx, mode: laneHealthMode }),
+                warnOnly: laneHealthMode !== 'error',
+            },
             // WU-2062: Safety-critical tests ALWAYS run
-            { name: GATE_NAMES.SAFETY_CRITICAL_TEST, cmd: GATE_COMMANDS.SAFETY_CRITICAL_TEST },
+            // WU-1280: When tests_required=false (methodology.testing: none), failures only warn
+            {
+                name: GATE_NAMES.SAFETY_CRITICAL_TEST,
+                cmd: GATE_COMMANDS.SAFETY_CRITICAL_TEST,
+                warnOnly: !testsRequired,
+            },
             // WU-1920: Use changed tests by default, full suite with --full-tests
             // WU-2244: --full-coverage implies --full-tests for accurate coverage
+            // WU-1280: When tests_required=false (methodology.testing: none), failures only warn
             {
                 name: GATE_NAMES.TEST,
                 cmd: isFullTests || isFullCoverage
                     ? pnpmCmd('turbo', 'run', 'test')
                     : GATE_COMMANDS.INCREMENTAL_TEST,
+                warnOnly: !testsRequired,
             },
             // WU-2062: Integration tests only for high-risk changes
+            // WU-1280: When tests_required=false (methodology.testing: none), failures only warn
             ...(riskTier && riskTier.shouldRunIntegration
-                ? [{ name: GATE_NAMES.INTEGRATION_TEST, cmd: GATE_COMMANDS.TIERED_TEST }]
+                ? [
+                    {
+                        name: GATE_NAMES.INTEGRATION_TEST,
+                        cmd: GATE_COMMANDS.TIERED_TEST,
+                        warnOnly: !testsRequired,
+                    },
+                ]
                 : []),
             // WU-1433: Coverage gate with configurable mode (warn/block)
             { name: GATE_NAMES.COVERAGE, cmd: GATE_COMMANDS.COVERAGE_GATE },
@@ -695,9 +1031,16 @@ async function main() {
     // Run all gates sequentially
     // WU-1920: Track last test result to skip coverage gate on changed tests
     let lastTestResult = null;
+    let lastFormatCheckFiles = null;
     for (const gate of gates) {
         let result;
-        if (gate.cmd === GATE_COMMANDS.INVARIANTS) {
+        if (gate.run) {
+            result = await gate.run({ agentLog, useAgentMode });
+            if (gate.name === GATE_NAMES.FORMAT_CHECK) {
+                lastFormatCheckFiles = result.filesChecked ?? null;
+            }
+        }
+        else if (gate.cmd === GATE_COMMANDS.INVARIANTS) {
             // WU-2252: Invariants check runs first (non-bypassable)
             const logLine = useAgentMode
                 ? (line) => writeSync(agentLog.logFd, `${line}\n`)
@@ -744,14 +1087,17 @@ async function main() {
                 continue;
             }
             // WU-1433: Special handling for coverage gate
+            // WU-1262: Include threshold from resolved policy in log
             if (!useAgentMode) {
-                console.log(`\n> Coverage gate (mode: ${coverageMode})\n`);
+                console.log(`\n> Coverage gate (mode: ${coverageMode}, threshold: ${coverageThreshold}%)\n`);
             }
             else {
-                writeSync(agentLog.logFd, `\n> Coverage gate (mode: ${coverageMode})\n\n`);
+                writeSync(agentLog.logFd, `\n> Coverage gate (mode: ${coverageMode}, threshold: ${coverageThreshold}%)\n\n`);
             }
             result = await runCoverageGate({
                 mode: coverageMode,
+                // WU-1262: Pass resolved threshold from methodology policy
+                threshold: coverageThreshold,
                 logger: useAgentMode
                     ? {
                         log: (msg) => {
@@ -785,7 +1131,7 @@ async function main() {
                 continue;
             }
             if (gate.name === GATE_NAMES.FORMAT_CHECK) {
-                emitFormatCheckGuidance({ agentLog, useAgentMode });
+                emitFormatCheckGuidance({ agentLog, useAgentMode, files: lastFormatCheckFiles });
             }
             if (useAgentMode) {
                 const tail = readLogTail(agentLog.logPath);
@@ -807,13 +1153,19 @@ async function main() {
     else {
         console.log(`✅ All gates passed (agent mode). Log: ${agentLog.logPath}\n`);
     }
-    process.exit(EXIT_CODES.SUCCESS);
+    return true;
 }
 // WU-1071: Use import.meta.main instead of process.argv[1] comparison
 // The old pattern fails with pnpm symlinks because process.argv[1] is the symlink
 // path but import.meta.url resolves to the real path - they never match
 if (import.meta.main) {
-    main().catch((error) => {
+    // eslint-disable-next-line sonarjs/deprecation -- Pre-existing: parseGatesArgs kept for backwards compatibility
+    const opts = parseGatesArgs();
+    executeGates({ ...opts, argv: process.argv.slice(2) })
+        .then((ok) => {
+        process.exit(ok ? EXIT_CODES.SUCCESS : EXIT_CODES.ERROR);
+    })
+        .catch((error) => {
         console.error('Gates failed:', error);
         process.exit(EXIT_CODES.ERROR);
     });