@lumenflow/cli 2.4.0 → 2.5.0

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;

package/dist/wu-done.js

@@ -65,6 +65,7 @@ CONTEXT_VALIDATION, } from '@lumenflow/core/dist/wu-constants.js';
 import { printGateFailureBox, printStatusPreview } from '@lumenflow/core/dist/wu-done-ui.js';
 import { ensureOnMain } from '@lumenflow/core/dist/wu-helpers.js';
 import { WU_PATHS } from '@lumenflow/core/dist/wu-paths.js';
+import { getConfig } from '@lumenflow/core/dist/lumenflow-config.js';
 import { writeWU, appendNote, parseYAML } from '@lumenflow/core/dist/wu-yaml.js';
 import { PLACEHOLDER_SENTINEL, validateWU, validateDoneWU, validateApprovalGates, } from '@lumenflow/core/dist/wu-schema.js';
 import { validateBacklogSync } from '@lumenflow/core/dist/backlog-sync-validator.js';
@@ -969,11 +970,14 @@ async function runGatesInWorktree(worktreePath, id, options = {}) {
 }
 async function validateStagedFiles(id, isDocsOnly = false) {
     const staged = await listStaged();
+    // WU-1311: Use config-based paths instead of hardcoded docs/04-operations paths
+    const config = getConfig();
+    const wuPath = `${config.directories.wuDir}/${id}.yaml`;
     // WU-1740: Include wu-events.jsonl to persist state store events
     const whitelist = [
-        `docs/04-operations/tasks/wu/${id}.yaml`,
-        'docs/04-operations/tasks/status.md',
-        'docs/04-operations/tasks/backlog.md',
+        wuPath,
+        config.directories.statusPath,
+        config.directories.backlogPath,
         WU_EVENTS_PATH,
     ];
     if (isDocsOnly) {
@@ -998,7 +1002,10 @@ async function validateStagedFiles(id, isDocsOnly = false) {
         return true;
     });
     if (unexpected.length > 0) {
-        const otherWuYamlOnly = unexpected.every((f) => /^docs\/04-operations\/tasks\/wu\/WU-\d+\.yaml$/.test(f));
+        // WU-1311: Use config-based pattern for WU YAML detection
+        const wuDirPattern = config.directories.wuDir.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+        const wuYamlRegex = new RegExp(`^${wuDirPattern}/WU-\\d+\\.yaml$`);
+        const otherWuYamlOnly = unexpected.every((f) => wuYamlRegex.test(f));
         if (otherWuYamlOnly) {
             console.warn(`${LOG_PREFIX.DONE} Warning: other WU YAMLs are staged; proceeding and committing only current WU files.`);
         }
@@ -1620,8 +1627,10 @@ async function executePreFlightChecks({ id, args, isBranchOnly, isDocsOnly, docM
     if (!specResult.valid) {
         console.error(`\n❌ Spec completeness validation failed for ${id}:\n`);
         specResult.errors.forEach((err) => console.error(`  - ${err}`));
+        // WU-1311: Use config-based path in error message
+        const specConfig = getConfig();
         console.error(`\nFix these issues before running wu:done:\n` +
-            `  1. Update docs/04-operations/tasks/wu/${id}.yaml\n` +
+            `  1. Update ${specConfig.directories.wuDir}/${id}.yaml\n` +
             `  2. Fill description with Context/Problem/Solution\n` +
             `  3. Replace ${PLACEHOLDER_SENTINEL} text with specific criteria\n` +
             `  4. List all modified files in code_paths\n` +

package/dist/wu-edit.js

@@ -57,6 +57,8 @@ import { readInitiative, writeInitiative } from '@lumenflow/initiatives/dist/ini
 import { normalizeWUSchema } from '@lumenflow/core/dist/wu-schema-normalization.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 validation
+import { validateCodePathsExistence, validateTestPathsExistence, } from '@lumenflow/core/dist/wu-preflight-validators.js';
 /* eslint-disable security/detect-object-injection */
 const PREFIX = LOG_PREFIX.EDIT;
 /**
@@ -377,6 +379,8 @@ function parseArgs() {
             EDIT_OPTIONS.replaceDependencies,
             // WU-1039: Add exposure for done WU metadata updates
             WU_OPTIONS.exposure,
+            // WU-1329: Strict validation is default, --no-strict bypasses
+            WU_OPTIONS.noStrict,
         ],
         required: ['id'],
         allowPositionalId: true,
@@ -921,6 +925,37 @@ async function main() {
     // WU-1750: CRITICAL - Use transformed data for all subsequent operations
     // This ensures embedded newlines are normalized before YAML output
     const normalizedWU = validationResult.data;
+    // WU-1329: Strict validation of path existence (default behavior)
+    // --no-strict bypasses these checks
+    const strict = !opts.noStrict;
+    if (!strict) {
+        console.warn(`${PREFIX} WARNING: strict validation bypassed (--no-strict). Path existence checks skipped.`);
+    }
+    if (strict) {
+        const rootDir = process.cwd();
+        const strictErrors = [];
+        // Validate code_paths exist
+        if (normalizedWU.code_paths && normalizedWU.code_paths.length > 0) {
+            const codePathsResult = validateCodePathsExistence(normalizedWU.code_paths, rootDir);
+            if (!codePathsResult.valid) {
+                strictErrors.push(...codePathsResult.errors);
+            }
+        }
+        // Validate test_paths exist (unit, e2e - not manual)
+        if (normalizedWU.tests) {
+            const testPathsResult = validateTestPathsExistence(normalizedWU.tests, rootDir);
+            if (!testPathsResult.valid) {
+                strictErrors.push(...testPathsResult.errors);
+            }
+        }
+        if (strictErrors.length > 0) {
+            const errorList = strictErrors.map((e) => `  • ${e}`).join('\n');
+            die(`${PREFIX} ❌ Strict validation failed:\n\n${errorList}\n\n` +
+                `Options:\n` +
+                `  1. Fix the paths in the WU spec to match actual files\n` +
+                `  2. Use --no-strict to bypass path existence checks (not recommended)`);
+        }
+    }
     // Validate lane format if present (WU-923: block parent-only lanes with taxonomy)
     if (normalizedWU.lane) {
         validateLaneFormat(normalizedWU.lane);

package/dist/wu-spawn.js

@@ -36,7 +36,9 @@ import { parseYAML } from '@lumenflow/core/dist/wu-yaml.js';
 import { die } from '@lumenflow/core/dist/error-handler.js';
 import { WU_STATUS, PATTERNS, FILE_SYSTEM, EMOJI } from '@lumenflow/core/dist/wu-constants.js';
 // WU-1603: Check lane lock status before spawning
+// WU-1325: Import lock policy getter for lane availability check
 import { checkLaneLock } from '@lumenflow/core/dist/lane-lock.js';
+import { getLockPolicyForLane } from '@lumenflow/core/dist/lane-checker.js';
 import { minimatch } from 'minimatch';
 // WU-2252: Import invariants loader for spawn output injection
 import { loadInvariants, INVARIANT_TYPES } from '@lumenflow/core/dist/invariants-runner.js';
@@ -1146,11 +1148,17 @@ ${SPAWN_END_SENTINEL}
 }
 /**
  * WU-1603: Check if a lane is currently occupied by another WU
+ * WU-1325: Now considers lock_policy - lanes with policy=none are never occupied
  *
  * @param {string} lane - Lane name (e.g., "Operations: Tooling")
  * @returns {import('@lumenflow/core/dist/lane-lock.js').LockMetadata|null} Lock metadata if occupied, null otherwise
  */
 export function checkLaneOccupation(lane) {
+    // WU-1325: Lanes with lock_policy=none never report as occupied
+    const lockPolicy = getLockPolicyForLane(lane);
+    if (lockPolicy === 'none') {
+        return null;
+    }
     const lockStatus = checkLaneLock(lane);
     if (lockStatus.locked && lockStatus.metadata) {
         return lockStatus.metadata;

package/dist/wu-unblock.js

@@ -1,4 +1,5 @@
 #!/usr/bin/env node
+/* eslint-disable no-console -- CLI tool requires console output */
 /**
  * WU Unblock Helper
  *
@@ -16,12 +17,15 @@
 import { existsSync, writeFileSync } from 'node:fs';
 import path from 'node:path';
 import { assertTransition } from '@lumenflow/core/dist/state-machine.js';
-import { checkLaneFree } from '@lumenflow/core/dist/lane-checker.js';
+import { checkLaneFree, getLockPolicyForLane } from '@lumenflow/core/dist/lane-checker.js';
+// WU-1325: Import lane lock functions for policy-based lock acquisition on unblock
+import { acquireLaneLock } from '@lumenflow/core/dist/lane-lock.js';
 import { getGitForCwd } from '@lumenflow/core/dist/git-adapter.js';
 import { die } from '@lumenflow/core/dist/error-handler.js';
 import { todayISO } from '@lumenflow/core/dist/date-utils.js';
 import { createWUParser, WU_OPTIONS } from '@lumenflow/core/dist/arg-parser.js';
 import { WU_PATHS, defaultWorktreeFrom } from '@lumenflow/core/dist/wu-paths.js';
+import { getConfig } from '@lumenflow/core/dist/lumenflow-config.js';
 import { readWU, writeWU, appendNote } from '@lumenflow/core/dist/wu-yaml.js';
 import { STATUS_SECTIONS, PATTERNS, LOG_PREFIX, WU_STATUS, REMOTES, BRANCHES, GIT_REFS, FILE_SYSTEM, EXIT_CODES, MICRO_WORKTREE_OPERATIONS, } from '@lumenflow/core/dist/wu-constants.js';
 import { defaultBranchFrom } from '@lumenflow/core/dist/wu-done-validators.js';
@@ -88,7 +92,8 @@ function handleLaneOccupancy(laneCheck, lane, id, force) {
         `  1. Wait for ${laneCheck.occupiedBy} to complete or block\n` +
         `  2. Move ${id} to a different lane\n` +
         `  3. 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 optional worktree creation after unblock
@@ -221,6 +226,33 @@ async function main() {
         getGitForCwd().run(`git push ${REMOTES.ORIGIN} ${BRANCHES.MAIN}`);
     }
     handleWorktreeCreation(args, doc);
+    // WU-1325: Re-acquire lane lock when WU is unblocked (only for lock_policy=active)
+    // For policy=all, lock was retained through the block cycle
+    // For policy=none, no lock exists to acquire
+    try {
+        if (lane && lane !== 'Unknown') {
+            const lockPolicy = getLockPolicyForLane(lane);
+            if (lockPolicy === 'active') {
+                const lockResult = acquireLaneLock(lane, id);
+                if (lockResult.acquired && !lockResult.skipped) {
+                    console.log(`${PREFIX} Lane lock re-acquired for "${lane}" (lock_policy=active)`);
+                }
+                else if (!lockResult.acquired) {
+                    // Lock acquisition failed - another WU claimed the lane while we were blocked
+                    console.warn(`${PREFIX} Warning: Could not re-acquire lane lock: ${lockResult.error}`);
+                    console.warn(`${PREFIX} Another WU may have claimed lane "${lane}" while this WU was blocked.`);
+                }
+            }
+            else if (lockPolicy === 'all') {
+                console.log(`${PREFIX} Lane lock retained for "${lane}" (lock_policy=all)`);
+            }
+            // For policy=none, no lock exists - nothing to do
+        }
+    }
+    catch (err) {
+        // Non-blocking: lock acquisition failure should not block the unblocking operation
+        console.warn(`${PREFIX} Warning: Could not acquire lane lock: ${err.message}`);
+    }
     console.log(`\n${PREFIX} Marked in progress and pushed.`);
     console.log(`- WU: ${id} — ${title}`);
     if (args.reason)

package/dist/wu-validate.js

@@ -3,13 +3,15 @@
  * WU Validation Tool
  *
  * Validates WU YAML files against schema and checks for quality warnings.
- * Returns exit code 0 if valid (warnings are advisory, not blocking).
- * Returns exit code 1 only for schema errors.
+ *
+ * WU-1329: Strict mode is now the DEFAULT behavior.
+ * - Warnings are treated as errors by default
+ * - Use --no-strict to restore legacy advisory-only warnings behavior
  *
  * Usage:
- *   pnpm wu:validate --id WU-123         # Validate specific WU
- *   pnpm wu:validate --all               # Validate all WUs
- *   pnpm wu:validate --all --strict      # Fail on warnings too
+ *   pnpm wu:validate --id WU-123         # Validate with strict mode (default)
+ *   pnpm wu:validate --all               # Validate all WUs with strict mode
+ *   pnpm wu:validate --all --no-strict   # Warnings are advisory (legacy behavior)
  *
  * @see {@link packages/@lumenflow/cli/src/lib/wu-schema.ts} - Schema definitions
  */
@@ -27,12 +29,14 @@ const LOG_PREFIX = '[wu:validate]';
 /**
  * Validate a single WU file
  *
+ * WU-1329: strict defaults to true (warnings treated as errors)
+ *
  * @param {string} wuPath - Path to WU YAML file
  * @param {object} options - Validation options
- * @param {boolean} options.strict - Treat warnings as errors
+ * @param {boolean} options.strict - Treat warnings as errors (default: true)
  * @returns {{valid: boolean, warnings: string[], errors: string[]}}
  */
-function validateSingleWU(wuPath, { strict = false } = {}) {
+function validateSingleWU(wuPath, { strict = true } = {}) {
     const errors = [];
     const warnings = [];
     // Read and parse YAML
@@ -74,11 +78,13 @@ function validateSingleWU(wuPath, { strict = false } = {}) {
 /**
  * Validate all WU files
  *
+ * WU-1329: strict defaults to true (warnings treated as errors)
+ *
  * @param {object} options - Validation options
- * @param {boolean} options.strict - Treat warnings as errors
+ * @param {boolean} options.strict - Treat warnings as errors (default: true)
  * @returns {{totalValid: number, totalInvalid: number, totalWarnings: number, results: object[]}}
  */
-function validateAllWUs({ strict = false } = {}) {
+function validateAllWUs({ strict = true } = {}) {
     const wuDir = WU_PATHS.WU_DIR();
     if (!existsSync(wuDir)) {
         die(`WU directory not found: ${wuDir}`);
@@ -110,7 +116,7 @@ function validateAllWUs({ strict = false } = {}) {
 async function main() {
     const args = createWUParser({
         name: 'wu-validate',
-        description: 'Validate WU YAML files against schema',
+        description: 'Validate WU YAML files against schema (strict mode by default, WU-1329)',
         options: [
             WU_OPTIONS.id,
             {
@@ -119,17 +125,19 @@ async function main() {
                 type: 'boolean',
                 description: 'Validate all WUs',
             },
-            {
-                name: 'strict',
-                flags: '-s, --strict',
-                type: 'boolean',
-                description: 'Treat warnings as errors',
-            },
+            // WU-1329: Change from --strict to --no-strict (strict is now default)
+            WU_OPTIONS.noStrict,
         ],
         required: [],
         allowPositionalId: true,
     });
-    const { id, all, strict } = args;
+    const { id, all, noStrict } = args;
+    // WU-1329: Strict mode is the default, --no-strict opts out
+    const strict = !noStrict;
+    // WU-1329: Log when strict validation is bypassed
+    if (noStrict) {
+        console.warn(`${LOG_PREFIX} WARNING: strict validation bypassed (--no-strict). Warnings will be advisory only.`);
+    }
     if (!id && !all) {
         die('Must specify --id WU-XXX or --all');
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lumenflow/cli",
-  "version": "2.4.0",
+  "version": "2.5.0",
   "description": "Command-line interface for LumenFlow workflow framework",
   "keywords": [
     "lumenflow",
@@ -75,6 +75,10 @@
     "initiative-add-wu": "./dist/initiative-add-wu.js",
     "initiative-plan": "./dist/initiative-plan.js",
     "init-plan": "./dist/init-plan.js",
+    "plan-create": "./dist/plan-create.js",
+    "plan-link": "./dist/plan-link.js",
+    "plan-edit": "./dist/plan-edit.js",
+    "plan-promote": "./dist/plan-promote.js",
     "agent-session": "./dist/agent-session.js",
     "agent-session-end": "./dist/agent-session-end.js",
     "agent-log-issue": "./dist/agent-log-issue.js",
@@ -144,11 +148,11 @@
     "pretty-ms": "^9.2.0",
     "simple-git": "^3.30.0",
     "yaml": "^2.8.2",
-    "@lumenflow/core": "2.4.0",
-    "@lumenflow/metrics": "2.4.0",
-    "@lumenflow/memory": "2.4.0",
-    "@lumenflow/initiatives": "2.4.0",
-    "@lumenflow/agent": "2.4.0"
+    "@lumenflow/core": "2.5.0",
+    "@lumenflow/initiatives": "2.5.0",
+    "@lumenflow/memory": "2.5.0",
+    "@lumenflow/agent": "2.5.0",
+    "@lumenflow/metrics": "2.5.0"
   },
   "devDependencies": {
     "@vitest/coverage-v8": "^4.0.17",

package/templates/core/AGENTS.md.template

@@ -17,11 +17,11 @@ cd worktrees/<lane>-wu-xxxx
 pnpm gates
 
 # 3. Complete (ALWAYS run this!)
-cd {{PROJECT_ROOT}}
+cd <project-root>
 pnpm wu:done --id WU-XXXX
 ```
 
-> **Complete CLI reference:** See [quick-ref-commands.md](docs/04-operations/_frameworks/lumenflow/agent/onboarding/quick-ref-commands.md)
+> **Complete CLI reference:** See [quick-ref-commands.md]({{QUICK_REF_LINK}})
 
 ---