@lumenflow/cli 2.4.0 → 2.5.1

package/dist/plan-promote.js

@@ -0,0 +1,231 @@
+#!/usr/bin/env node
+/* eslint-disable no-console -- CLI tool requires console output */
+/* eslint-disable security/detect-non-literal-fs-filename */
+/**
+ * Plan Promote Command (WU-1313)
+ *
+ * Promotes a plan from draft to approved status.
+ * Validates that required sections are complete before approving.
+ *
+ * Usage:
+ *   pnpm plan:promote --id WU-1313
+ *   pnpm plan:promote --id INIT-001 --force  # Skip validation
+ *
+ * Features:
+ * - Validates plan completeness (non-empty required sections)
+ * - Adds approved status and timestamp
+ * - Uses micro-worktree isolation for atomic commits
+ * - Idempotent: no error if already approved
+ *
+ * Context: WU-1313 (INIT-013 Plan Tooling)
+ */
+import { getGitForCwd } from '@lumenflow/core/dist/git-adapter.js';
+import { die } from '@lumenflow/core/dist/error-handler.js';
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { createWUParser, WU_OPTIONS } from '@lumenflow/core/dist/arg-parser.js';
+import { ensureOnMain } from '@lumenflow/core/dist/wu-helpers.js';
+import { withMicroWorktree } from '@lumenflow/core/dist/micro-worktree.js';
+import { WU_PATHS } from '@lumenflow/core/dist/wu-paths.js';
+import { todayISO } from '@lumenflow/core/dist/date-utils.js';
+import { LOG_PREFIX as CORE_LOG_PREFIX } from '@lumenflow/core/dist/wu-constants.js';
+/** Log prefix for console output */
+export const LOG_PREFIX = CORE_LOG_PREFIX.PLAN_PROMOTE ?? '[plan:promote]';
+/** Micro-worktree operation name */
+const OPERATION_NAME = 'plan-promote';
+/** WU ID pattern */
+const WU_ID_PATTERN = /^WU-\d+$/;
+/** Initiative ID pattern */
+const INIT_ID_PATTERN = /^INIT-[A-Z0-9]+$/i;
+/** Required sections that must have content */
+const REQUIRED_SECTIONS = ['Goal', 'Scope', 'Approach'];
+/** Status marker patterns */
+const STATUS_APPROVED_PATTERN = /^Status:\s*approved/im;
+/**
+ * Get the path to a plan file from its ID
+ *
+ * @param id - WU or Initiative ID
+ * @returns Path to plan file
+ * @throws Error if plan not found
+ */
+export function getPlanPath(id) {
+    const plansDir = WU_PATHS.PLANS_DIR();
+    const planPath = join(plansDir, `${id}-plan.md`);
+    if (!existsSync(planPath)) {
+        die(`Plan not found for ${id}\n\n` +
+            `Expected path: ${planPath}\n\n` +
+            `Create it first with: pnpm plan:create --id ${id} --title "Title"`);
+    }
+    return planPath;
+}
+/**
+ * Validate that a plan has all required sections with content
+ *
+ * @param planPath - Path to plan file
+ * @returns Validation result with valid flag and errors array
+ */
+export function validatePlanComplete(planPath) {
+    if (!existsSync(planPath)) {
+        return { valid: false, errors: ['Plan file not found'] };
+    }
+    const text = readFileSync(planPath, { encoding: 'utf-8' });
+    const errors = [];
+    for (const section of REQUIRED_SECTIONS) {
+        const sectionHeading = `## ${section}`;
+        const headingIndex = text.indexOf(sectionHeading);
+        if (headingIndex === -1) {
+            errors.push(`Missing required section: ${section}`);
+            continue;
+        }
+        // Find the content between this heading and the next
+        const afterHeading = text.substring(headingIndex + sectionHeading.length);
+        const nextHeadingIndex = afterHeading.indexOf('\n## ');
+        const sectionContent = nextHeadingIndex >= 0 ? afterHeading.substring(0, nextHeadingIndex) : afterHeading;
+        // Check if content is just whitespace, empty, or only comments
+        const trimmedContent = sectionContent
+            .split('\n')
+            .filter((line) => !line.trim().startsWith('<!--') && line.trim() !== '-->')
+            .join('\n')
+            .trim();
+        if (trimmedContent === '' || trimmedContent.length < 10) {
+            errors.push(`${section} section is empty or too short`);
+        }
+    }
+    return {
+        valid: errors.length === 0,
+        errors,
+    };
+}
+/**
+ * Promote a plan to approved status
+ *
+ * Adds Status: approved and Approved: date after the Created line.
+ *
+ * @param planPath - Path to plan file
+ * @returns True if changes were made, false if already approved
+ */
+export function promotePlan(planPath) {
+    if (!existsSync(planPath)) {
+        die(`Plan file not found: ${planPath}`);
+    }
+    const text = readFileSync(planPath, { encoding: 'utf-8' });
+    // Check if already approved
+    if (STATUS_APPROVED_PATTERN.test(text)) {
+        console.log(`${LOG_PREFIX} Plan already approved (idempotent)`);
+        return false;
+    }
+    // Find the Created: line and insert status after it
+    // Use specific pattern to avoid backtracking (sonarjs/slow-regex)
+    const createdPattern = /^Created:\s*\S.*$/m;
+    const createdMatch = createdPattern.exec(text);
+    const today = todayISO();
+    const statusLines = `Status: approved\nApproved: ${today}`;
+    let newText;
+    if (createdMatch && createdMatch.index !== undefined) {
+        // Insert after Created: line
+        const insertPos = createdMatch.index + createdMatch[0].length;
+        newText = text.substring(0, insertPos) + '\n' + statusLines + text.substring(insertPos);
+    }
+    else {
+        // No Created: line found, insert after first heading
+        const firstHeadingPattern = /^# .+$/m;
+        const firstHeadingMatch = firstHeadingPattern.exec(text);
+        if (firstHeadingMatch && firstHeadingMatch.index !== undefined) {
+            const insertPos = firstHeadingMatch.index + firstHeadingMatch[0].length;
+            newText =
+                text.substring(0, insertPos) + '\n\n' + statusLines + '\n' + text.substring(insertPos);
+        }
+        else {
+            // Fallback: prepend to file
+            newText = statusLines + '\n\n' + text;
+        }
+    }
+    writeFileSync(planPath, newText, { encoding: 'utf-8' });
+    console.log(`${LOG_PREFIX} Plan promoted to approved status`);
+    return true;
+}
+/**
+ * Generate commit message for plan promote operation
+ *
+ * @param id - WU or Initiative ID
+ * @returns Commit message
+ */
+export function getCommitMessage(id) {
+    const idLower = id.toLowerCase();
+    return `docs: promote ${idLower} plan to approved`;
+}
+async function main() {
+    const FORCE_OPTION = {
+        name: 'force',
+        flags: '-f, --force',
+        description: 'Skip validation and promote anyway',
+    };
+    const args = createWUParser({
+        name: 'plan-promote',
+        description: 'Promote a plan to approved status',
+        options: [WU_OPTIONS.id, FORCE_OPTION],
+        required: ['id'],
+        allowPositionalId: true,
+    });
+    const id = args.id;
+    const force = args.force;
+    // Validate ID format
+    if (!WU_ID_PATTERN.test(id) && !INIT_ID_PATTERN.test(id)) {
+        die(`Invalid ID format: "${id}"\n\n` + `Expected format: WU-XXX or INIT-XXX`);
+    }
+    console.log(`${LOG_PREFIX} Promoting plan for ${id}...`);
+    // Ensure on main for micro-worktree operations
+    await ensureOnMain(getGitForCwd());
+    try {
+        await withMicroWorktree({
+            operation: OPERATION_NAME,
+            id,
+            logPrefix: LOG_PREFIX,
+            pushOnly: true,
+            execute: async ({ worktreePath }) => {
+                const planRelPath = join(WU_PATHS.PLANS_DIR(), `${id}-plan.md`);
+                const planAbsPath = join(worktreePath, planRelPath);
+                if (!existsSync(planAbsPath)) {
+                    die(`Plan not found for ${id}\n\n` +
+                        `Expected path: ${planRelPath}\n\n` +
+                        `Create it first with: pnpm plan:create --id ${id} --title "Title"`);
+                }
+                // Validate plan completeness (unless force)
+                if (!force) {
+                    const validation = validatePlanComplete(planAbsPath);
+                    if (!validation.valid) {
+                        const errorList = validation.errors.map((e) => `  - ${e}`).join('\n');
+                        die(`Plan validation failed:\n\n${errorList}\n\n` +
+                            `Fix these issues or use --force to skip validation.`);
+                    }
+                    console.log(`${LOG_PREFIX} Plan validation passed`);
+                }
+                // Promote the plan
+                const changed = promotePlan(planAbsPath);
+                if (!changed) {
+                    console.log(`${LOG_PREFIX} No changes needed (already approved)`);
+                }
+                return {
+                    commitMessage: getCommitMessage(id),
+                    files: [planRelPath],
+                };
+            },
+        });
+        console.log(`\n${LOG_PREFIX} Plan promoted successfully!`);
+        console.log(`\nPromotion Details:`);
+        console.log(`  ID:     ${id}`);
+        console.log(`  Status: approved`);
+    }
+    catch (error) {
+        die(`Plan promotion failed: ${error.message}\n\n` +
+            `Micro-worktree cleanup was attempted automatically.\n` +
+            `If issue persists, check for orphaned branches: git branch | grep tmp/${OPERATION_NAME}`);
+    }
+}
+// Guard main() for testability
+import { runCLI } from './cli-entry-point.js';
+if (import.meta.main) {
+    void runCLI(main);
+}
+// Export for testing
+export { main };

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);
 }

package/dist/wu-block.js

@@ -1,4 +1,5 @@
 #!/usr/bin/env node
+/* eslint-disable no-console -- CLI tool requires console output */
 /**
  * WU Block Helper
  *
@@ -32,6 +33,8 @@ import { withMicroWorktree } from '@lumenflow/core/dist/micro-worktree.js';
 import { WUStateStore } from '@lumenflow/core/dist/wu-state-store.js';
 // WU-1603: Atomic lane locking - release lock when WU is blocked
 import { releaseLaneLock } from '@lumenflow/core/dist/lane-lock.js';
+// WU-1325: Import lock policy getter to determine release behavior
+import { getLockPolicyForLane } from '@lumenflow/core/dist/lane-checker.js';
 // ensureOnMain() moved to wu-helpers.ts (WU-1256)
 // ensureStaged() moved to git-staged-validator.ts (WU-1341)
 // defaultWorktreeFrom() moved to wu-paths.ts (WU-1341)
@@ -215,15 +218,23 @@ async function main() {
         await getGitForCwd().push(REMOTES.ORIGIN, BRANCHES.MAIN);
     }
     await handleWorktreeRemoval(args, doc);
-    // WU-1603: Release lane lock when WU is blocked
-    // This allows another WU to be claimed in the same lane
+    // WU-1325: Release lane lock when WU is blocked (only for lock_policy=active)
+    // For policy=all, lock is held through block/unblock cycle
+    // For policy=none, no lock exists to release
     try {
         const lane = doc.lane;
         if (lane) {
-            const releaseResult = releaseLaneLock(lane, { wuId: id });
-            if (releaseResult.released && !releaseResult.notFound) {
-                console.log(`${LOG_PREFIX.BLOCK} Lane lock released for "${lane}"`);
+            const lockPolicy = getLockPolicyForLane(lane);
+            if (lockPolicy === 'active') {
+                const releaseResult = releaseLaneLock(lane, { wuId: id });
+                if (releaseResult.released && !releaseResult.notFound) {
+                    console.log(`${LOG_PREFIX.BLOCK} Lane lock released for "${lane}" (lock_policy=active)`);
+                }
             }
+            else if (lockPolicy === 'all') {
+                console.log(`${LOG_PREFIX.BLOCK} Lane lock retained for "${lane}" (lock_policy=all)`);
+            }
+            // For policy=none, no lock exists - nothing to do
         }
     }
     catch (err) {

package/dist/wu-claim.js

@@ -67,9 +67,13 @@ async function ensureCleanOrClaimOnlyWhenNoAuto() {
         .split(STRING_LITERALS.NEWLINE)
         .filter(Boolean)
         .filter((l) => l.startsWith('A ') || l.startsWith('M ') || l.startsWith('R '));
-    const hasClaimFiles = staged.some((l) => l.includes('docs/04-operations/tasks/status.md') ||
-        l.includes('docs/04-operations/tasks/backlog.md') ||
-        /docs\/04-operations\/tasks\/wu\/WU-\d+\.yaml/.test(l));
+    // WU-1311: Use config-based paths instead of hardcoded docs/04-operations paths
+    const config = getConfig();
+    const wuDirPattern = config.directories.wuDir.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    const wuYamlRegex = new RegExp(`${wuDirPattern}/WU-\\d+\\.yaml`);
+    const hasClaimFiles = staged.some((l) => l.includes(config.directories.statusPath) ||
+        l.includes(config.directories.backlogPath) ||
+        wuYamlRegex.test(l));
     if (!hasClaimFiles) {
         console.error(status);
         die('Stage claim-related files (status/backlog/WU YAML) before running with --no-auto.');
@@ -400,12 +404,12 @@ async function appendClaimEventOnly(stateDir, id, title, lane) {
  * @returns {string[]} List of files to commit
  */
 export function getWorktreeCommitFiles(wuId) {
+    // WU-1311: Use config-based paths instead of hardcoded docs/04-operations paths
+    const config = getConfig();
     return [
-        `docs/04-operations/tasks/wu/${wuId}.yaml`,
+        `${config.directories.wuDir}/${wuId}.yaml`,
         LUMENFLOW_PATHS.WU_EVENTS, // WU-1740: Event store is source of truth
-        // WU-1746: Explicitly NOT including:
-        // - docs/04-operations/tasks/backlog.md
-        // - docs/04-operations/tasks/status.md
+        // WU-1746: Explicitly NOT including backlog.md and status.md
         // These generated files cause merge conflicts when main advances
     ];
 }
@@ -694,7 +698,8 @@ function handleLaneOccupancy(laneCheck, lane, id, force) {
         `  2. Choose a different lane\n` +
         `  3. Increase wip_limit in .lumenflow.config.yaml\n` +
         `  4. Use --force to override (P0 emergencies only)\n\n` +
-        `To check lane status: grep "${STATUS_SECTIONS.IN_PROGRESS}" docs/04-operations/tasks/status.md`);
+        // WU-1311: Use config-based status path
+        `To check lane status: grep "${STATUS_SECTIONS.IN_PROGRESS}" ${getConfig().directories.statusPath}`);
 }
 /**
  * Handle code path overlap detection (WU-901)
@@ -726,13 +731,14 @@ function handleCodePathOverlap(WU_PATH, STATUS_PATH, id, args) {
             return `  - ${c.wuid}: ${displayedOverlaps}${suffix}`;
         })
             .join(STRING_LITERALS.NEWLINE);
+        // WU-1311: Use config-based status path in error message
         die(`Code path overlap detected with in-progress WUs:\n\n${conflictList}\n\n` +
             `Merge conflicts are guaranteed if both WUs proceed.\n\n` +
             `Options:\n` +
             `  1. Wait for conflicting WU(s) to complete\n` +
             `  2. Coordinate with agent working on conflicting WU\n` +
             `  3. Use --force-overlap --reason "..." (emits telemetry for audit)\n\n` +
-            `To check WU status: grep "${STATUS_SECTIONS.IN_PROGRESS}" docs/04-operations/tasks/status.md`);
+            `To check WU status: grep "${STATUS_SECTIONS.IN_PROGRESS}" ${getConfig().directories.statusPath}`);
     }
     if (args.forceOverlap) {
         if (!args.reason) {

package/dist/wu-create.js

@@ -41,6 +41,7 @@ import { inferSubLane } from '@lumenflow/core/dist/lane-inference.js';
 import { parseBacklogFrontmatter } from '@lumenflow/core/dist/backlog-parser.js';
 import { createWUParser, WU_CREATE_OPTIONS, WU_OPTIONS } from '@lumenflow/core/dist/arg-parser.js';
 import { WU_PATHS } from '@lumenflow/core/dist/wu-paths.js';
+import { getConfig } from '@lumenflow/core/dist/lumenflow-config.js';
 import { validateWU } from '@lumenflow/core/dist/wu-schema.js';
 import { getPlanPath, getPlanProtocolRef, getPlansDir, } from '@lumenflow/core/dist/lumenflow-home.js';
 import { validateSpecRefs } from '@lumenflow/core/dist/wu-create-validators.js';
@@ -57,6 +58,8 @@ import { validateSpecCompleteness } from '@lumenflow/core/dist/wu-done-validator
 import { readWU } from '@lumenflow/core/dist/wu-yaml.js';
 // WU-2253: Import WU spec linter for acceptance/code_paths validation
 import { lintWUSpec, formatLintErrors } from '@lumenflow/core/dist/wu-lint.js';
+// WU-1329: Import path existence validators for strict mode
+import { validateCodePathsExistence, validateTestPathsExistence, } from '@lumenflow/core/dist/wu-preflight-validators.js';
 // WU-1025: Import placeholder validator for inline content validation
 import { validateNoPlaceholders, buildPlaceholderErrorMessage, } from '@lumenflow/core/dist/wu-validator.js';
 // WU-1211: Import initiative validation for phase check
@@ -247,9 +250,24 @@ function buildWUContent({ id, lane, title, priority, type, created, opts, }) {
         ...(specRefs?.length && { spec_refs: specRefs }),
     };
 }
+/**
+ * Validate WU spec for creation
+ *
+ * WU-1329: Strict mode (default) validates that code_paths and test_paths exist on disk.
+ * Use opts.strict = false to bypass path existence checks.
+ *
+ * @param params - Validation parameters
+ * @returns {{ valid: boolean, errors: string[] }}
+ */
 export function validateCreateSpec({ id, lane, title, priority, type, opts, }) {
     const errors = [];
     const effectiveType = type || DEFAULT_TYPE;
+    // WU-1329: Strict mode is the default
+    const strict = opts.strict !== false;
+    // WU-1329: Log when strict validation is bypassed
+    if (!strict) {
+        console.warn(`${LOG_PREFIX} WARNING: strict validation bypassed (--no-strict). Path existence checks skipped.`);
+    }
     if (!opts.description) {
         errors.push('--description is required');
     }
@@ -269,7 +287,9 @@ export function validateCreateSpec({ id, lane, title, priority, type, opts, }) {
         }
     }
     if (effectiveType === 'feature' && !opts.specRefs) {
-        errors.push('--spec-refs is required for type: feature WUs');
+        errors.push('--spec-refs is required for type: feature WUs\n' +
+            '    Tip: Create a plan first with: pnpm plan:create --id <WU-ID> --title "..."\n' +
+            '    Then use --plan flag or --spec-refs lumenflow://plans/<WU-ID>-plan.md');
     }
     if (errors.length > 0) {
         return { valid: false, errors };
@@ -303,6 +323,29 @@ export function validateCreateSpec({ id, lane, title, priority, type, opts, }) {
     if (!completeness.valid) {
         return { valid: false, errors: completeness.errors };
     }
+    // WU-1329: Strict mode validates path existence
+    if (strict) {
+        const rootDir = process.cwd();
+        // Validate code_paths exist
+        if (opts.codePaths && opts.codePaths.length > 0) {
+            const codePathsResult = validateCodePathsExistence(opts.codePaths, rootDir);
+            if (!codePathsResult.valid) {
+                errors.push(...codePathsResult.errors);
+            }
+        }
+        // Validate test_paths exist (unit, e2e - not manual)
+        const testsObj = {
+            unit: opts.testPathsUnit || [],
+            e2e: opts.testPathsE2e || [],
+        };
+        const testPathsResult = validateTestPathsExistence(testsObj, rootDir);
+        if (!testPathsResult.valid) {
+            errors.push(...testPathsResult.errors);
+        }
+        if (errors.length > 0) {
+            return { valid: false, errors };
+        }
+    }
     return { valid: true, errors: [] };
 }
 /**
@@ -382,9 +425,10 @@ function updateBacklogInWorktree(worktreePath, id, lane, title) {
     const backlogRelativePath = WU_PATHS.BACKLOG();
     const backlogAbsolutePath = join(worktreePath, backlogRelativePath);
     if (!existsSync(backlogAbsolutePath)) {
+        // WU-1311: Use config-based backlog path in error message
         die(`Backlog not found in micro-worktree: ${backlogAbsolutePath}\n\n` +
             `Options:\n` +
-            `  1. Ensure backlog.md exists at docs/04-operations/tasks/backlog.md\n` +
+            `  1. Ensure backlog.md exists at ${getConfig().directories.backlogPath}\n` +
             `  2. Run from repository root directory`);
     }
     const { frontmatter, markdown } = parseBacklogFrontmatter(backlogAbsolutePath);
@@ -482,6 +526,8 @@ async function main() {
             WU_OPTIONS.uiPairingWus,
             // WU-1062: External plan options for wu:create
             WU_CREATE_OPTIONS.plan,
+            // WU-1329: Strict validation is default, --no-strict bypasses
+            WU_OPTIONS.noStrict,
         ],
         required: ['lane', 'title'], // WU-1246: --id is now optional (auto-generated if not provided)
         allowPositionalId: false,
@@ -558,6 +604,8 @@ async function main() {
             blocks: args.blocks,
             labels: args.labels,
             assignedTo,
+            // WU-1329: Strict validation is default, --no-strict bypasses
+            strict: !args.noStrict,
         },
     });
     if (!createSpecValidation.valid) {

package/dist/wu-deps.js

@@ -15,6 +15,7 @@ import { die } from '@lumenflow/core/dist/error-handler.js';
 import { buildDependencyGraphAsync, renderASCII, renderMermaid, validateGraph, } from '@lumenflow/core/dist/dependency-graph.js';
 import { OUTPUT_FORMATS } from '@lumenflow/initiatives/dist/initiative-constants.js';
 import { PATTERNS } from '@lumenflow/core/dist/wu-constants.js';
+import { getConfig } from '@lumenflow/core/dist/lumenflow-config.js';
 async function main() {
     const args = createWUParser({
         name: 'wu-deps',
@@ -33,7 +34,8 @@ async function main() {
     console.log(`[wu:deps] Building dependency graph...`);
     const graph = await buildDependencyGraphAsync();
     if (!graph.has(wuId)) {
-        die(`WU not found in graph: ${wuId}\n\nEnsure the WU exists in docs/04-operations/tasks/wu/`);
+        // WU-1311: Use config-based WU directory path
+        die(`WU not found in graph: ${wuId}\n\nEnsure the WU exists in ${getConfig().directories.wuDir}/`);
     }
     const format = args.format || OUTPUT_FORMATS.ASCII;
     const depth = args.depth ? parseInt(args.depth, 10) : 3;