@lumenflow/cli 2.5.0 → 2.6.0

package/dist/gates.js

@@ -65,7 +65,8 @@ import { runSystemMapValidation } from '@lumenflow/core/dist/system-map-validato
 // 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-1356: Configurable package manager and test commands
+import { loadLaneHealthConfig, resolveTestPolicy, resolveGatesCommands, resolveTestRunner, } from '@lumenflow/core/dist/gates-config.js';
 // WU-1191: Lane health check
 import { runLaneHealthCheck } from './lane-health.js';
 // WU-1315: Onboarding smoke test
@@ -184,8 +185,24 @@ const PRETTIER_CONFIG_FILES = new Set([
     '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];
+// WU-1356: Extended to support multiple build tools and test runners
+const TEST_CONFIG_BASENAMES = new Set([
+    'turbo.json', // Turborepo
+    'nx.json', // Nx
+    'lerna.json', // Lerna
+    'pnpm-lock.yaml',
+    'package-lock.json',
+    'yarn.lock',
+    'bun.lockb',
+    'package.json',
+]);
+// WU-1356: Extended to support vitest, jest, and mocha config patterns
+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,
+    /^tsconfig(\..+)?\.json$/i,
+];
 function normalizePath(filePath) {
     return filePath.replace(/\\/g, '/');
 }
@@ -380,9 +397,11 @@ export function loadCurrentWUCodePaths(options = {}) {
 }
 /**
  * WU-1299: Run filtered tests for docs-only mode
+ * WU-1356: Updated to use configured test command
  *
  * When --docs-only is passed and code_paths contains packages, this runs tests
- * only for those specific packages using turbo's --filter flag.
+ * only for those specific packages. The filter syntax adapts to the configured
+ * build tool (turbo, nx, or plain package manager).
  *
  * @param options - Options including packages to test and agent log context
  * @returns Result object with ok status and duration
@@ -395,10 +414,20 @@ async function runDocsOnlyFilteredTests({ packages, agentLog, }) {
         return { ok: true, duration: Date.now() - start };
     }
     logLine(`\n> Tests (docs-only filtered: ${packages.join(', ')})\n`);
-    // Build turbo filter args for each package
-    // turbo supports --filter=@scope/package or --filter=package
+    // WU-1356: Use configured test command with filter
+    const gatesCommands = resolveGatesCommands(process.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 });
+        return { ok: result.ok, duration: Date.now() - start };
+    }
+    // Otherwise, use the full test command with filter args
+    // Build filter args for each package (works with turbo, nx, and pnpm/yarn workspaces)
     const filterArgs = packages.map((pkg) => `--filter=${pkg}`);
-    const result = run(pnpmCmd('turbo', 'run', 'test', ...filterArgs), { agentLog });
+    const baseCmd = gatesCommands.test_full;
+    // Append filter args to the base command
+    const filteredCmd = `${baseCmd} ${filterArgs.join(' ')}`;
+    const result = run(filteredCmd, { agentLog });
     return { ok: result.ok, duration: Date.now() - start };
 }
 export function parsePrettierListOutput(output) {
@@ -782,7 +811,8 @@ async function runIncrementalLint({ agentLog, } = {}) {
     }
 }
 /**
- * Run changed tests using Vitest's --changed flag from the repo root.
+ * Run changed tests using configured test runner's incremental mode.
+ * WU-1356: Updated to use configured commands from gates-config.
  * Falls back to full test suite if on main branch or if the run fails.
  *
  * @returns {{ ok: boolean, duration: number, isIncremental: boolean }}
@@ -797,13 +827,16 @@ async function runChangedTests({ agentLog, } = {}) {
         }
         writeSync(agentLog.logFd, `${line}\n`);
     };
+    // WU-1356: Get configured commands
+    const gatesCommands = resolveGatesCommands(process.cwd());
+    const testRunner = resolveTestRunner(process.cwd());
     try {
         const git = getGitForCwd();
         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(pnpmCmd('turbo', 'run', 'test'), { agentLog });
+            const result = run(gatesCommands.test_full, { agentLog });
             return { ...result, isIncremental: false };
         }
         let changedFiles = [];
@@ -841,16 +874,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(pnpmCmd('turbo', 'run', 'test'), { agentLog });
+            const result = run(gatesCommands.test_full, { 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 };
+        // 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 });
+            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 });
+            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 });
+        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(pnpmCmd('turbo', 'run', 'test'), { agentLog });
+        const result = run(gatesCommands.test_full, { agentLog });
         return { ...result, isIncremental: false };
     }
 }
@@ -1055,6 +1101,8 @@ async function executeGates(opts) {
     const testsRequired = resolvedTestPolicy.tests_required;
     // WU-1191: Lane health gate mode (warn, error, or off)
     const laneHealthMode = loadLaneHealthConfig(process.cwd());
+    // WU-1356: Resolve configured gates commands for test execution
+    const configuredGatesCommands = resolveGatesCommands(process.cwd());
     if (useAgentMode) {
         console.log(`🧾 gates (agent mode): output -> ${agentLog.logPath} (use --verbose for streaming)\n`);
     }
@@ -1185,10 +1233,11 @@ async function executeGates(opts) {
             // 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
-                    ? pnpmCmd('turbo', 'run', 'test')
+                    ? configuredGatesCommands.test_full
                     : GATE_COMMANDS.INCREMENTAL_TEST,
                 warnOnly: !testsRequired,
             },

package/dist/init.js

@@ -1909,6 +1909,8 @@ export async function scaffoldProject(targetDir, options) {
     // Create .lumenflow/agents directory with .gitkeep
     await createDirectory(path.join(targetDir, LUMENFLOW_AGENTS_DIR), result, targetDir);
     await createFile(path.join(targetDir, LUMENFLOW_AGENTS_DIR, '.gitkeep'), '', options.force ? 'force' : 'skip', result, targetDir);
+    // WU-1342: Create .gitignore with required exclusions
+    await scaffoldGitignore(targetDir, options, result);
     // Optional: full docs scaffolding
     if (options.full) {
         await scaffoldFullDocs(targetDir, options, result, tokenDefaults);
@@ -1925,18 +1927,106 @@ export async function scaffoldProject(targetDir, options) {
     }
     return result;
 }
+/**
+ * WU-1342: .gitignore template with required exclusions
+ * Includes node_modules, .lumenflow/state, and worktrees
+ */
+const GITIGNORE_TEMPLATE = `# Dependencies
+node_modules/
+
+# LumenFlow state (local only, not shared)
+.lumenflow/state/
+
+# Worktrees (isolated parallel work directories)
+worktrees/
+
+# Build output
+dist/
+*.tsbuildinfo
+
+# Environment files
+.env
+.env.local
+.env.*.local
+
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo
+
+# OS files
+.DS_Store
+Thumbs.db
+`;
+/** Gitignore file name constant to avoid duplicate string lint error */
+const GITIGNORE_FILE_NAME = '.gitignore';
+/**
+ * WU-1342: Scaffold .gitignore file with LumenFlow exclusions
+ * Supports merge mode to add exclusions to existing .gitignore
+ */
+async function scaffoldGitignore(targetDir, options, result) {
+    const gitignorePath = path.join(targetDir, GITIGNORE_FILE_NAME);
+    const fileMode = getFileMode(options);
+    if (fileMode === 'merge' && fs.existsSync(gitignorePath)) {
+        // Merge mode: append LumenFlow exclusions if not already present
+        const existingContent = fs.readFileSync(gitignorePath, 'utf-8');
+        const linesToAdd = [];
+        // Check each required exclusion
+        const requiredExclusions = [
+            { pattern: 'node_modules', line: 'node_modules/' },
+            { pattern: '.lumenflow/state', line: '.lumenflow/state/' },
+            { pattern: 'worktrees', line: 'worktrees/' },
+        ];
+        for (const { pattern, line } of requiredExclusions) {
+            if (!existingContent.includes(pattern)) {
+                linesToAdd.push(line);
+            }
+        }
+        if (linesToAdd.length > 0) {
+            const separator = existingContent.endsWith('\n') ? '' : '\n';
+            const lumenflowBlock = `${separator}
+# LumenFlow (auto-added)
+${linesToAdd.join('\n')}
+`;
+            fs.writeFileSync(gitignorePath, existingContent + lumenflowBlock);
+            result.merged?.push(GITIGNORE_FILE_NAME);
+        }
+        else {
+            result.skipped.push(GITIGNORE_FILE_NAME);
+        }
+        return;
+    }
+    // Skip or force mode
+    await createFile(gitignorePath, GITIGNORE_TEMPLATE, fileMode, result, targetDir);
+}
 /**
  * WU-1307: LumenFlow scripts to inject into package.json
+ * WU-1342: Expanded to include all 17 essential commands
  * Uses standalone binaries (wu-claim, wu-done, gates) that work in consumer projects
  * after installing @lumenflow/cli.
  */
 const LUMENFLOW_SCRIPTS = {
+    // Core WU lifecycle
     'wu:claim': 'wu-claim',
     'wu:done': 'wu-done',
     'wu:create': 'wu-create',
     'wu:status': 'wu-status',
     'wu:block': 'wu-block',
     'wu:unblock': 'wu-unblock',
+    // WU-1342: Additional critical commands
+    'wu:prep': 'wu-prep',
+    'wu:recover': 'wu-recover',
+    'wu:spawn': 'wu-spawn',
+    'wu:validate': 'wu-validate',
+    'wu:infer-lane': 'wu-infer-lane',
+    // Memory commands
+    'mem:init': 'mem-init',
+    'mem:checkpoint': 'mem-checkpoint',
+    'mem:inbox': 'mem-inbox',
+    // Lane commands
+    'lane:suggest': 'lane-suggest',
+    // Gates
     gates: 'gates',
     'gates:docs': 'gates --docs-only',
 };

package/dist/orchestrate-init-status.js

@@ -1,4 +1,5 @@
 #!/usr/bin/env node
+/* eslint-disable no-console -- CLI tool requires console output */
 /**
  * Orchestrate Initiative Status CLI
  *
@@ -10,10 +11,14 @@
  */
 import { Command } from 'commander';
 import { existsSync, readdirSync } from 'node:fs';
-import { loadInitiativeWUs, calculateProgress, formatProgress } from '@lumenflow/initiatives';
+import { loadInitiativeWUs, calculateProgress, formatProgress, getLaneAvailability, resolveLaneConfigsFromConfig, } from '@lumenflow/initiatives';
 import { EXIT_CODES, LUMENFLOW_PATHS } from '@lumenflow/core/dist/wu-constants.js';
+import { getConfig } from '@lumenflow/core/dist/lumenflow-config.js';
 import chalk from 'chalk';
 const LOG_PREFIX = '[orchestrate:init-status]';
+function getErrorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
 function getCompletedWUs(wuIds) {
     const completed = new Set();
     if (!existsSync(LUMENFLOW_PATHS.STAMPS_DIR)) {
@@ -27,6 +32,21 @@ function getCompletedWUs(wuIds) {
     }
     return completed;
 }
+function formatLaneAvailability(availability, laneConfigs) {
+    const lanes = Object.keys(availability).sort((a, b) => a.localeCompare(b));
+    if (lanes.length === 0) {
+        return '  (no lanes found)';
+    }
+    return lanes
+        .map((lane) => {
+        const entry = availability[lane];
+        const wipLimit = laneConfigs[lane]?.wip_limit ?? 1;
+        const statusLabel = entry.available ? chalk.green('available') : chalk.red('occupied');
+        const occupiedBy = entry.occupiedBy ?? 'none';
+        return `  ${lane}: ${statusLabel} (wip_limit=${wipLimit}, lock_policy=${entry.policy}, in_progress=${entry.inProgressCount}, blocked=${entry.blockedCount}, occupied_by=${occupiedBy})`;
+    })
+        .join('\n');
+}
 const program = new Command()
     .name('orchestrate:init-status')
     .description('Show initiative progress status')
@@ -45,18 +65,26 @@ const program = new Command()
         const completed = getCompletedWUs(wus.map((w) => w.id));
         console.log(chalk.bold('WUs:'));
         for (const wu of wus) {
-            const status = completed.has(wu.id)
-                ? chalk.green('✓ done')
-                : wu.doc.status === 'in_progress'
-                    ? chalk.yellow('⟳ in_progress')
-                    : wu.doc.status === 'blocked'
-                        ? chalk.red('⛔ blocked')
-                        : chalk.gray('○ ready');
+            let status = chalk.gray('○ ready');
+            if (completed.has(wu.id)) {
+                status = chalk.green('✓ done');
+            }
+            else if (wu.doc.status === 'in_progress') {
+                status = chalk.yellow('⟳ in_progress');
+            }
+            else if (wu.doc.status === 'blocked') {
+                status = chalk.red('⛔ blocked');
+            }
             console.log(`  ${wu.id}: ${wu.doc.title} [${status}]`);
         }
+        const laneConfigs = resolveLaneConfigsFromConfig(getConfig());
+        const availability = getLaneAvailability(wus, { laneConfigs });
+        console.log('');
+        console.log(chalk.bold('Lane Availability:'));
+        console.log(formatLaneAvailability(availability, laneConfigs));
     }
     catch (err) {
-        console.error(chalk.red(`${LOG_PREFIX} Error: ${err.message}`));
+        console.error(chalk.red(`${LOG_PREFIX} Error: ${getErrorMessage(err)}`));
         process.exit(EXIT_CODES.ERROR);
     }
 });

package/dist/orchestrate-initiative.js

@@ -1,4 +1,5 @@
 #!/usr/bin/env node
+/* eslint-disable no-console -- CLI tool requires console output */
 /**
  * Orchestrate Initiative CLI
  *
@@ -11,8 +12,12 @@
  */
 import { Command } from 'commander';
 import chalk from 'chalk';
-import { loadInitiativeWUs, loadMultipleInitiatives, buildExecutionPlanAsync, formatExecutionPlan, formatExecutionPlanWithEmbeddedSpawns, calculateProgress, formatProgress, buildCheckpointWave, formatCheckpointOutput, validateCheckpointFlags, resolveCheckpointModeAsync, LOG_PREFIX, } from '@lumenflow/initiatives';
+import { loadInitiativeWUs, loadMultipleInitiatives, buildExecutionPlanWithLockPolicy, resolveLaneConfigsFromConfig, formatExecutionPlan, formatExecutionPlanWithEmbeddedSpawns, calculateProgress, formatProgress, buildCheckpointWave, formatCheckpointOutput, validateCheckpointFlags, resolveCheckpointModeAsync, LOG_PREFIX, } from '@lumenflow/initiatives';
 import { EXIT_CODES } from '@lumenflow/core/dist/wu-constants.js';
+import { getConfig } from '@lumenflow/core/dist/lumenflow-config.js';
+function getErrorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
 const program = new Command()
     .name('orchestrate-initiative')
     .description('Orchestrate initiative execution with parallel agent spawning')
@@ -28,7 +33,7 @@ const program = new Command()
         validateCheckpointFlags({ checkpointPerWave, dryRun, noCheckpoint });
     }
     catch (error) {
-        console.error(chalk.red(`${LOG_PREFIX} Error: ${error.message}`));
+        console.error(chalk.red(`${LOG_PREFIX} Error: ${getErrorMessage(error)}`));
         process.exit(EXIT_CODES.ERROR);
     }
     if (!initIds || initIds.length === 0) {
@@ -76,7 +81,8 @@ const program = new Command()
             return;
         }
         console.log(chalk.cyan(`${LOG_PREFIX} Building execution plan...`));
-        const plan = await buildExecutionPlanAsync(wus);
+        const laneConfigs = resolveLaneConfigsFromConfig(getConfig());
+        const plan = buildExecutionPlanWithLockPolicy(wus, { laneConfigs });
         if (plan.waves.length === 0) {
             console.log(chalk.green(`${LOG_PREFIX} All WUs are complete! Nothing to execute.`));
             return;
@@ -99,7 +105,7 @@ const program = new Command()
         console.log(chalk.cyan('Copy the spawn XML above to execute agents.'));
     }
     catch (error) {
-        console.error(chalk.red(`${LOG_PREFIX} Error: ${error.message}`));
+        console.error(chalk.red(`${LOG_PREFIX} Error: ${getErrorMessage(error)}`));
         process.exit(EXIT_CODES.ERROR);
     }
 });

package/dist/sync-templates.js

@@ -8,9 +8,16 @@
  * - Claude skills -> templates/vendors/claude/.claude/skills/
  * - Core docs (LUMENFLOW.md, constraints.md) -> templates/core/
  */
+/* eslint-disable no-console -- CLI tool requires console output */
+/* eslint-disable security/detect-non-literal-fs-filename -- CLI tool syncs templates from known paths */
+/* eslint-disable security/detect-non-literal-regexp -- Dynamic date pattern for template substitution */
 import * as fs from 'node:fs';
 import * as path from 'node:path';
 import { createWUParser } from '@lumenflow/core';
+// Directory name constants to avoid duplicate strings
+const LUMENFLOW_DIR = '.lumenflow';
+const CLAUDE_DIR = '.claude';
+const SKILLS_DIR = 'skills';
 // Template variable patterns
 const DATE_PATTERN = /\d{4}-\d{2}-\d{2}/g;
 /**
@@ -29,6 +36,12 @@ const SYNC_TEMPLATES_OPTIONS = {
         description: 'Show detailed output',
         default: false,
     },
+    checkDrift: {
+        name: 'check-drift',
+        flags: '--check-drift',
+        description: 'Check for template drift without syncing (CI mode)',
+        default: false,
+    },
 };
 /**
  * Parse sync-templates command options
@@ -42,6 +55,7 @@ export function parseSyncTemplatesOptions() {
     return {
         dryRun: opts['dry-run'] ?? false,
         verbose: opts.verbose ?? false,
+        checkDrift: opts['check-drift'] ?? false,
     };
 }
 /**
@@ -119,8 +133,8 @@ export async function syncOnboardingDocs(projectRoot, dryRun = false) {
  */
 export async function syncSkillsToTemplates(projectRoot, dryRun = false) {
     const result = { synced: [], errors: [] };
-    const sourceDir = path.join(projectRoot, '.claude', 'skills');
-    const targetDir = path.join(getTemplatesDir(projectRoot), 'vendors', 'claude', '.claude', 'skills');
+    const sourceDir = path.join(projectRoot, CLAUDE_DIR, SKILLS_DIR);
+    const targetDir = path.join(getTemplatesDir(projectRoot), 'vendors', 'claude', CLAUDE_DIR, SKILLS_DIR);
     if (!fs.existsSync(sourceDir)) {
         result.errors.push(`Skills source directory not found: ${sourceDir}`);
         return result;
@@ -153,8 +167,8 @@ export async function syncCoreDocs(projectRoot, dryRun = false) {
     const lumenflowTarget = path.join(templatesDir, 'core', 'LUMENFLOW.md.template');
     syncFile(lumenflowSource, lumenflowTarget, projectRoot, result, dryRun);
     // Sync constraints.md
-    const constraintsSource = path.join(projectRoot, '.lumenflow', 'constraints.md');
-    const constraintsTarget = path.join(templatesDir, 'core', '.lumenflow', 'constraints.md.template');
+    const constraintsSource = path.join(projectRoot, LUMENFLOW_DIR, 'constraints.md');
+    const constraintsTarget = path.join(templatesDir, 'core', LUMENFLOW_DIR, 'constraints.md.template');
     syncFile(constraintsSource, constraintsTarget, projectRoot, result, dryRun);
     return result;
 }
@@ -167,12 +181,130 @@ export async function syncTemplates(projectRoot, dryRun = false) {
     const core = await syncCoreDocs(projectRoot, dryRun);
     return { onboarding, skills, core };
 }
+/**
+ * Compare source file content with template content (ignoring date placeholders)
+ */
+function compareContent(sourceContent, templateContent, projectRoot) {
+    // Convert source to template format for comparison
+    const convertedSource = convertToTemplate(sourceContent, projectRoot);
+    return convertedSource === templateContent;
+}
+/**
+ * Check if a single template file is in sync with its source
+ */
+function checkFileDrift(sourcePath, templatePath, projectRoot) {
+    const relativePath = path.relative(projectRoot, templatePath);
+    if (!fs.existsSync(sourcePath)) {
+        return { isDrifting: false, relativePath }; // Source doesn't exist, can't drift
+    }
+    if (!fs.existsSync(templatePath)) {
+        return { isDrifting: true, relativePath }; // Template missing, definitely drifting
+    }
+    const sourceContent = fs.readFileSync(sourcePath, 'utf-8');
+    const templateContent = fs.readFileSync(templatePath, 'utf-8');
+    const isDrifting = !compareContent(sourceContent, templateContent, projectRoot);
+    return { isDrifting, relativePath };
+}
+/**
+ * Check for template drift - compares source docs with templates (WU-1353)
+ *
+ * This function compares source documents with their template counterparts
+ * to detect if templates have drifted out of sync. Used by CI to warn
+ * when templates need to be re-synced.
+ */
+// eslint-disable-next-line sonarjs/cognitive-complexity -- Multi-category drift check requires nested iteration
+export async function checkTemplateDrift(projectRoot) {
+    const driftingFiles = [];
+    const checkedFiles = [];
+    const templatesDir = getTemplatesDir(projectRoot);
+    // Check core docs
+    const coreChecks = [
+        {
+            source: path.join(projectRoot, 'LUMENFLOW.md'),
+            template: path.join(templatesDir, 'core', 'LUMENFLOW.md.template'),
+        },
+        {
+            source: path.join(projectRoot, LUMENFLOW_DIR, 'constraints.md'),
+            template: path.join(templatesDir, 'core', LUMENFLOW_DIR, 'constraints.md.template'),
+        },
+    ];
+    for (const check of coreChecks) {
+        const result = checkFileDrift(check.source, check.template, projectRoot);
+        checkedFiles.push(result.relativePath);
+        if (result.isDrifting) {
+            driftingFiles.push(result.relativePath);
+        }
+    }
+    // Check onboarding docs
+    const onboardingSourceDir = path.join(projectRoot, 'docs', '04-operations', '_frameworks', 'lumenflow', 'agent', 'onboarding');
+    const onboardingTargetDir = path.join(templatesDir, 'core', 'ai', 'onboarding');
+    if (fs.existsSync(onboardingSourceDir)) {
+        const files = fs.readdirSync(onboardingSourceDir).filter((f) => f.endsWith('.md'));
+        for (const file of files) {
+            const sourcePath = path.join(onboardingSourceDir, file);
+            const templatePath = path.join(onboardingTargetDir, `${file}.template`);
+            const result = checkFileDrift(sourcePath, templatePath, projectRoot);
+            checkedFiles.push(result.relativePath);
+            if (result.isDrifting) {
+                driftingFiles.push(result.relativePath);
+            }
+        }
+    }
+    // Check skills
+    const skillsSourceDir = path.join(projectRoot, CLAUDE_DIR, SKILLS_DIR);
+    const skillsTargetDir = path.join(templatesDir, 'vendors', 'claude', CLAUDE_DIR, SKILLS_DIR);
+    if (fs.existsSync(skillsSourceDir)) {
+        const skillDirs = fs
+            .readdirSync(skillsSourceDir, { withFileTypes: true })
+            .filter((d) => d.isDirectory())
+            .map((d) => d.name);
+        for (const skillName of skillDirs) {
+            const skillFile = path.join(skillsSourceDir, skillName, 'SKILL.md');
+            const templatePath = path.join(skillsTargetDir, skillName, 'SKILL.md.template');
+            if (fs.existsSync(skillFile)) {
+                const result = checkFileDrift(skillFile, templatePath, projectRoot);
+                checkedFiles.push(result.relativePath);
+                if (result.isDrifting) {
+                    driftingFiles.push(result.relativePath);
+                }
+            }
+        }
+    }
+    return {
+        hasDrift: driftingFiles.length > 0,
+        driftingFiles,
+        checkedFiles,
+    };
+}
 /**
  * CLI entry point
  */
+// eslint-disable-next-line sonarjs/cognitive-complexity -- CLI main() handles multiple modes and output formatting
 export async function main() {
     const opts = parseSyncTemplatesOptions();
     const projectRoot = process.cwd();
+    // Check-drift mode: verify templates match source without syncing
+    if (opts.checkDrift) {
+        console.log('[sync-templates] Checking for template drift...');
+        const drift = await checkTemplateDrift(projectRoot);
+        if (opts.verbose) {
+            console.log(`  Checked ${drift.checkedFiles.length} files`);
+        }
+        if (drift.hasDrift) {
+            console.log('\n[sync-templates] WARNING: Template drift detected!');
+            console.log('  The following templates are out of sync with their source:');
+            for (const file of drift.driftingFiles) {
+                console.log(`    - ${file}`);
+            }
+            console.log('\n  Run `pnpm sync:templates` to update templates.');
+            process.exitCode = 1;
+        }
+        else {
+            console.log('[sync-templates] All templates are in sync.');
+        }
+        return;
+    }
+    // Sync mode: update templates from source
     console.log('[sync-templates] Syncing internal docs to CLI templates...');
     if (opts.dryRun) {
         console.log('  (dry-run mode - no files will be written)');
@@ -208,5 +340,5 @@ export async function main() {
 // CLI entry point
 import { runCLI } from './cli-entry-point.js';
 if (import.meta.main) {
-    runCLI(main);
+    void runCLI(main);
 }