@lumenflow/cli 2.15.2 → 2.16.0

package/dist/gates.js

@@ -42,37 +42,41 @@ import { execSync, spawnSync } from 'node:child_process';
 import { closeSync, mkdirSync, openSync, readSync, statSync, writeSync } from 'node:fs';
 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 { emitGateEvent, getCurrentWU, getCurrentLane } from '@lumenflow/core/telemetry';
+import { die } from '@lumenflow/core/error-handler';
 // WU-1299: Import WU YAML reader to get code_paths for docs-only filtering
-import { readWURaw } from '@lumenflow/core/dist/wu-yaml.js';
-import { createWuPaths } from '@lumenflow/core/dist/wu-paths.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';
+import { readWURaw } from '@lumenflow/core/wu-yaml';
+import { createWuPaths } from '@lumenflow/core/wu-paths';
+import { getChangedLintableFiles, isLintableFile } from '@lumenflow/core/incremental-lint';
+import { buildVitestChangedArgs, isCodeFilePath } from '@lumenflow/core/incremental-test';
+import { createGitForPath } from '@lumenflow/core/git-adapter';
+import { runCoverageGate, COVERAGE_GATE_MODES } from '@lumenflow/core/coverage-gate';
+import { buildGatesLogPath, shouldUseGatesAgentMode, updateGatesLatestSymlink, } from '@lumenflow/core/gates-agent-mode';
 // WU-2062: Import risk detector for tiered test execution
-import { detectRiskTier, RISK_TIERS } from '@lumenflow/core/dist/risk-detector.js';
+import { detectRiskTier, RISK_TIERS } from '@lumenflow/core/risk-detector';
 // 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 { 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';
+import { runInvariants } from '@lumenflow/core/invariants-runner';
+import { createWUParser } from '@lumenflow/core/arg-parser';
+import { validateBacklogSync } from '@lumenflow/core/validators/backlog-sync';
+import { runSupabaseDocsLinter } from '@lumenflow/core/validators/supabase-docs-linter';
+import { runSystemMapValidation } from '@lumenflow/core/system-map-validator';
 // 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)
 // WU-1356: Configurable package manager and test commands
-import { loadLaneHealthConfig, resolveTestPolicy, resolveGatesCommands, resolveTestRunner, } from '@lumenflow/core/dist/gates-config.js';
+import { loadLaneHealthConfig, resolveTestPolicy, resolveGatesCommands, resolveTestRunner, } from '@lumenflow/core/gates-config';
 // WU-1191: Lane health check
 import { runLaneHealthCheck } from './lane-health.js';
 // WU-1315: Onboarding smoke test
 import { runOnboardingSmokeTestGate } from './onboarding-smoke-test.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';
+import { BRANCHES, PACKAGES, PKG_MANAGER, ESLINT_FLAGS, ESLINT_COMMANDS, ESLINT_DEFAULTS, SCRIPTS, CACHE_STRATEGIES, DIRECTORIES, GATE_NAMES, GATE_COMMANDS, EXIT_CODES, FILE_SYSTEM, PRETTIER_ARGS, PRETTIER_FLAGS, } from '@lumenflow/core/wu-constants';
 // WU-1520: Gates graceful degradation for missing optional scripts
-import { checkScriptExists, buildMissingScriptWarning, loadPackageJsonScripts, resolveGateAction, formatGateSummary, SKIPPABLE_GATE_SCRIPTS, } from './gates-graceful-degradation.js';
+import { buildMissingScriptWarning, loadPackageJsonScripts, resolveGateAction, formatGateSummary, } from './gates-graceful-degradation.js';
+import { runCLI } from './cli-entry-point.js';
+// WU-1550: Gate registry for declarative gate registration
+import { GateRegistry } from './gate-registry.js';
+import { registerDocsOnlyGates, registerCodeGates } from './gate-defaults.js';
 /**
  * WU-1087: Gates-specific option definitions for createWUParser.
  * Exported for testing and consistency with other CLI commands.
@@ -209,6 +213,7 @@ const TEST_CONFIG_PATTERNS = [
     /^vitest\.config\.(ts|mts|js|mjs|cjs)$/i,
     /^jest\.config\.(ts|js|mjs|cjs|json)$/i,
     /^\.mocharc\.(js|json|yaml|yml)$/i,
+    // eslint-disable-next-line security/detect-unsafe-regex -- static tsconfig pattern; no backtracking risk
     /^tsconfig(\..+)?\.json$/i,
 ];
 function normalizePath(filePath) {
@@ -410,19 +415,19 @@ export function loadCurrentWUCodePaths(options = {}) {
  * @param options - Options including packages to test and agent log context
  * @returns Result object with ok status and duration
  */
-async function runDocsOnlyFilteredTests({ packages, agentLog, }) {
+async function runDocsOnlyFilteredTests({ packages, agentLog, cwd = process.cwd(), }) {
     const start = Date.now();
-    const logLine = makeGateLogger({ agentLog, useAgentMode: !!agentLog });
+    const logLine = makeGateLogger({ agentLog, useAgentMode: !!agentLog, cwd });
     if (packages.length === 0) {
         logLine('📝 docs-only mode: no packages to test, skipping');
         return { ok: true, duration: Date.now() - start };
     }
     logLine(`\n> Tests (docs-only filtered: ${packages.join(', ')})\n`);
     // WU-1356: Use configured test command with filter
-    const gatesCommands = resolveGatesCommands(process.cwd());
+    const gatesCommands = resolveGatesCommands(cwd);
     // If there's a configured test_docs_only command, use it
     if (gatesCommands.test_docs_only) {
-        const result = run(gatesCommands.test_docs_only, { agentLog });
+        const result = run(gatesCommands.test_docs_only, { agentLog, cwd });
         return { ok: result.ok, duration: Date.now() - start };
     }
     // Otherwise, use the full test command with filter args
@@ -481,8 +486,8 @@ function collectPrettierListDifferent(cwd, files = []) {
     const output = `${result.stdout || ''}\n${result.stderr || ''}`;
     return parsePrettierListOutput(output);
 }
-function emitFormatCheckGuidance({ agentLog, useAgentMode, files, }) {
-    const formattedFiles = collectPrettierListDifferent(process.cwd(), files ?? []);
+function emitFormatCheckGuidance({ agentLog, useAgentMode, files, cwd, }) {
+    const formattedFiles = collectPrettierListDifferent(cwd, files ?? []);
     if (!formattedFiles.length)
         return;
     const lines = formatFormatCheckGuidance(formattedFiles);
@@ -514,8 +519,7 @@ function readLogTail(logPath, { maxLines = 40, maxBytes = 64 * 1024 } = {}) {
         return '';
     }
 }
-function createAgentLogContext({ wuId, lane }) {
-    const cwd = process.cwd();
+function createAgentLogContext({ wuId, lane, cwd, }) {
     const logPath = buildGatesLogPath({ cwd, env: process.env, wuId, lane });
     mkdirSync(path.dirname(logPath), { recursive: true });
     const logFd = openSync(logPath, 'a');
@@ -532,12 +536,16 @@ function createAgentLogContext({ wuId, lane }) {
     });
     return { logPath, logFd };
 }
-function run(cmd, { agentLog } = {}) {
+function run(cmd, { agentLog, cwd = process.cwd(), } = {}) {
     const start = Date.now();
     if (!agentLog) {
         console.log(`\n> ${cmd}\n`);
         try {
-            execSync(cmd, { stdio: 'inherit', encoding: FILE_SYSTEM.ENCODING });
+            execSync(cmd, {
+                stdio: 'inherit',
+                encoding: FILE_SYSTEM.ENCODING,
+                cwd,
+            });
             return { ok: true, duration: Date.now() - start };
         }
         catch {
@@ -548,17 +556,17 @@ function run(cmd, { agentLog } = {}) {
     const result = spawnSync(cmd, [], {
         shell: true,
         stdio: ['ignore', agentLog.logFd, agentLog.logFd],
-        cwd: process.cwd(),
+        cwd,
         encoding: FILE_SYSTEM.ENCODING,
     });
     return { ok: result.status === EXIT_CODES.SUCCESS, duration: Date.now() - start };
 }
-async function runSpecLinterGate({ agentLog, useAgentMode }) {
+async function runSpecLinterGate({ agentLog, useAgentMode, cwd }) {
     const start = Date.now();
     const wuId = getCurrentWU();
     if (wuId) {
         const scopedCmd = pnpmCmd('wu:validate', '--id', wuId);
-        const scopedResult = run(scopedCmd, { agentLog });
+        const scopedResult = run(scopedCmd, { agentLog, cwd });
         if (!scopedResult.ok) {
             return { ok: false, duration: Date.now() - start };
         }
@@ -569,7 +577,7 @@ async function runSpecLinterGate({ agentLog, useAgentMode }) {
     else if (agentLog) {
         writeSync(agentLog.logFd, '⚠️  Unable to detect current WU; skipping scoped validation.\n');
     }
-    const globalResult = run(pnpmRun(SCRIPTS.SPEC_LINTER), { agentLog });
+    const globalResult = run(pnpmRun(SCRIPTS.SPEC_LINTER), { agentLog, cwd });
     return { ok: globalResult.ok, duration: Date.now() - start };
 }
 function makeGateLogger({ agentLog, useAgentMode }) {
@@ -583,11 +591,11 @@ function makeGateLogger({ agentLog, useAgentMode }) {
         }
     };
 }
-async function runBacklogSyncGate({ agentLog, useAgentMode }) {
+async function runBacklogSyncGate({ agentLog, useAgentMode, cwd }) {
     const start = Date.now();
     const logLine = makeGateLogger({ agentLog, useAgentMode });
     logLine('\n> Backlog sync\n');
-    const result = await validateBacklogSync({ cwd: process.cwd() });
+    const result = await validateBacklogSync({ cwd });
     if (result.errors.length > 0) {
         logLine('❌ Backlog sync errors:');
         result.errors.forEach((error) => logLine(`  - ${error}`));
@@ -599,11 +607,11 @@ async function runBacklogSyncGate({ agentLog, useAgentMode }) {
     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 }) {
+async function runSupabaseDocsGate({ agentLog, useAgentMode, cwd }) {
     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 } });
+    const result = await runSupabaseDocsLinter({ cwd, logger: { log: logLine } });
     if (result.skipped) {
         logLine(`⚠️  ${result.message ?? 'Supabase docs linter skipped.'}`);
     }
@@ -616,12 +624,12 @@ async function runSupabaseDocsGate({ agentLog, useAgentMode }) {
     }
     return { ok: result.ok, duration: Date.now() - start };
 }
-async function runSystemMapGate({ agentLog, useAgentMode }) {
+async function runSystemMapGate({ agentLog, useAgentMode, cwd }) {
     const start = Date.now();
     const logLine = makeGateLogger({ agentLog, useAgentMode });
     logLine('\n> System map validation\n');
     const result = await runSystemMapValidation({
-        cwd: process.cwd(),
+        cwd,
         logger: { log: logLine, warn: logLine, error: logLine },
     });
     if (!result.valid) {
@@ -646,7 +654,7 @@ async function runSystemMapGate({ agentLog, useAgentMode }) {
  * - 'error': Fail the gate if issues detected
  * - 'off': Skip the check entirely
  */
-async function runLaneHealthGate({ agentLog, useAgentMode, mode, }) {
+async function runLaneHealthGate({ agentLog, useAgentMode, mode, cwd, }) {
     const start = Date.now();
     const logLine = makeGateLogger({ agentLog, useAgentMode });
     // Skip if mode is 'off'
@@ -655,7 +663,7 @@ async function runLaneHealthGate({ agentLog, useAgentMode, mode, }) {
         return { ok: true, duration: Date.now() - start };
     }
     logLine(`\n> Lane health check (mode: ${mode})\n`);
-    const report = runLaneHealthCheck({ projectRoot: process.cwd() });
+    const report = runLaneHealthCheck({ projectRoot: cwd });
     if (!report.healthy) {
         logLine('⚠️  Lane health issues detected:');
         if (report.overlaps.hasOverlaps) {
@@ -688,24 +696,24 @@ async function filterExistingFiles(files) {
     }));
     return existingFiles.filter((file) => Boolean(file));
 }
-async function runFormatCheckGate({ agentLog, useAgentMode }) {
+async function runFormatCheckGate({ agentLog, useAgentMode, cwd }) {
     const start = Date.now();
     const logLine = makeGateLogger({ agentLog, useAgentMode });
     let git;
     let isMainBranch = false;
     try {
-        git = getGitForCwd();
+        git = createGitForPath(cwd);
         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 });
+        const result = run(pnpmCmd(SCRIPTS.FORMAT_CHECK), { agentLog, cwd });
         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 });
+        const result = run(pnpmCmd(SCRIPTS.FORMAT_CHECK), { agentLog, cwd });
         return { ...result, duration: Date.now() - start, fileCount: -1 };
     }
     let changedFiles = [];
@@ -730,7 +738,7 @@ async function runFormatCheckGate({ agentLog, useAgentMode }) {
                 ? ' (file list unavailable)'
                 : '';
         logLine(`📋 Running full format check${reason}`);
-        const result = run(pnpmCmd(SCRIPTS.FORMAT_CHECK), { agentLog });
+        const result = run(pnpmCmd(SCRIPTS.FORMAT_CHECK), { agentLog, cwd });
         return { ...result, duration: Date.now() - start, fileCount: -1 };
     }
     const existingFiles = await filterExistingFiles(plan.files);
@@ -740,7 +748,7 @@ async function runFormatCheckGate({ agentLog, useAgentMode }) {
         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 });
+    const result = run(buildPrettierCheckCommand(existingFiles), { agentLog, cwd });
     return {
         ...result,
         duration: Date.now() - start,
@@ -753,7 +761,7 @@ async function runFormatCheckGate({ agentLog, useAgentMode }) {
  * Falls back to full lint if on main branch or if incremental fails
  * @returns {{ ok: boolean, duration: number, fileCount: number }}
  */
-async function runIncrementalLint({ agentLog, } = {}) {
+async function runIncrementalLint({ agentLog, cwd, }) {
     const start = Date.now();
     const logLine = (line) => {
         if (!agentLog) {
@@ -764,12 +772,12 @@ async function runIncrementalLint({ agentLog, } = {}) {
     };
     try {
         // Check if we're on main branch
-        const git = getGitForCwd();
+        const git = createGitForPath(cwd);
         const currentBranch = await git.getCurrentBranch();
         const isMainBranch = currentBranch === BRANCHES.MAIN || currentBranch === BRANCHES.MASTER;
         if (isMainBranch) {
             logLine('📋 On main branch - running full lint');
-            const result = run(pnpmCmd(SCRIPTS.LINT), { agentLog });
+            const result = run(pnpmCmd(SCRIPTS.LINT), { agentLog, cwd });
             return { ...result, fileCount: -1 };
         }
         const changedFiles = await getChangedLintableFiles({ git });
@@ -781,7 +789,7 @@ async function runIncrementalLint({ agentLog, } = {}) {
         }
         if (plan.mode === 'full') {
             logLine('📋 Running full lint (incremental plan forced full)');
-            const result = run(pnpmCmd(SCRIPTS.LINT), { agentLog });
+            const result = run(pnpmCmd(SCRIPTS.LINT), { agentLog, cwd });
             return { ...result, fileCount: -1 };
         }
         const existingFiles = await filterExistingFiles(plan.files);
@@ -808,12 +816,12 @@ async function runIncrementalLint({ agentLog, } = {}) {
             ? {
                 stdio: ['ignore', agentLog.logFd, agentLog.logFd],
                 encoding: FILE_SYSTEM.ENCODING,
-                cwd: process.cwd(),
+                cwd,
             }
             : {
                 stdio: 'inherit',
                 encoding: FILE_SYSTEM.ENCODING,
-                cwd: process.cwd(),
+                cwd,
             });
         const duration = Date.now() - start;
         return {
@@ -824,7 +832,7 @@ async function runIncrementalLint({ agentLog, } = {}) {
     }
     catch (error) {
         console.error('⚠️  Incremental lint failed, falling back to full lint:', error.message);
-        const result = run(pnpmCmd(SCRIPTS.LINT), { agentLog });
+        const result = run(pnpmCmd(SCRIPTS.LINT), { agentLog, cwd });
         return { ...result, fileCount: -1 };
     }
 }
@@ -835,7 +843,7 @@ async function runIncrementalLint({ agentLog, } = {}) {
  *
  * @returns {{ ok: boolean, duration: number, isIncremental: boolean }}
  */
-async function runChangedTests({ agentLog, } = {}) {
+async function runChangedTests({ agentLog, cwd, }) {
     const start = Date.now();
     // eslint-disable-next-line sonarjs/no-identical-functions -- Pre-existing: logLine helper duplicated across gate runners
     const logLine = (line) => {
@@ -846,15 +854,15 @@ async function runChangedTests({ agentLog, } = {}) {
         writeSync(agentLog.logFd, `${line}\n`);
     };
     // WU-1356: Get configured commands
-    const gatesCommands = resolveGatesCommands(process.cwd());
-    const testRunner = resolveTestRunner(process.cwd());
+    const gatesCommands = resolveGatesCommands(cwd);
+    const testRunner = resolveTestRunner(cwd);
     try {
-        const git = getGitForCwd();
+        const git = createGitForPath(cwd);
         const currentBranch = await git.getCurrentBranch();
         const isMainBranch = currentBranch === BRANCHES.MAIN || currentBranch === BRANCHES.MASTER;
         if (isMainBranch) {
             logLine('📋 On main branch - running full test suite');
-            const result = run(gatesCommands.test_full, { agentLog });
+            const result = run(gatesCommands.test_full, { agentLog, cwd });
             return { ...result, isIncremental: false };
         }
         let changedFiles = [];
@@ -892,29 +900,29 @@ async function runChangedTests({ agentLog, } = {}) {
                 logLine('⚠️  Changed file list unavailable - running full test suite');
             }
             logLine('📋 Running full test suite to avoid missing coverage');
-            const result = run(gatesCommands.test_full, { agentLog });
+            const result = run(gatesCommands.test_full, { agentLog, cwd });
             return { ...result, duration: Date.now() - start, isIncremental: false };
         }
         // WU-1356: Use configured incremental test command
         logLine(`\n> Running tests (${testRunner} --changed)\n`);
         // If test_incremental is configured, use it directly
         if (gatesCommands.test_incremental) {
-            const result = run(gatesCommands.test_incremental, { agentLog });
+            const result = run(gatesCommands.test_incremental, { agentLog, cwd });
             return { ...result, duration: Date.now() - start, isIncremental: true };
         }
         // Fallback: For vitest, use the built-in changed args helper
         if (testRunner === 'vitest') {
-            const result = run(pnpmCmd('vitest', 'run', ...buildVitestChangedArgs({ baseBranch: 'origin/main' })), { agentLog });
+            const result = run(pnpmCmd('vitest', 'run', ...buildVitestChangedArgs({ baseBranch: 'origin/main' })), { agentLog, cwd });
             return { ...result, duration: Date.now() - start, isIncremental: true };
         }
         // For other runners without configured incremental, fall back to full
         logLine('⚠️  No incremental test command configured, running full suite');
-        const result = run(gatesCommands.test_full, { agentLog });
+        const result = run(gatesCommands.test_full, { agentLog, cwd });
         return { ...result, duration: Date.now() - start, isIncremental: false };
     }
     catch (error) {
         console.error('⚠️  Changed tests failed, falling back to full suite:', error.message);
-        const result = run(gatesCommands.test_full, { agentLog });
+        const result = run(gatesCommands.test_full, { agentLog, cwd });
         return { ...result, isIncremental: false };
     }
 }
@@ -953,7 +961,7 @@ const SAFETY_CRITICAL_TEST_FILES = [
  * @param {object} [options.agentLog] - Agent log context
  * @returns {Promise<{ ok: boolean, duration: number, testCount: number }>}
  */
-async function runSafetyCriticalTests({ agentLog, } = {}) {
+async function runSafetyCriticalTests({ agentLog, cwd, }) {
     const start = Date.now();
     // eslint-disable-next-line sonarjs/no-identical-functions -- Pre-existing: logLine helper duplicated across gate runners
     const logLine = (line) => {
@@ -964,7 +972,7 @@ async function runSafetyCriticalTests({ agentLog, } = {}) {
         writeSync(agentLog.logFd, `${line}\n`);
     };
     // WU-1006: Skip safety-critical tests if apps/web doesn't exist (repo-agnostic)
-    const webDir = path.join(process.cwd(), DIRECTORIES.APPS_WEB);
+    const webDir = path.join(cwd, DIRECTORIES.APPS_WEB);
     try {
         await access(webDir);
     }
@@ -989,12 +997,12 @@ async function runSafetyCriticalTests({ agentLog, } = {}) {
             ? {
                 stdio: ['ignore', agentLog.logFd, agentLog.logFd],
                 encoding: FILE_SYSTEM.ENCODING,
-                cwd: process.cwd(),
+                cwd,
             }
             : {
                 stdio: 'inherit',
                 encoding: FILE_SYSTEM.ENCODING,
-                cwd: process.cwd(),
+                cwd,
             });
         const duration = Date.now() - start;
         return {
@@ -1016,7 +1024,7 @@ async function runSafetyCriticalTests({ agentLog, } = {}) {
  * @param {object} [options.agentLog] - Agent log context
  * @returns {Promise<{ ok: boolean, duration: number }>}
  */
-async function runIntegrationTests({ agentLog, } = {}) {
+async function runIntegrationTests({ agentLog, cwd, }) {
     const start = Date.now();
     // eslint-disable-next-line sonarjs/no-identical-functions -- Pre-existing: logLine helper duplicated across gate runners
     const logLine = (line) => {
@@ -1030,7 +1038,7 @@ async function runIntegrationTests({ agentLog, } = {}) {
         logLine('\n> Integration tests (high-risk changes detected)\n');
         // WU-1415: vitest doesn't support --include flag
         // Pass glob patterns as positional arguments instead
-        const result = run(`RUN_INTEGRATION_TESTS=1 ${pnpmCmd('vitest', 'run', "'**/*.integration.*'", "'**/golden-*.test.*'")}`, { agentLog });
+        const result = run(`RUN_INTEGRATION_TESTS=1 ${pnpmCmd('vitest', 'run', "'**/*.integration.*'", "'**/golden-*.test.*'")}`, { agentLog, cwd });
         const duration = Date.now() - start;
         return {
             ok: result.ok,
@@ -1062,7 +1070,7 @@ async function getChangedFilesForIncremental({ git, baseBranch = 'origin/main',
     return [...new Set([...committedFiles, ...unstagedFiles, ...untrackedFiles])];
 }
 async function getAllChangedFiles(options = {}) {
-    const { git = getGitForCwd() } = options;
+    const { git = createGitForPath(options.cwd ?? process.cwd()) } = options;
     try {
         return await getChangedFilesForIncremental({ git });
     }
@@ -1072,41 +1080,30 @@ async function getAllChangedFiles(options = {}) {
     }
 }
 /**
- * WU-1541: runGates still uses process.chdir as a contained, self-restoring pattern.
- * The executeGates function and ~30 sub-functions use process.cwd() extensively.
- * A full refactor to pass explicit cwd through all gate functions would be a separate WU.
- * The try/finally pattern here is safe: chdir is always restored even on error.
+ * Run gates for a specific working directory without mutating global process cwd.
  */
 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,
+            cwd: options.cwd ?? process.cwd(),
             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 executeGates(opts) {
+    const cwd = opts.cwd ?? process.cwd();
     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;
+    const agentLog = useAgentMode ? createAgentLogContext({ wuId: wu_id, lane, cwd }) : null;
     // Parse command line arguments (now via Commander)
     const isDocsOnly = opts.docsOnly || false;
     const isFullLint = opts.fullLint || false;
@@ -1116,7 +1113,7 @@ async function executeGates(opts) {
     // 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());
+    const resolvedTestPolicy = resolveTestPolicy(cwd);
     // WU-1433: Coverage gate mode (warn or block)
     // WU-2334: Default changed from WARN to BLOCK for TDD enforcement
     // WU-1262: CLI flag overrides resolved policy, which overrides methodology defaults
@@ -1126,12 +1123,12 @@ async function executeGates(opts) {
     // 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());
+    const laneHealthMode = loadLaneHealthConfig(cwd);
     // WU-1356: Resolve configured gates commands for test execution
-    const configuredGatesCommands = resolveGatesCommands(process.cwd());
+    const configuredGatesCommands = resolveGatesCommands(cwd);
     // WU-1520: Strict mode and script existence checking for graceful degradation
     const isStrict = opts.strict || false;
-    const packageJsonScripts = loadPackageJsonScripts(process.cwd());
+    const packageJsonScripts = loadPackageJsonScripts(cwd);
     // WU-1520: Track gate results for summary
     const gateResults = [];
     if (useAgentMode) {
@@ -1142,7 +1139,7 @@ async function executeGates(opts) {
     let changedFiles = [];
     if (!isDocsOnly) {
         try {
-            changedFiles = await getAllChangedFiles();
+            changedFiles = await getAllChangedFiles({ cwd });
             riskTier = detectRiskTier({ changedFiles });
             const logLine = useAgentMode
                 ? (line) => writeSync(agentLog.logFd, `${line}\n`)
@@ -1168,132 +1165,62 @@ async function executeGates(opts) {
     // WU-1299: Load code_paths and compute docs-only test plan
     let docsOnlyTestPlan = null;
     if (effectiveDocsOnly) {
-        const codePaths = loadCurrentWUCodePaths({ cwd: process.cwd() });
+        const codePaths = loadCurrentWUCodePaths({ cwd });
         docsOnlyTestPlan = resolveDocsOnlyTestPlan({ codePaths });
     }
-    // Determine which gates to run
+    // WU-1550: Build gate list via GateRegistry (declarative, Open-Closed Principle)
+    // New gates can be added by calling registry.register() without modifying this function.
     // WU-2252: Invariants gate runs FIRST and is included in both docs-only and regular modes
     // WU-1520: scriptName field maps gates to their package.json script for existence checking
-    const gates = effectiveDocsOnly
-        ? [
-            // WU-2252: Invariants check runs first (non-bypassable)
-            { name: GATE_NAMES.INVARIANTS, cmd: GATE_COMMANDS.INVARIANTS },
-            {
-                name: GATE_NAMES.FORMAT_CHECK,
-                run: runFormatCheckGate,
-                scriptName: SCRIPTS.FORMAT_CHECK,
-            },
-            { name: GATE_NAMES.SPEC_LINTER, run: runSpecLinterGate, scriptName: SCRIPTS.SPEC_LINTER },
-            // WU-1467: prompts:lint removed -- was a stub (exit 0), not an authoritative gate
-            { 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,
-                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-1315: Onboarding smoke test (init + wu:create validation)
-            {
-                name: GATE_NAMES.ONBOARDING_SMOKE_TEST,
-                cmd: GATE_COMMANDS.ONBOARDING_SMOKE_TEST,
-            },
-            // WU-1299: Filtered tests for packages in code_paths (if any)
-            // When docs-only mode has packages in code_paths, run tests only for those packages
-            // This prevents pre-existing failures in unrelated packages from blocking
-            ...(docsOnlyTestPlan && docsOnlyTestPlan.mode === 'filtered'
-                ? [
-                    {
-                        name: GATE_NAMES.TEST,
-                        run: (ctx) => {
-                            // Safe access: docsOnlyTestPlan is guaranteed non-null by the outer conditional
-                            const pkgs = docsOnlyTestPlan.packages;
-                            return runDocsOnlyFilteredTests({
-                                packages: pkgs,
-                                agentLog: ctx.agentLog,
-                            });
-                        },
-                        warnOnly: !testsRequired,
-                    },
-                ]
-                : []),
-        ]
-        : [
-            // WU-2252: Invariants check runs first (non-bypassable)
-            { name: GATE_NAMES.INVARIANTS, cmd: GATE_COMMANDS.INVARIANTS },
-            {
-                name: GATE_NAMES.FORMAT_CHECK,
-                run: runFormatCheckGate,
-                scriptName: SCRIPTS.FORMAT_CHECK,
-            },
-            {
-                name: GATE_NAMES.LINT,
-                cmd: isFullLint ? pnpmCmd(SCRIPTS.LINT) : GATE_COMMANDS.INCREMENTAL,
-                scriptName: SCRIPTS.LINT,
-            },
-            {
-                name: GATE_NAMES.TYPECHECK,
-                cmd: pnpmCmd(SCRIPTS.TYPECHECK),
-                scriptName: SCRIPTS.TYPECHECK,
-            },
-            { name: GATE_NAMES.SPEC_LINTER, run: runSpecLinterGate, scriptName: SCRIPTS.SPEC_LINTER },
-            // WU-1467: prompts:lint removed -- was a stub (exit 0), not an authoritative gate
-            { 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,
-                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-1315: Onboarding smoke test (init + wu:create validation)
-            {
-                name: GATE_NAMES.ONBOARDING_SMOKE_TEST,
-                cmd: GATE_COMMANDS.ONBOARDING_SMOKE_TEST,
-            },
-            // WU-2062: Safety-critical tests ALWAYS run
-            // 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
-            // WU-1356: Use configured test command instead of hard-coded turbo
-            {
-                name: GATE_NAMES.TEST,
-                cmd: isFullTests || isFullCoverage
-                    ? configuredGatesCommands.test_full
-                    : 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,
-                        warnOnly: !testsRequired,
-                    },
-                ]
-                : []),
-            // WU-1433: Coverage gate with configurable mode (warn/block)
-            { name: GATE_NAMES.COVERAGE, cmd: GATE_COMMANDS.COVERAGE_GATE },
-        ];
+    const gateRegistry = new GateRegistry();
+    if (effectiveDocsOnly) {
+        registerDocsOnlyGates(gateRegistry, {
+            laneHealthMode,
+            testsRequired,
+            docsOnlyTestPlan,
+        });
+    }
+    else {
+        registerCodeGates(gateRegistry, {
+            isFullLint,
+            isFullTests,
+            isFullCoverage,
+            laneHealthMode,
+            testsRequired,
+            shouldRunIntegration: !!(riskTier && riskTier.shouldRunIntegration),
+            configuredTestFullCmd: configuredGatesCommands.test_full,
+        });
+    }
+    // WU-1550: Inject run functions for gates that need them.
+    // The registry stores declarative metadata; run functions are bound here
+    // because they depend on local gate-runner functions in this module.
+    const gateRunFunctions = {
+        [GATE_NAMES.FORMAT_CHECK]: runFormatCheckGate,
+        [GATE_NAMES.SPEC_LINTER]: runSpecLinterGate,
+        [GATE_NAMES.BACKLOG_SYNC]: runBacklogSyncGate,
+        [GATE_NAMES.SUPABASE_DOCS_LINTER]: runSupabaseDocsGate,
+        [GATE_NAMES.SYSTEM_MAP_VALIDATE]: runSystemMapGate,
+        [GATE_NAMES.LANE_HEALTH]: (ctx) => runLaneHealthGate({ ...ctx, mode: laneHealthMode }),
+    };
+    // WU-1299: Docs-only filtered tests get a custom run function
+    if (docsOnlyTestPlan && docsOnlyTestPlan.mode === 'filtered') {
+        gateRunFunctions[GATE_NAMES.TEST] = (ctx) => {
+            const pkgs = docsOnlyTestPlan.packages;
+            return runDocsOnlyFilteredTests({
+                packages: pkgs,
+                agentLog: ctx.agentLog,
+                cwd: ctx.cwd,
+            });
+        };
+    }
+    // Apply run functions to registered gates
+    const gates = gateRegistry.getAll().map((gate) => {
+        const runFn = gateRunFunctions[gate.name];
+        if (runFn && !gate.run) {
+            return { ...gate, run: runFn };
+        }
+        return gate;
+    });
     if (effectiveDocsOnly) {
         // WU-1299: Show clear messaging about what's being skipped/run in docs-only mode
         const docsOnlyMessage = docsOnlyTestPlan && docsOnlyTestPlan.mode === 'filtered'
@@ -1316,7 +1243,7 @@ async function executeGates(opts) {
         const gateScriptName = gate.scriptName ?? null;
         const gateAction = resolveGateAction(gate.name, gateScriptName, packageJsonScripts, isStrict);
         if (gateAction === 'skip') {
-            const logLine = makeGateLogger({ agentLog, useAgentMode });
+            const logLine = makeGateLogger({ agentLog, useAgentMode, cwd });
             const warningMsg = buildMissingScriptWarning(gateScriptName);
             logLine(`\n${warningMsg}\n`);
             gateResults.push({
@@ -1328,7 +1255,7 @@ async function executeGates(opts) {
             continue;
         }
         if (gateAction === 'fail') {
-            const logLine = makeGateLogger({ agentLog, useAgentMode });
+            const logLine = makeGateLogger({ agentLog, useAgentMode, cwd });
             logLine(`\n❌ "${gateScriptName}" script not found in package.json (--strict mode)\n`);
             gateResults.push({
                 name: gate.name,
@@ -1339,7 +1266,7 @@ async function executeGates(opts) {
             die(`${gate.name} failed: missing script "${gateScriptName}" in package.json (--strict mode requires all gate scripts)`);
         }
         if (gate.run) {
-            result = await gate.run({ agentLog, useAgentMode });
+            result = await gate.run({ agentLog, useAgentMode, cwd });
             if (gate.name === GATE_NAMES.FORMAT_CHECK) {
                 lastFormatCheckFiles = result.filesChecked ?? null;
             }
@@ -1350,7 +1277,7 @@ async function executeGates(opts) {
                 ? (line) => writeSync(agentLog.logFd, `${line}\n`)
                 : (line) => console.log(line);
             logLine('\n> Invariants check\n');
-            const invariantsResult = runInvariants({ baseDir: process.cwd(), silent: false });
+            const invariantsResult = runInvariants({ baseDir: cwd, silent: false });
             result = {
                 ok: invariantsResult.success,
                 duration: 0, // runInvariants doesn't track duration
@@ -1362,20 +1289,20 @@ async function executeGates(opts) {
         }
         else if (gate.cmd === GATE_COMMANDS.INCREMENTAL) {
             // Special handling for incremental lint
-            result = await runIncrementalLint({ agentLog });
+            result = await runIncrementalLint({ agentLog, cwd });
         }
         else if (gate.cmd === GATE_COMMANDS.SAFETY_CRITICAL_TEST) {
             // WU-2062: Safety-critical tests always run
-            result = await runSafetyCriticalTests({ agentLog });
+            result = await runSafetyCriticalTests({ agentLog, cwd });
         }
         else if (gate.cmd === GATE_COMMANDS.INCREMENTAL_TEST) {
             // WU-1920: Special handling for changed tests
-            result = await runChangedTests({ agentLog });
+            result = await runChangedTests({ agentLog, cwd });
             lastTestResult = result;
         }
         else if (gate.cmd === GATE_COMMANDS.TIERED_TEST) {
             // WU-2062: Integration tests for high-risk changes
-            result = await runIntegrationTests({ agentLog });
+            result = await runIntegrationTests({ agentLog, cwd });
         }
         else if (gate.cmd === GATE_COMMANDS.COVERAGE_GATE) {
             // WU-1920: Skip coverage gate when tests were changed (partial coverage)
@@ -1429,7 +1356,7 @@ async function executeGates(opts) {
             });
         }
         else {
-            result = run(gate.cmd, { agentLog });
+            result = run(gate.cmd, { agentLog, cwd });
         }
         // Emit telemetry event
         emitGateEvent({
@@ -1458,7 +1385,7 @@ async function executeGates(opts) {
                 continue;
             }
             if (gate.name === GATE_NAMES.FORMAT_CHECK) {
-                emitFormatCheckGuidance({ agentLog, useAgentMode, files: lastFormatCheckFiles });
+                emitFormatCheckGuidance({ agentLog, useAgentMode, files: lastFormatCheckFiles, cwd });
             }
             // WU-1520: Track failed gate before dying
             gateResults.push({
@@ -1467,7 +1394,7 @@ async function executeGates(opts) {
                 durationMs: result.duration,
             });
             // WU-1520: Print summary before failing
-            const logLine = makeGateLogger({ agentLog, useAgentMode });
+            const logLine = makeGateLogger({ agentLog, useAgentMode, cwd });
             logLine(`\n${formatGateSummary(gateResults)}\n`);
             if (useAgentMode) {
                 const tail = readLogTail(agentLog.logPath);
@@ -1487,10 +1414,10 @@ async function executeGates(opts) {
     }
     // WU-2064: Create/update gates-latest.log symlink for easy agent access
     if (agentLog) {
-        updateGatesLatestSymlink({ logPath: agentLog.logPath, cwd: process.cwd(), env: process.env });
+        updateGatesLatestSymlink({ logPath: agentLog.logPath, cwd, env: process.env });
     }
     // WU-1520: Print gate summary showing passed/skipped/failed/warned
-    const summaryLogLine = makeGateLogger({ agentLog, useAgentMode });
+    const summaryLogLine = makeGateLogger({ agentLog, useAgentMode, cwd });
     summaryLogLine(`\n${formatGateSummary(gateResults)}`);
     if (!useAgentMode) {
         console.log('\n✅ All gates passed!\n');
@@ -1500,18 +1427,18 @@ async function executeGates(opts) {
     }
     return true;
 }
+// WU-1537: Wrap executeGates in a standard main() for runCLI consistency
+async function main() {
+    const opts = parseGatesArgs();
+    const ok = await executeGates({ ...opts, argv: process.argv.slice(2) });
+    if (!ok) {
+        process.exit(EXIT_CODES.ERROR);
+    }
+}
 // 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) {
-    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);
-    });
+    void runCLI(main);
 }
 //# sourceMappingURL=gates.js.map