@lumenflow/cli 2.2.2 → 2.3.2

package/dist/wu-claim.js

@@ -1,4 +1,5 @@
 #!/usr/bin/env node
+/* eslint-disable no-console -- CLI tool requires console output */
 /**
  * WU Claim Helper
  *
@@ -8,7 +9,7 @@
  * 3) Create a dedicated worktree+branch for the WU
  *
  * Usage:
- *   node tools/wu-claim.mjs --id WU-334 --lane Intelligence \
+ *   node tools/wu-claim.ts --id WU-334 --lane Intelligence \
  *     [--worktree worktrees/intelligence-wu-334] [--branch lane/intelligence/wu-334]
  *
  * WU-2542: This script imports utilities from @lumenflow/core package.
@@ -18,21 +19,24 @@ import { existsSync, readFileSync, rmSync } from 'node:fs';
 import { access, readFile, writeFile, mkdir } from 'node:fs/promises';
 import path from 'node:path';
 import { isOrphanWorktree } from '@lumenflow/core/dist/orphan-detector.js';
-// WU-1352: Use centralized YAML functions from wu-yaml.mjs
+// WU-1352: Use centralized YAML functions from wu-yaml.ts
 import { parseYAML, stringifyYAML } from '@lumenflow/core/dist/wu-yaml.js';
 import { assertTransition } from '@lumenflow/core/dist/state-machine.js';
-import { checkLaneFree, validateLaneFormat } from '@lumenflow/core/dist/lane-checker.js';
+import { checkLaneFree, validateLaneFormat, checkWipJustification, } from '@lumenflow/core/dist/lane-checker.js';
 // WU-1603: Atomic lane locking to prevent TOCTOU race conditions
 import { acquireLaneLock, releaseLaneLock, checkLaneLock, forceRemoveStaleLock, } from '@lumenflow/core/dist/lane-lock.js';
 // WU-1825: Import from unified code-path-validator (consolidates 3 validators)
-import { validateLaneCodePaths, logLaneValidationWarnings, } from '@lumenflow/core/dist/code-path-validator.js';
+// WU-1213: Using deprecated sync API - async validate() requires larger refactor (separate WU)
+import { 
+// eslint-disable-next-line sonarjs/deprecation -- sync API required for current architecture
+validateLaneCodePaths, logLaneValidationWarnings, } from '@lumenflow/core/dist/code-path-validator.js';
 // WU-1574: parseBacklogFrontmatter/getSectionHeadings removed - state store replaces backlog parsing
 import { detectConflicts } from '@lumenflow/core/dist/code-paths-overlap.js';
 import { getGitForCwd, createGitForPath } from '@lumenflow/core/dist/git-adapter.js';
 import { die } from '@lumenflow/core/dist/error-handler.js';
 import { createWUParser, WU_OPTIONS } from '@lumenflow/core/dist/arg-parser.js';
 import { WU_PATHS, getStateStoreDirFromBacklog } from '@lumenflow/core/dist/wu-paths.js';
-import { BRANCHES, REMOTES, WU_STATUS, CLAIMED_MODES, STATUS_SECTIONS, PATTERNS, toKebab, LOG_PREFIX, GIT_REFS, MICRO_WORKTREE_OPERATIONS, COMMIT_FORMATS, EMOJI, FILE_SYSTEM, STRING_LITERALS, } from '@lumenflow/core/dist/wu-constants.js';
+import { BRANCHES, REMOTES, WU_STATUS, CLAIMED_MODES, STATUS_SECTIONS, PATTERNS, toKebab, LOG_PREFIX, GIT_REFS, MICRO_WORKTREE_OPERATIONS, COMMIT_FORMATS, EMOJI, FILE_SYSTEM, STRING_LITERALS, LUMENFLOW_PATHS, } from '@lumenflow/core/dist/wu-constants.js';
 import { withMicroWorktree } from '@lumenflow/core/dist/micro-worktree.js';
 import { ensureOnMain, ensureMainUpToDate } from '@lumenflow/core/dist/wu-helpers.js';
 import { emitWUFlowEvent } from '@lumenflow/core/dist/telemetry.js';
@@ -51,7 +55,9 @@ import { WUStateStore } from '@lumenflow/core/dist/wu-state-store.js';
 import { generateBacklog, generateStatus } from '@lumenflow/core/dist/backlog-generator.js';
 // WU-2411: Import resume helpers for agent handoff
 import { resumeClaimForHandoff, getWorktreeUncommittedChanges, formatUncommittedChanges, createHandoffCheckpoint, } from '@lumenflow/core/dist/wu-claim-resume.js';
-// ensureOnMain() moved to wu-helpers.mjs (WU-1256)
+// WU-1211: Import initiative validation for status auto-progression
+import { shouldProgressInitiativeStatus, findInitiative, writeInitiative, getInitiativeWUs, } from '@lumenflow/initiatives/dist/index.js';
+// ensureOnMain() moved to wu-helpers.ts (WU-1256)
 async function ensureCleanOrClaimOnlyWhenNoAuto() {
     // Require staged claim edits only if running with --no-auto
     const status = await getGitForCwd().getStatus();
@@ -258,7 +264,52 @@ async function updateWUYaml(WU_PATH, id, lane, claimedMode = 'worktree', worktre
     // Write file
     // eslint-disable-next-line security/detect-non-literal-fs-filename -- CLI tool writes WU files
     await writeFile(WU_PATH, out, { encoding: FILE_SYSTEM.UTF8 });
-    return doc.title || '';
+    // WU-1211: Return both title and initiative for status progression check
+    return { title: doc.title || '', initiative: doc.initiative || null };
+}
+/**
+ * WU-1211: Check and progress initiative status from draft/open to in_progress.
+ *
+ * Called when a WU with an initiative field is claimed. If this is the first
+ * WU being claimed for the initiative, progress the initiative status.
+ *
+ * @param {string} worktreePath - Path to micro-worktree (or main)
+ * @param {string} initiativeRef - Initiative ID or slug
+ * @param {string} wuId - WU ID being claimed
+ * @returns {Promise<{updated: boolean, initPath: string|null}>} Result
+ */
+async function maybeProgressInitiativeStatus(worktreePath, initiativeRef, wuId) {
+    try {
+        // Find the initiative
+        const initiative = findInitiative(initiativeRef);
+        if (!initiative) {
+            console.log(`${PREFIX} Initiative ${initiativeRef} not found (may be created later)`);
+            return { updated: false, initPath: null };
+        }
+        // Get all WUs for this initiative to check if any are in_progress
+        const wus = getInitiativeWUs(initiativeRef);
+        // Include the WU we're currently claiming as in_progress
+        const wusWithCurrent = wus.map((wu) => wu.id === wuId ? { ...wu, doc: { ...wu.doc, status: 'in_progress' } } : wu);
+        const wuDocs = wusWithCurrent.map((wu) => wu.doc);
+        // Check if initiative status should progress
+        const progressCheck = shouldProgressInitiativeStatus(initiative.doc, wuDocs);
+        if (!progressCheck.shouldProgress || !progressCheck.newStatus) {
+            return { updated: false, initPath: null };
+        }
+        // Update initiative status in worktree
+        const initRelativePath = initiative.path.replace(process.cwd() + '/', '');
+        const initAbsPath = path.join(worktreePath, initRelativePath);
+        // Read, update, write
+        const initDoc = { ...initiative.doc, status: progressCheck.newStatus };
+        writeInitiative(initAbsPath, initDoc);
+        console.log(`${PREFIX} ✅ Initiative ${initiativeRef} status progressed: ${initiative.doc.status} → ${progressCheck.newStatus}`);
+        return { updated: true, initPath: initRelativePath };
+    }
+    catch (error) {
+        // Non-fatal: log warning and continue
+        console.warn(`${PREFIX} ⚠️  Could not check initiative status progression: ${error.message}`);
+        return { updated: false, initPath: null };
+    }
 }
 async function addOrReplaceInProgressStatus(statusPath, id, title) {
     // Check file exists
@@ -351,7 +402,7 @@ async function appendClaimEventOnly(stateDir, id, title, lane) {
 export function getWorktreeCommitFiles(wuId) {
     return [
         `docs/04-operations/tasks/wu/${wuId}.yaml`,
-        '.lumenflow/state/wu-events.jsonl', // WU-1740: Event store is source of truth
+        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
@@ -407,12 +458,7 @@ async function applyCanonicalClaimUpdate(ctx, sessionId) {
     let updatedTitle = '';
     const filesToCommit = args.noAuto && stagedChanges.length > 0
         ? stagedChanges.map((change) => change.filePath).filter(Boolean)
-        : [
-            WU_PATHS.WU(id),
-            WU_PATHS.STATUS(),
-            WU_PATHS.BACKLOG(),
-            '.lumenflow/state/wu-events.jsonl',
-        ];
+        : [WU_PATHS.WU(id), WU_PATHS.STATUS(), WU_PATHS.BACKLOG(), LUMENFLOW_PATHS.WU_EVENTS];
     console.log(`${PREFIX} Updating canonical claim state (push-only)...`);
     await withMicroWorktree({
         operation: MICRO_WORKTREE_OPERATIONS.WU_CLAIM,
@@ -433,10 +479,23 @@ async function applyCanonicalClaimUpdate(ctx, sessionId) {
                     console.log(`${PREFIX} YAML fixes applied successfully`);
                 }
                 const microGit = createGitForPath(worktreePath);
-                updatedTitle =
-                    (await updateWUYaml(microWUPath, id, args.lane, claimedMode, worktreePathForYaml, sessionId, microGit)) || updatedTitle;
+                // WU-1211: updateWUYaml now returns {title, initiative}
+                const updateResult = await updateWUYaml(microWUPath, id, args.lane, claimedMode, worktreePathForYaml, sessionId, microGit);
+                updatedTitle = updateResult.title || updatedTitle;
                 await addOrReplaceInProgressStatus(microStatusPath, id, updatedTitle);
                 await removeFromReadyAndAddToInProgressBacklog(microBacklogPath, id, updatedTitle, args.lane);
+                // WU-1211: Check and progress initiative status
+                let initPath = null;
+                if (updateResult.initiative) {
+                    const initProgress = await maybeProgressInitiativeStatus(worktreePath, updateResult.initiative, id);
+                    initPath = initProgress.initPath;
+                }
+                // Include initiative path in files to commit if updated
+                const allFilesToCommit = initPath ? [...filesToCommit, initPath] : filesToCommit;
+                return {
+                    commitMessage: commitMsg,
+                    files: allFilesToCommit,
+                };
             }
             return {
                 commitMessage: commitMsg,
@@ -459,10 +518,14 @@ async function readWUTitle(id) {
     // Read file
     // eslint-disable-next-line security/detect-non-literal-fs-filename -- CLI tool validates WU files
     const text = await readFile(p, { encoding: FILE_SYSTEM.UTF8 });
-    const m = text.match(/^title:\s*"?(.+?)"?$/m);
+    // Match title field - use RegExp.exec for sonarjs/prefer-regexp-exec compliance
+    // Regex is safe: runs on trusted WU YAML files with bounded input
+    // eslint-disable-next-line sonarjs/slow-regex -- Bounded input from WU YAML files
+    const titlePattern = /^title:\s*"?([^"\n]+)"?$/m;
+    const m = titlePattern.exec(text);
     return m ? m[1] : null;
 }
-// emitWUFlowEvent() moved to telemetry.mjs as emitWUFlowEvent() (WU-1256)
+// emitWUFlowEvent() moved to telemetry.ts as emitWUFlowEvent() (WU-1256)
 /**
  * Check if there's already a Branch-Only WU in progress
  * Branch-Only mode doesn't support parallel WUs (only one WU at a time in main checkout)
@@ -492,11 +555,12 @@ async function checkExistingBranchOnlyWU(statusPath, currentWU) {
     else
         endIdx = startIdx + 1 + endIdx;
     // Extract WU IDs from In Progress section
+    // Use RegExp.exec for sonarjs/prefer-regexp-exec compliance
     const wuPattern = /\[?(WU-\d+)/i;
     const inProgressWUs = lines
         .slice(startIdx + 1, endIdx)
         .map((line) => {
-        const match = line.match(wuPattern);
+        const match = wuPattern.exec(line);
         return match ? match[1].toUpperCase() : null;
     })
         .filter(Boolean)
@@ -566,7 +630,7 @@ async function handleOrphanCheck(lane, id) {
                         WU_PATHS.BACKLOG(),
                         WU_PATHS.STATUS(),
                         `.lumenflow/stamps/${orphanId}.done`,
-                        '.lumenflow/state/wu-events.jsonl',
+                        LUMENFLOW_PATHS.WU_EVENTS,
                     ],
                 };
             },
@@ -655,7 +719,12 @@ function handleCodePathOverlap(WU_PATH, STATUS_PATH, id, args) {
     });
     if (overlapCheck.hasBlocker && !args.forceOverlap) {
         const conflictList = overlapCheck.conflicts
-            .map((c) => `  - ${c.wuid}: ${c.overlaps.slice(0, 3).join(', ')}${c.overlaps.length > 3 ? ` (+${c.overlaps.length - 3} more)` : ''}`)
+            .map((c) => {
+            const displayedOverlaps = c.overlaps.slice(0, 3).join(', ');
+            const remainingCount = c.overlaps.length - 3;
+            const suffix = remainingCount > 0 ? ` (+${remainingCount} more)` : '';
+            return `  - ${c.wuid}: ${displayedOverlaps}${suffix}`;
+        })
             .join(STRING_LITERALS.NEWLINE);
         die(`Code path overlap detected with in-progress WUs:\n\n${conflictList}\n\n` +
             `Merge conflicts are guaranteed if both WUs proceed.\n\n` +
@@ -727,11 +796,20 @@ async function claimBranchOnlyMode(ctx) {
             await ensureCleanOrClaimOnlyWhenNoAuto();
         }
         else {
-            finalTitle =
-                (await updateWUYaml(WU_PATH, id, args.lane, claimedMode, null, sessionId)) || finalTitle;
+            // WU-1211: updateWUYaml now returns {title, initiative}
+            const updateResult = await updateWUYaml(WU_PATH, id, args.lane, claimedMode, null, sessionId);
+            finalTitle = updateResult.title || finalTitle;
             await addOrReplaceInProgressStatus(STATUS_PATH, id, finalTitle);
             await removeFromReadyAndAddToInProgressBacklog(BACKLOG_PATH, id, finalTitle, args.lane);
-            await getGitForCwd().add(`${JSON.stringify(WU_PATH)} ${JSON.stringify(STATUS_PATH)} ${JSON.stringify(BACKLOG_PATH)}`);
+            const filesToAdd = [WU_PATH, STATUS_PATH, BACKLOG_PATH];
+            // WU-1211: Progress initiative status if needed
+            if (updateResult.initiative) {
+                const initProgress = await maybeProgressInitiativeStatus(process.cwd(), updateResult.initiative, id);
+                if (initProgress.initPath) {
+                    filesToAdd.push(initProgress.initPath);
+                }
+            }
+            await getGitForCwd().add(filesToAdd.map((f) => JSON.stringify(f)).join(' '));
         }
         await getGitForCwd().commit(msg);
         console.warn(`${PREFIX} Warning: --no-push enabled. Claim is local-only and NOT visible to other agents.`);
@@ -741,10 +819,12 @@ async function claimBranchOnlyMode(ctx) {
     }
     // Summary
     console.log(`\n${PREFIX} Claim recorded in Branch-Only mode.`);
-    console.log(`- WU: ${id}${finalTitle ? ` — ${finalTitle}` : ''}`);
+    const wuDisplay = finalTitle ? `- WU: ${id} — ${finalTitle}` : `- WU: ${id}`;
+    console.log(wuDisplay);
     console.log(`- Lane: ${args.lane}`);
     console.log(`- Mode: Branch-Only (no worktree)`);
-    console.log(`${args.noPush ? `- Commit: ${msg}` : `- Branch: ${branch}`}`);
+    const refDisplay = args.noPush ? `- Commit: ${msg}` : `- Branch: ${branch}`;
+    console.log(refDisplay);
     console.log('\n⚠️  LIMITATION: Branch-Only mode does not support parallel WUs (WIP=1 across ALL lanes)');
     console.log('Next: work on this branch in the main checkout.');
     // WU-1360: Print next-steps checklist to prevent common mistakes
@@ -768,6 +848,82 @@ async function claimBranchOnlyMode(ctx) {
     // WU-1763: Print lifecycle nudge with tips for tool adoption
     printLifecycleNudge(id);
 }
+/**
+ * WU-1213: Handle local-only claim metadata update (noPush mode).
+ * Extracted to reduce cognitive complexity of claimWorktreeMode.
+ *
+ * @returns {Promise<{finalTitle: string, initPathToCommit: string | null}>}
+ */
+async function handleNoPushMetadataUpdate(ctx) {
+    const { args, id, worktree, worktreePath, WU_PATH, BACKLOG_PATH, claimedMode, fixableIssues, sessionId, title, updatedTitle, stagedChanges, } = ctx;
+    let finalTitle = updatedTitle || title;
+    let initPathToCommit = null;
+    if (args.noAuto) {
+        await applyStagedChangesToMicroWorktree(worktreePath, stagedChanges);
+    }
+    else {
+        const wtWUPath = path.join(worktreePath, WU_PATH);
+        const wtBacklogPath = path.join(worktreePath, BACKLOG_PATH);
+        if (fixableIssues && fixableIssues.length > 0) {
+            console.log(`${PREFIX} Applying ${fixableIssues.length} YAML fix(es)...`);
+            autoFixWUYaml(wtWUPath);
+            console.log(`${PREFIX} YAML fixes applied successfully`);
+        }
+        const updateResult = await updateWUYaml(wtWUPath, id, args.lane, claimedMode, worktree, sessionId);
+        finalTitle = updateResult.title || finalTitle;
+        const wtStateDir = getStateStoreDirFromBacklog(wtBacklogPath);
+        await appendClaimEventOnly(wtStateDir, id, finalTitle, args.lane);
+        if (updateResult.initiative) {
+            const initProgress = await maybeProgressInitiativeStatus(worktreePath, updateResult.initiative, id);
+            initPathToCommit = initProgress.initPath;
+        }
+    }
+    return { finalTitle, initPathToCommit };
+}
+/**
+ * WU-1213: Setup worktree dependencies (symlink or full install).
+ * Extracted to reduce cognitive complexity of claimWorktreeMode.
+ */
+async function setupWorktreeDependencies(worktreePath, originalCwd, skipSetup) {
+    // eslint-disable-next-line sonarjs/no-selector-parameter -- skipSetup mirrors CLI flag semantics
+    if (skipSetup) {
+        // WU-1443: Symlink-only mode for fast claims
+        const symlinkResult = symlinkNodeModules(worktreePath, console, originalCwd);
+        if (symlinkResult.created) {
+            console.log(`${PREFIX} ${EMOJI.SUCCESS} node_modules symlinked (--skip-setup mode)`);
+        }
+        else if (symlinkResult.refused) {
+            console.warn(`${PREFIX} Warning: symlink refused: ${symlinkResult.reason}`);
+            console.warn(`${PREFIX} Run 'pnpm install' manually in the worktree`);
+        }
+        // WU-1579: Auto-symlink nested package node_modules for turbo typecheck
+        if (!symlinkResult.refused) {
+            const nestedResult = symlinkNestedNodeModules(worktreePath, originalCwd);
+            if (nestedResult.created > 0) {
+                console.log(`${PREFIX} ${EMOJI.SUCCESS} ${nestedResult.created} nested node_modules symlinked for typecheck`);
+            }
+        }
+    }
+    else {
+        // WU-1023: Full setup mode (default) - run pnpm install with progress indicator
+        console.log(`${PREFIX} Installing worktree dependencies (this may take a moment)...`);
+        try {
+            const { execSync } = await import('node:child_process');
+            execSync('pnpm install --frozen-lockfile', {
+                cwd: worktreePath,
+                stdio: 'inherit',
+                timeout: 300000, // 5 minute timeout
+            });
+            console.log(`${PREFIX} ${EMOJI.SUCCESS} Worktree dependencies installed`);
+        }
+        catch (installError) {
+            console.warn(`${PREFIX} Warning: pnpm install failed: ${installError.message}`);
+            console.warn(`${PREFIX} You may need to run 'pnpm install' manually in the worktree`);
+            console.log(`${PREFIX} Falling back to symlink approach...`);
+            applyFallbackSymlinks(worktreePath, originalCwd, console);
+        }
+    }
+}
 /**
  * Execute worktree mode claim workflow
  *
@@ -788,14 +944,12 @@ async function claimBranchOnlyMode(ctx) {
  * - Cleaner rollback: delete worktree+branch = claim undone
  */
 async function claimWorktreeMode(ctx) {
-    const { args, id, laneK, title, branch, worktree, WU_PATH, BACKLOG_PATH, claimedMode, fixableIssues, // Fixable issues from pre-flight validation
-    sessionId, updatedTitle, stagedChanges, } = ctx;
+    const { args, id, laneK, title, branch, worktree, WU_PATH, updatedTitle } = ctx;
     const originalCwd = process.cwd();
     const worktreePath = path.resolve(worktree);
     let finalTitle = updatedTitle || title;
     const commitMsg = COMMIT_FORMATS.CLAIM(id.toLowerCase(), laneK);
     // WU-1741: Step 1 - Create work worktree+branch from main
-    // Branch creation IS the coordination lock (git prevents duplicate branch names)
     console.log(`${PREFIX} Creating worktree (branch = coordination lock)...`);
     const startPoint = args.noPush ? BRANCHES.MAIN : `${REMOTES.ORIGIN}/${BRANCHES.MAIN}`;
     await getGitForCwd().worktreeAdd(worktree, branch, startPoint);
@@ -804,80 +958,27 @@ async function claimWorktreeMode(ctx) {
         const wtGit = createGitForPath(worktreePath);
         await wtGit.push(REMOTES.ORIGIN, branch, { setUpstream: true });
     }
+    // Handle local-only claim metadata update (noPush mode)
     if (args.noPush) {
-        // Local-only claim (air-gapped) - update metadata inside worktree branch
-        if (args.noAuto) {
-            await applyStagedChangesToMicroWorktree(worktreePath, stagedChanges);
-        }
-        else {
-            const wtWUPath = path.join(worktreePath, WU_PATH);
-            const wtBacklogPath = path.join(worktreePath, BACKLOG_PATH);
-            if (fixableIssues && fixableIssues.length > 0) {
-                console.log(`${PREFIX} Applying ${fixableIssues.length} YAML fix(es)...`);
-                autoFixWUYaml(wtWUPath);
-                console.log(`${PREFIX} YAML fixes applied successfully`);
-            }
-            finalTitle =
-                (await updateWUYaml(wtWUPath, id, args.lane, claimedMode, worktree, sessionId)) ||
-                    finalTitle;
-            // WU-1746: Only append claim event to state store - don't regenerate backlog.md/status.md
-            const wtStateDir = getStateStoreDirFromBacklog(wtBacklogPath);
-            await appendClaimEventOnly(wtStateDir, id, finalTitle, args.lane);
-        }
+        const metadataResult = await handleNoPushMetadataUpdate({ ...ctx, worktreePath });
+        finalTitle = metadataResult.finalTitle;
+        // Commit metadata in worktree
         console.log(`${PREFIX} Committing claim metadata in worktree...`);
         const wtGit = createGitForPath(worktreePath);
         const filesToCommit = getWorktreeCommitFiles(id);
+        if (metadataResult.initPathToCommit) {
+            filesToCommit.push(metadataResult.initPathToCommit);
+        }
         await wtGit.add(filesToCommit);
         await wtGit.commit(commitMsg);
         console.log(`${PREFIX} ${EMOJI.SUCCESS} Claim committed: ${commitMsg}`);
         console.warn(`${PREFIX} Warning: --no-push enabled. Claim is local-only and NOT visible to other agents.`);
     }
     // WU-1023: Auto-setup worktree dependencies
-    // By default, run pnpm install to ensure all dependencies are built (including CLI dist)
-    // Use --skip-setup to use symlink-only approach for faster claims when deps are already built
-    if (args.skipSetup) {
-        // WU-1443: Symlink-only mode for fast claims
-        // WU-2238: Pass mainRepoPath to detect broken worktree-path symlinks
-        const symlinkResult = symlinkNodeModules(worktreePath, console, originalCwd);
-        if (symlinkResult.created) {
-            console.log(`${PREFIX} ${EMOJI.SUCCESS} node_modules symlinked (--skip-setup mode)`);
-        }
-        else if (symlinkResult.refused) {
-            console.warn(`${PREFIX} Warning: symlink refused: ${symlinkResult.reason}`);
-            console.warn(`${PREFIX} Run 'pnpm install' manually in the worktree`);
-        }
-        // WU-1579: Auto-symlink nested package node_modules for turbo typecheck
-        if (!symlinkResult.refused) {
-            const nestedResult = symlinkNestedNodeModules(worktreePath, originalCwd);
-            if (nestedResult.created > 0) {
-                console.log(`${PREFIX} ${EMOJI.SUCCESS} ${nestedResult.created} nested node_modules symlinked for typecheck`);
-            }
-        }
-    }
-    else {
-        // WU-1023: Full setup mode (default) - run pnpm install with progress indicator
-        // This ensures CLI dist is built and all dependencies are properly resolved
-        console.log(`${PREFIX} Installing worktree dependencies (this may take a moment)...`);
-        try {
-            const { execSync } = await import('node:child_process');
-            execSync('pnpm install --frozen-lockfile', {
-                cwd: worktreePath,
-                stdio: 'inherit', // Shows progress output from pnpm
-                timeout: 300000, // 5 minute timeout for full install
-            });
-            console.log(`${PREFIX} ${EMOJI.SUCCESS} Worktree dependencies installed`);
-        }
-        catch (installError) {
-            // Non-fatal: warn but don't block claim
-            console.warn(`${PREFIX} Warning: pnpm install failed: ${installError.message}`);
-            console.warn(`${PREFIX} You may need to run 'pnpm install' manually in the worktree`);
-            // Fall back to symlink approach so worktree is at least somewhat usable
-            console.log(`${PREFIX} Falling back to symlink approach...`);
-            applyFallbackSymlinks(worktreePath, originalCwd, console);
-        }
-    }
+    await setupWorktreeDependencies(worktreePath, originalCwd, args.skipSetup);
     console.log(`${PREFIX} Claim recorded in worktree`);
-    console.log(`- WU: ${id}${finalTitle ? ` — ${finalTitle}` : ''}`);
+    const worktreeWuDisplay = finalTitle ? `- WU: ${id} — ${finalTitle}` : `- WU: ${id}`;
+    console.log(worktreeWuDisplay);
     console.log(`- Lane: ${args.lane}`);
     console.log(`- Worktree: ${worktreePath}`);
     console.log(`- Branch: ${branch}`);
@@ -1113,7 +1214,13 @@ async function main() {
     const doc = preflightValidateWU(WU_PATH, id);
     await handleOrphanCheck(args.lane, id);
     validateLaneFormatWithError(args.lane);
+    // WU-1187: Check for WIP justification when WIP > 1 (soft enforcement - warning only)
+    const wipJustificationCheck = checkWipJustification(args.lane);
+    if (wipJustificationCheck.warning) {
+        console.warn(`${PREFIX} ${wipJustificationCheck.warning}`);
+    }
     // WU-1372: Lane-to-code_paths consistency check (advisory only, never blocks)
+    // eslint-disable-next-line sonarjs/deprecation -- sync API required for current architecture
     const laneValidation = validateLaneCodePaths(doc, args.lane);
     logLaneValidationWarnings(laneValidation, PREFIX);
     // WU-1361: YAML schema validation at claim time
@@ -1190,11 +1297,14 @@ async function main() {
         const title = (await readWUTitle(id)) || '';
         const branch = args.branch || `lane/${laneK}/${idK}`;
         const worktree = args.worktree || `worktrees/${laneK}-${idK}`;
-        const claimedMode = args.branchOnly
-            ? CLAIMED_MODES.BRANCH_ONLY
-            : args.prMode
-                ? CLAIMED_MODES.WORKTREE_PR
-                : CLAIMED_MODES.WORKTREE;
+        // Determine claimed mode based on flags (no nested ternaries for sonarjs compliance)
+        let claimedMode = CLAIMED_MODES.WORKTREE;
+        if (args.branchOnly) {
+            claimedMode = CLAIMED_MODES.BRANCH_ONLY;
+        }
+        else if (args.prMode) {
+            claimedMode = CLAIMED_MODES.WORKTREE_PR;
+        }
         // Branch-Only mode validation
         if (args.branchOnly) {
             await validateBranchOnlyMode(STATUS_PATH, id);
@@ -1307,5 +1417,5 @@ async function main() {
 // path but import.meta.url resolves to the real path - they never match
 import { runCLI } from './cli-entry-point.js';
 if (import.meta.main) {
-    runCLI(main);
+    void runCLI(main);
 }

package/dist/wu-cleanup.js

@@ -191,7 +191,7 @@ async function main() {
     }
     const id = args.id.toUpperCase();
     const wu = readWU(WU_PATHS.WU(id), id);
-    // Use kebab-case lane naming (match wu-claim.mjs logic)
+    // Use kebab-case lane naming (match wu-claim.ts logic)
     const laneK = wu.lane
         ?.toLowerCase()
         .trim()
@@ -267,9 +267,10 @@ async function main() {
     console.log('║  Branch deleted (local + remote)');
     console.log(BOX.BOT);
 }
-// Guard main() for testability (WU-1366)
-import { fileURLToPath } from 'node:url';
+// WU-1181: 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
 import { runCLI } from './cli-entry-point.js';
-if (process.argv[1] === fileURLToPath(import.meta.url)) {
+if (import.meta.main) {
     runCLI(main);
 }