@lumenflow/cli 2.2.1 → 2.2.2

package/dist/__tests__/release.test.js

@@ -146,11 +146,39 @@ describe('release command integration', () => {
 describe('WU-1077: release script bug fixes', () => {
     describe('hasNpmAuth - ~/.npmrc detection', () => {
         let testDir;
+        let originalUserConfig;
+        let originalNpmToken;
+        let originalNodeAuthToken;
         beforeEach(() => {
             testDir = join(tmpdir(), `release-npmrc-test-${Date.now()}`);
             mkdirSync(testDir, { recursive: true });
+            originalUserConfig = process.env.NPM_CONFIG_USERCONFIG;
+            originalNpmToken = process.env.NPM_TOKEN;
+            originalNodeAuthToken = process.env.NODE_AUTH_TOKEN;
+            process.env.NPM_CONFIG_USERCONFIG = join(testDir, 'user.npmrc');
+            writeFileSync(process.env.NPM_CONFIG_USERCONFIG, '');
+            delete process.env.NPM_TOKEN;
+            delete process.env.NODE_AUTH_TOKEN;
         });
         afterEach(() => {
+            if (originalUserConfig === undefined) {
+                delete process.env.NPM_CONFIG_USERCONFIG;
+            }
+            else {
+                process.env.NPM_CONFIG_USERCONFIG = originalUserConfig;
+            }
+            if (originalNpmToken === undefined) {
+                delete process.env.NPM_TOKEN;
+            }
+            else {
+                process.env.NPM_TOKEN = originalNpmToken;
+            }
+            if (originalNodeAuthToken === undefined) {
+                delete process.env.NODE_AUTH_TOKEN;
+            }
+            else {
+                process.env.NODE_AUTH_TOKEN = originalNodeAuthToken;
+            }
             rmSync(testDir, { recursive: true, force: true });
         });
         it('should detect auth from ~/.npmrc authToken line', async () => {

package/dist/gates.js

@@ -55,7 +55,10 @@ import { detectRiskTier, RISK_TIERS, } from '@lumenflow/core/dist/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 { 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';
+import { BRANCHES, PACKAGES, PKG_MANAGER, PKG_FLAGS, 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.
@@ -274,6 +277,71 @@ 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 };
+}
 /**
  * Run incremental ESLint on changed files only
  * Falls back to full lint if on main branch or if incremental fails
@@ -576,15 +644,36 @@ async function getAllChangedFiles(options = {}) {
         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;
@@ -637,11 +726,11 @@ 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.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,
             },
         ]
@@ -659,12 +748,12 @@ 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-2062: Safety-critical tests ALWAYS run
@@ -697,7 +786,10 @@ async function main() {
     let lastTestResult = null;
     for (const gate of gates) {
         let result;
-        if (gate.cmd === GATE_COMMANDS.INVARIANTS) {
+        if (gate.run) {
+            result = await gate.run({ agentLog, useAgentMode });
+        }
+        else if (gate.cmd === GATE_COMMANDS.INVARIANTS) {
             // WU-2252: Invariants check runs first (non-bypassable)
             const logLine = useAgentMode
                 ? (line) => writeSync(agentLog.logFd, `${line}\n`)
@@ -807,13 +899,18 @@ 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) => {
+    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);
     });

package/dist/validate-backlog-sync.js

@@ -15,89 +15,11 @@
  *
  * @see {@link docs/04-operations/tasks/backlog.md} - Backlog file
  */
-import { existsSync, readFileSync, readdirSync } from 'node:fs';
-import path from 'node:path';
 import { fileURLToPath } from 'node:url';
-import { FILE_SYSTEM, EMOJI } from '@lumenflow/core/dist/wu-constants.js';
+import { validateBacklogSync, } from '@lumenflow/core/dist/validators/backlog-sync.js';
+import { EMOJI } from '@lumenflow/core/dist/wu-constants.js';
 const LOG_PREFIX = '[validate-backlog-sync]';
-/**
- * Extract WU IDs from backlog.md content
- *
- * @param content - backlog.md content
- * @returns Array of WU IDs found
- */
-function extractWUIDsFromBacklog(content) {
-    const wuIds = [];
-    const pattern = /WU-\d+/gi;
-    let match;
-    while ((match = pattern.exec(content)) !== null) {
-        const wuId = match[0].toUpperCase();
-        if (!wuIds.includes(wuId)) {
-            wuIds.push(wuId);
-        }
-    }
-    return wuIds;
-}
-/**
- * Get all WU IDs from YAML files
- *
- * @param wuDir - Path to WU directory
- * @returns Array of WU IDs
- */
-function getWUIDsFromFiles(wuDir) {
-    if (!existsSync(wuDir)) {
-        return [];
-    }
-    return readdirSync(wuDir)
-        .filter((f) => f.endsWith('.yaml'))
-        .map((f) => f.replace('.yaml', '').toUpperCase());
-}
-/**
- * Validate that backlog.md is in sync with WU YAML files
- *
- * @param options - Validation options
- * @param options.cwd - Working directory (default: process.cwd())
- * @returns Validation result
- */
-export async function validateBacklogSync(options = {}) {
-    const { cwd = process.cwd() } = options;
-    const errors = [];
-    const warnings = [];
-    // Paths
-    const backlogPath = path.join(cwd, 'docs', '04-operations', 'tasks', 'backlog.md');
-    const wuDir = path.join(cwd, 'docs', '04-operations', 'tasks', 'wu');
-    // Check backlog.md exists
-    if (!existsSync(backlogPath)) {
-        errors.push(`Backlog file not found: ${backlogPath}`);
-        return { valid: false, errors, warnings, wuCount: 0, backlogCount: 0 };
-    }
-    // Get WU IDs from files
-    const wuIdsFromFiles = getWUIDsFromFiles(wuDir);
-    // Get WU IDs from backlog
-    const backlogContent = readFileSync(backlogPath, {
-        encoding: FILE_SYSTEM.UTF8,
-    });
-    const wuIdsFromBacklog = extractWUIDsFromBacklog(backlogContent);
-    // Check for WUs in files but not in backlog
-    for (const wuId of wuIdsFromFiles) {
-        if (!wuIdsFromBacklog.includes(wuId)) {
-            errors.push(`${wuId} not found in backlog.md (exists as ${wuId}.yaml)`);
-        }
-    }
-    // Check for WUs in backlog but not as files (warning only)
-    for (const wuId of wuIdsFromBacklog) {
-        if (!wuIdsFromFiles.includes(wuId)) {
-            warnings.push(`${wuId} referenced in backlog.md but ${wuId}.yaml not found`);
-        }
-    }
-    return {
-        valid: errors.length === 0,
-        errors,
-        warnings,
-        wuCount: wuIdsFromFiles.length,
-        backlogCount: wuIdsFromBacklog.length,
-    };
-}
+export { validateBacklogSync };
 /**
  * Main CLI entry point
  */

package/dist/validate.js

@@ -19,113 +19,12 @@
  * @see {@link wu-validate.ts} - Detailed WU validation with schema
  * @see {@link docs/04-operations/_frameworks/lumenflow/lumenflow-complete.md} - WU lifecycle
  */
-import { existsSync, readFileSync, readdirSync } from 'node:fs';
 import { fileURLToPath } from 'node:url';
+import { validateSingleWU, validateAllWUs, } from '@lumenflow/core/dist/validators/wu-tasks.js';
 import { WU_PATHS } from '@lumenflow/core/dist/wu-paths.js';
-import { parseYAML } from '@lumenflow/core/dist/wu-yaml.js';
-import { validateWU, validateWUCompleteness } from '@lumenflow/core/dist/wu-schema.js';
-import { FILE_SYSTEM, EMOJI, PATTERNS } from '@lumenflow/core/dist/wu-constants.js';
+import { EMOJI, PATTERNS } from '@lumenflow/core/dist/wu-constants.js';
 const LOG_PREFIX = '[validate]';
-/**
- * Validate a single WU file
- *
- * @param wuPath - Path to WU YAML file
- * @param options - Validation options
- * @returns Validation result
- */
-export function validateSingleWU(wuPath, options = {}) {
-    const { strict = false } = options;
-    const errors = [];
-    const warnings = [];
-    // Check file exists
-    if (!existsSync(wuPath)) {
-        errors.push(`WU file not found: ${wuPath}`);
-        return { valid: false, warnings, errors };
-    }
-    // Read and parse YAML
-    let doc;
-    try {
-        const text = readFileSync(wuPath, { encoding: FILE_SYSTEM.UTF8 });
-        doc = parseYAML(text);
-    }
-    catch (e) {
-        errors.push(`Failed to parse YAML: ${e.message}`);
-        return { valid: false, warnings, errors };
-    }
-    // Schema validation
-    const schemaResult = validateWU(doc);
-    if (!schemaResult.success) {
-        const schemaErrors = schemaResult.error.issues.map((issue) => `${issue.path.join('.')}: ${issue.message}`);
-        errors.push(...schemaErrors);
-        return { valid: false, warnings, errors };
-    }
-    // Completeness validation (soft warnings)
-    const completenessResult = validateWUCompleteness(schemaResult.data);
-    warnings.push(...completenessResult.warnings);
-    // In strict mode, warnings become errors
-    if (strict && warnings.length > 0) {
-        errors.push(...warnings.map((w) => `[STRICT] ${w}`));
-        return { valid: false, warnings: [], errors };
-    }
-    return { valid: true, warnings, errors };
-}
-/**
- * Validate all WU files in the WU directory
- *
- * @param options - Validation options
- * @returns Summary of all validations
- */
-export function validateAllWUs(options = {}) {
-    const { strict = false, doneOnly = false } = options;
-    const wuDir = WU_PATHS.WU_DIR();
-    if (!existsSync(wuDir)) {
-        return {
-            totalValid: 0,
-            totalInvalid: 1,
-            totalWarnings: 0,
-            results: [
-                {
-                    wuId: 'DIRECTORY',
-                    valid: false,
-                    warnings: [],
-                    errors: [`WU directory not found: ${wuDir}`],
-                },
-            ],
-        };
-    }
-    const files = readdirSync(wuDir).filter((f) => f.endsWith('.yaml'));
-    const results = [];
-    let totalValid = 0;
-    let totalInvalid = 0;
-    let totalWarnings = 0;
-    for (const file of files) {
-        const wuPath = `${wuDir}/${file}`;
-        const wuId = file.replace('.yaml', '');
-        // Skip if only validating done WUs
-        if (doneOnly) {
-            try {
-                const text = readFileSync(wuPath, { encoding: FILE_SYSTEM.UTF8 });
-                const doc = parseYAML(text);
-                if (doc.status !== 'done') {
-                    continue;
-                }
-            }
-            catch {
-                // If we can't read, still validate to catch the error
-            }
-        }
-        const result = validateSingleWU(wuPath, { strict });
-        results.push({ wuId, ...result });
-        if (result.valid) {
-            totalValid++;
-            totalWarnings += result.warnings.length;
-        }
-        else {
-            totalInvalid++;
-        }
-    }
-    return { totalValid, totalInvalid, totalWarnings, results };
-}
+export { validateSingleWU, validateAllWUs };
 /**
  * Main CLI entry point
  */

package/dist/wu-done.js

@@ -33,6 +33,7 @@
  */
 import { execSync } from 'node:child_process';
 import prettyMs from 'pretty-ms';
+import { runGates } from './gates.js';
 import { getGitForCwd } from '@lumenflow/core/dist/git-adapter.js';
 import { die } from '@lumenflow/core/dist/error-handler.js';
 import { existsSync, readFileSync, mkdirSync, appendFileSync, unlinkSync, statSync } from 'node:fs';
@@ -915,14 +916,13 @@ function checkNodeModulesStaleness(worktreePath) {
  * @param {boolean} options.isDocsOnly - Auto-detected docs-only from code_paths
  * @param {boolean} options.docsOnly - Explicit --docs-only flag from CLI
  */
-function runGatesInWorktree(worktreePath, id, options = {}) {
+async function runGatesInWorktree(worktreePath, id, options = {}) {
     const { isDocsOnly = false, docsOnly = false } = options;
     console.log(`\n${LOG_PREFIX.DONE} Running gates in worktree: ${worktreePath}`);
     // Check for stale node_modules before running gates (prevents confusing failures)
     checkNodeModulesStaleness(worktreePath);
     // WU-1012: Use docs-only gates if explicit --docs-only flag OR auto-detected
     const useDocsOnlyGates = docsOnly || isDocsOnly;
-    const gatesCmd = buildGatesCommand({ docsOnly, isDocsOnly });
     if (useDocsOnlyGates) {
         console.log(`${LOG_PREFIX.DONE} Using docs-only gates (skipping lint/typecheck/tests)`);
         if (docsOnly) {
@@ -931,12 +931,14 @@ function runGatesInWorktree(worktreePath, id, options = {}) {
     }
     const startTime = Date.now();
     try {
-        // WU-1230: Pass WU_ID to validator for context-aware validation
-        execSync(gatesCmd, {
+        const ok = Boolean(await runGates({
             cwd: worktreePath,
-            stdio: 'inherit',
-            env: { ...process.env, WU_ID: id },
-        });
+            docsOnly: useDocsOnlyGates,
+            coverageMode: undefined,
+        }));
+        if (!ok) {
+            throw new Error('Gates failed');
+        }
         const duration = Date.now() - startTime;
         console.log(`${LOG_PREFIX.DONE} ${EMOJI.SUCCESS} Gates passed in ${prettyMs(duration)}`);
         emitTelemetry({ script: 'wu-done', wu_id: id, step: 'gates', ok: true, duration_ms: duration });
@@ -1774,8 +1776,7 @@ async function executeGates({ id, args, isBranchOnly, isDocsOnly, worktreePath,
         // Branch-Only mode: run gates in-place (current directory on lane branch)
         console.log(`\n${LOG_PREFIX.DONE} Running gates in Branch-Only mode (in-place on lane branch)`);
         // WU-1012: Use docs-only gates if explicit --docs-only flag OR auto-detected
-        const useDocsOnlyGates = args.docsOnly || isDocsOnly;
-        const gatesCmd = buildGatesCommand({ docsOnly: Boolean(args.docsOnly), isDocsOnly });
+        const useDocsOnlyGates = Boolean(args.docsOnly) || Boolean(isDocsOnly);
         if (useDocsOnlyGates) {
             console.log(`${LOG_PREFIX.DONE} Using docs-only gates (skipping lint/typecheck/tests)`);
             if (args.docsOnly) {
@@ -1784,7 +1785,10 @@ async function executeGates({ id, args, isBranchOnly, isDocsOnly, worktreePath,
         }
         const startTime = Date.now();
         try {
-            execSync(gatesCmd, { stdio: 'inherit' });
+            const ok = Boolean(await runGates({ docsOnly: useDocsOnlyGates }));
+            if (!ok) {
+                throw new Error('Gates failed');
+            }
             const duration = Date.now() - startTime;
             console.log(`${LOG_PREFIX.DONE} ${EMOJI.SUCCESS} Gates passed in ${prettyMs(duration)}`);
             emitTelemetry({
@@ -1818,7 +1822,10 @@ async function executeGates({ id, args, isBranchOnly, isDocsOnly, worktreePath,
     else if (worktreePath && existsSync(worktreePath)) {
         // Worktree mode: run gates in the dedicated worktree
         // WU-1012: Pass both auto-detected and explicit docs-only flags
-        runGatesInWorktree(worktreePath, id, { isDocsOnly, docsOnly: Boolean(args.docsOnly) });
+        await runGatesInWorktree(worktreePath, id, {
+            isDocsOnly,
+            docsOnly: Boolean(args.docsOnly),
+        });
     }
     else {
         die(`Worktree not found (${worktreePath || 'unknown'}). Gates must run in the lane worktree.\n` +
@@ -1977,7 +1984,9 @@ async function main() {
     // WU-2308: Pass worktreePath to run audit from worktree (checks fixed deps, not stale main deps)
     // WU-1145: Skip pre-flight when skipGates is true (pre-flight runs gates which was already skipped)
     if (!args.skipGates) {
-        const hookResult = validateAllPreCommitHooks(id, worktreePath);
+        const hookResult = await validateAllPreCommitHooks(id, worktreePath, {
+            runGates: ({ cwd }) => runGates({ cwd, docsOnly: false }),
+        });
         if (!hookResult.valid) {
             die('Pre-flight validation failed. Fix hook issues and try again.');
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lumenflow/cli",
-  "version": "2.2.1",
+  "version": "2.2.2",
   "description": "Command-line interface for LumenFlow workflow framework",
   "keywords": [
     "lumenflow",
@@ -133,11 +133,11 @@
     "pretty-ms": "^9.2.0",
     "simple-git": "^3.30.0",
     "yaml": "^2.8.2",
-    "@lumenflow/metrics": "2.2.1",
-    "@lumenflow/core": "2.2.1",
-    "@lumenflow/memory": "2.2.1",
-    "@lumenflow/initiatives": "2.2.1",
-    "@lumenflow/agent": "2.2.1"
+    "@lumenflow/core": "2.2.2",
+    "@lumenflow/metrics": "2.2.2",
+    "@lumenflow/memory": "2.2.2",
+    "@lumenflow/initiatives": "2.2.2",
+    "@lumenflow/agent": "2.2.2"
   },
   "devDependencies": {
     "@vitest/coverage-v8": "^4.0.17",