@lumenflow/cli 1.1.0 → 1.3.2

package/dist/wu-deps.js

@@ -114,6 +114,7 @@ function renderGraphJSON(graph, rootId, depth, direction) {
 }
 // Guard main() for testability (WU-1366)
 import { fileURLToPath } from 'node:url';
+import { runCLI } from './cli-entry-point.js';
 if (process.argv[1] === fileURLToPath(import.meta.url)) {
-    main();
+    runCLI(main);
 }

package/dist/wu-done.js

@@ -147,7 +147,7 @@ async function validateClaimMetadataBeforeGates(id, worktreePath, yamlStatus) {
         `  pnpm wu:repair-claim --id ${id}\n\n` +
         `After repair, retry:\n` +
         `  pnpm wu:done --id ${id}\n\n` +
-        `See: ai/onboarding/troubleshooting-wu-done.md for more recovery options.`);
+        `See: docs/04-operations/_frameworks/lumenflow/agent/onboarding/troubleshooting-wu-done.md for more recovery options.`);
 }
 export function printExposureWarnings(wu, options = {}) {
     // Validate exposure
@@ -1793,7 +1793,8 @@ async function executeGates({ id, args, isBranchOnly, isDocsOnly, worktreePath,
     }
     else {
         die(`Worktree not found (${worktreePath || 'unknown'}). Gates must run in the lane worktree.\n` +
-            `If the worktree was removed, recreate it and retry, or use --skip-gates with justification.`);
+            `If the worktree was removed, recreate it and retry, or rerun with --branch-only when the lane branch exists.\n` +
+            `Use --skip-gates only with justification.`);
     }
     // Step 0.75: Run COS governance gates (WU-614, COS v1.3 §7)
     if (!args.skipCosGates) {
@@ -1858,6 +1859,13 @@ async function executeGates({ id, args, isBranchOnly, isDocsOnly, worktreePath,
  * @param {string|null} params.derivedWorktree - Derived worktree path
  * @param {string} params.STAMPS_DIR - Stamps directory path
  */
+export function computeBranchOnlyFallback({ isBranchOnly, branchOnlyRequested, worktreeExists, derivedWorktree, }) {
+    const allowFallback = Boolean(branchOnlyRequested) && !isBranchOnly && !worktreeExists && Boolean(derivedWorktree);
+    return {
+        allowFallback,
+        effectiveBranchOnly: isBranchOnly || allowFallback,
+    };
+}
 function printStateHUD({ id, docMain, isBranchOnly, isDocsOnly, derivedWorktree, STAMPS_DIR }) {
     const stampExists = existsSync(path.join(STAMPS_DIR, `${id}.done`)) ? 'yes' : 'no';
     const yamlStatus = docMain.status || 'unknown';
@@ -1869,6 +1877,8 @@ function printStateHUD({ id, docMain, isBranchOnly, isDocsOnly, derivedWorktree,
 }
 // eslint-disable-next-line sonarjs/cognitive-complexity -- Pre-existing complexity, refactor tracked separately
 async function main() {
+    // Allow pre-push hook to recognize wu:done automation (WU-1030)
+    process.env.LUMENFLOW_WU_TOOL = 'wu-done';
     // Validate CLI arguments and WU ID format (extracted to wu-done-validators.mjs)
     const { args, id } = validateInputs(process.argv);
     // Detect workspace mode and calculate paths (WU-1215: extracted to validators module)
@@ -1876,25 +1886,39 @@ async function main() {
     const { WU_PATH, STATUS_PATH, BACKLOG_PATH, STAMPS_DIR, docMain, isBranchOnly, derivedWorktree, docForValidation: initialDocForValidation, isDocsOnly, } = pathInfo;
     // Capture main checkout path once. process.cwd() may drift later during recovery flows.
     const mainCheckoutPath = process.cwd();
+    // Resolve worktree path early so we can detect missing worktree before pre-flight checks
+    const resolvedWorktreePath = derivedWorktree && !isBranchOnly
+        ? path.isAbsolute(derivedWorktree)
+            ? derivedWorktree
+            : path.resolve(mainCheckoutPath, derivedWorktree)
+        : null;
+    const worktreeExists = resolvedWorktreePath ? existsSync(resolvedWorktreePath) : false;
+    const { allowFallback: allowBranchOnlyFallback, effectiveBranchOnly } = computeBranchOnlyFallback({
+        isBranchOnly,
+        branchOnlyRequested: args.branchOnly,
+        worktreeExists,
+        derivedWorktree,
+    });
+    if (allowBranchOnlyFallback) {
+        console.warn(`${LOG_PREFIX.DONE} ${EMOJI.WARNING} Worktree missing (${resolvedWorktreePath}). Proceeding in branch-only mode because --branch-only was provided.`);
+    }
+    const effectiveDerivedWorktree = effectiveBranchOnly ? null : derivedWorktree;
+    const effectiveWorktreePath = effectiveBranchOnly ? null : resolvedWorktreePath;
     // Pre-flight checks (WU-1215: extracted to executePreFlightChecks function)
     const preFlightResult = await executePreFlightChecks({
         id,
         args,
-        isBranchOnly,
+        isBranchOnly: effectiveBranchOnly,
         isDocsOnly,
         docMain,
         docForValidation: initialDocForValidation,
-        derivedWorktree,
+        derivedWorktree: effectiveDerivedWorktree,
     });
     const title = preFlightResult.title;
     // Note: docForValidation is returned but not used after pre-flight checks
     // The metadata transaction uses docForUpdate instead
     // Step 0: Run gates (WU-1215: extracted to executeGates function)
-    const worktreePath = derivedWorktree && !isBranchOnly
-        ? path.isAbsolute(derivedWorktree)
-            ? derivedWorktree
-            : path.resolve(mainCheckoutPath, derivedWorktree)
-        : null;
+    const worktreePath = effectiveWorktreePath;
     // WU-1943: Check if any checkpoints exist for this WU session
     // Warn (don't block) if no checkpoints - agent should have been checkpointing periodically
     try {
@@ -1908,9 +1932,16 @@ async function main() {
     catch {
         // Non-blocking: checkpoint check failure should not block wu:done
     }
-    await executeGates({ id, args, isBranchOnly, isDocsOnly, worktreePath });
+    await executeGates({ id, args, isBranchOnly: effectiveBranchOnly, isDocsOnly, worktreePath });
     // Print State HUD for visibility (WU-1215: extracted to printStateHUD function)
-    printStateHUD({ id, docMain, isBranchOnly, isDocsOnly, derivedWorktree, STAMPS_DIR });
+    printStateHUD({
+        id,
+        docMain,
+        isBranchOnly: effectiveBranchOnly,
+        isDocsOnly,
+        derivedWorktree: effectiveDerivedWorktree,
+        STAMPS_DIR,
+    });
     // Step 0.5: Pre-flight validation - run ALL pre-commit hooks BEFORE merge
     // This prevents partial completion states where merge succeeds but commit fails
     // Validates all 8 gates: secrets, file size, ESLint, Prettier, TypeScript, audit, architecture, tasks
@@ -1947,7 +1978,7 @@ async function main() {
             validateStagedFiles,
         };
         try {
-            if (isBranchOnly) {
+            if (effectiveBranchOnly) {
                 // Branch-Only mode: merge first, then update metadata on main
                 // NOTE: Branch-only still uses old rollback mechanism
                 const branchOnlyContext = {
@@ -2165,7 +2196,7 @@ async function detectChangedDocPaths(worktreePath, baseBranch) {
         // Get files changed in this branch vs base
         const diff = await git.raw(['diff', '--name-only', baseBranch]);
         const changedFiles = diff.split('\n').filter(Boolean);
-        // Filter to docs: ai/onboarding/, docs/, CLAUDE.md, README.md, *.md in root
+        // Filter to docs: docs/04-operations/_frameworks/lumenflow/agent/onboarding/, docs/, CLAUDE.md, README.md, *.md in root
         const docPatterns = [
             /^ai\/onboarding\//,
             /^docs\//,
@@ -2183,6 +2214,7 @@ async function detectChangedDocPaths(worktreePath, baseBranch) {
 // Guard main() execution for testability (WU-1366)
 // When imported as a module for testing, main() should not auto-run
 import { fileURLToPath } from 'node:url';
+import { runCLI } from './cli-entry-point.js';
 if (process.argv[1] === fileURLToPath(import.meta.url)) {
-    main();
+    runCLI(main);
 }

package/dist/wu-edit.js

@@ -26,6 +26,7 @@
  * Part of WU-1274: Add wu:edit command for spec-only changes
  * @see {@link tools/lib/micro-worktree.mjs} - Shared micro-worktree logic
  */
+import { fileURLToPath } from 'node:url';
 import { getGitForCwd, createGitForPath } from '@lumenflow/core/dist/git-adapter.js';
 import { die } from '@lumenflow/core/dist/error-handler.js';
 import { existsSync, readFileSync, writeFileSync } from 'node:fs';
@@ -35,7 +36,9 @@ import { join, resolve } from 'node:path';
 import { parseYAML, stringifyYAML, readWU } from '@lumenflow/core/dist/wu-yaml.js';
 import { createWUParser, WU_OPTIONS } from '@lumenflow/core/dist/arg-parser.js';
 import { WU_PATHS } from '@lumenflow/core/dist/wu-paths.js';
-import { FILE_SYSTEM, EXIT_CODES, MICRO_WORKTREE_OPERATIONS, LOG_PREFIX, COMMIT_FORMATS, WU_STATUS, CLAIMED_MODES, getLaneBranch, PKG_MANAGER, SCRIPTS, PRETTIER_FLAGS, READINESS_UI, } from '@lumenflow/core/dist/wu-constants.js';
+import { FILE_SYSTEM, EXIT_CODES, MICRO_WORKTREE_OPERATIONS, LOG_PREFIX, COMMIT_FORMATS, WU_STATUS, CLAIMED_MODES, getLaneBranch, PKG_MANAGER, SCRIPTS, PRETTIER_FLAGS, READINESS_UI, 
+// WU-1039: Import exposure values for validation (Library-First, no magic strings)
+WU_EXPOSURE_VALUES, } from '@lumenflow/core/dist/wu-constants.js';
 // WU-1593: Use centralized validateWUIDFormat (DRY)
 import { ensureOnMain, ensureMainUpToDate, validateWUIDFormat, } from '@lumenflow/core/dist/wu-helpers.js';
 import { withMicroWorktree } from '@lumenflow/core/dist/micro-worktree.js';
@@ -57,6 +60,86 @@ import { normalizeWUSchema } from '@lumenflow/core/dist/wu-schema-normalization.
 import { lintWUSpec, formatLintErrors } from '@lumenflow/core/dist/wu-lint.js';
 /* eslint-disable security/detect-object-injection */
 const PREFIX = LOG_PREFIX.EDIT;
+/**
+ * WU-1039: Validate which edits are allowed on done WUs
+ *
+ * Done WUs only allow metadata reassignment: initiative, phase, and exposure.
+ * All other edits are blocked to preserve WU immutability after completion.
+ *
+ * @param opts - Parsed CLI options
+ * @returns { valid: boolean, disallowedEdits: string[] }
+ */
+export function validateDoneWUEdits(opts) {
+    const disallowedEdits = [];
+    // Check for disallowed edits on done WUs
+    if (opts.specFile)
+        disallowedEdits.push('--spec-file');
+    if (opts.description)
+        disallowedEdits.push('--description');
+    if (opts.acceptance && Array.isArray(opts.acceptance) && opts.acceptance.length > 0) {
+        disallowedEdits.push('--acceptance');
+    }
+    if (opts.notes)
+        disallowedEdits.push('--notes');
+    if (opts.codePaths && Array.isArray(opts.codePaths) && opts.codePaths.length > 0) {
+        disallowedEdits.push('--code-paths');
+    }
+    if (opts.lane)
+        disallowedEdits.push('--lane');
+    if (opts.type)
+        disallowedEdits.push('--type');
+    if (opts.priority)
+        disallowedEdits.push('--priority');
+    if (opts.testPathsManual &&
+        Array.isArray(opts.testPathsManual) &&
+        opts.testPathsManual.length > 0) {
+        disallowedEdits.push('--test-paths-manual');
+    }
+    if (opts.testPathsUnit && Array.isArray(opts.testPathsUnit) && opts.testPathsUnit.length > 0) {
+        disallowedEdits.push('--test-paths-unit');
+    }
+    if (opts.testPathsE2e && Array.isArray(opts.testPathsE2e) && opts.testPathsE2e.length > 0) {
+        disallowedEdits.push('--test-paths-e2e');
+    }
+    return {
+        valid: disallowedEdits.length === 0,
+        disallowedEdits,
+    };
+}
+/**
+ * WU-1039: Validate exposure value against schema
+ *
+ * Uses WU_EXPOSURE_VALUES from core constants (Library-First, no magic strings).
+ *
+ * @param exposure - Exposure value to validate
+ * @returns { valid: boolean, error?: string }
+ */
+export function validateExposureValue(exposure) {
+    // WU_EXPOSURE_VALUES is readonly array, need to cast for includes check
+    const validValues = WU_EXPOSURE_VALUES;
+    if (!validValues.includes(exposure)) {
+        return {
+            valid: false,
+            error: `Invalid exposure value: "${exposure}"\n\nValid values: ${WU_EXPOSURE_VALUES.join(', ')}`,
+        };
+    }
+    return { valid: true };
+}
+/**
+ * WU-1039: Apply exposure edit to WU object
+ *
+ * Returns a new WU object with updated exposure (immutable pattern).
+ *
+ * @param wu - Original WU object
+ * @param exposure - New exposure value
+ * @returns Updated WU object (does not mutate original)
+ */
+export function applyExposureEdit(wu, exposure) {
+    return {
+        ...wu,
+        exposure,
+    };
+}
 /**
  * Custom options for wu-edit (not in shared WU_OPTIONS)
  */
@@ -244,6 +327,8 @@ function parseArgs() {
             // WU-2564: Add blocked_by and dependencies
             EDIT_OPTIONS.blockedBy,
             EDIT_OPTIONS.addDep,
+            // WU-1039: Add exposure for done WU metadata updates
+            WU_OPTIONS.exposure,
         ],
         required: ['id'],
         allowPositionalId: true,
@@ -629,6 +714,14 @@ function applyEdits(wu, opts) {
             .filter(Boolean);
         updated.dependencies = mergeArrayField(wu.dependencies, depIds, opts.append);
     }
+    // WU-1039: Handle --exposure flag with validation
+    if (opts.exposure) {
+        const exposureResult = validateExposureValue(opts.exposure);
+        if (!exposureResult.valid) {
+            die(exposureResult.error);
+        }
+        updated.exposure = opts.exposure;
+    }
     return updated;
 }
 /**
@@ -642,38 +735,18 @@ async function main() {
     // Validate inputs
     validateWUIDFormat(id);
     const { wu: originalWU, editMode, isDone } = validateWUEditable(id);
-    // WU-1929: Done WUs only allow initiative/phase edits (metadata reassignment)
+    // WU-1039: Done WUs allow initiative/phase/exposure edits only (metadata reassignment)
+    // Uses validateDoneWUEdits (DRY - centralized validation logic)
     if (isDone) {
-        const disallowedEdits = [];
-        if (opts.specFile)
-            disallowedEdits.push('--spec-file');
-        if (opts.description)
-            disallowedEdits.push('--description');
-        if (opts.acceptance && opts.acceptance.length > 0)
-            disallowedEdits.push('--acceptance');
-        if (opts.notes)
-            disallowedEdits.push('--notes');
-        if (opts.codePaths && opts.codePaths.length > 0)
-            disallowedEdits.push('--code-paths');
-        if (opts.lane)
-            disallowedEdits.push('--lane');
-        if (opts.type)
-            disallowedEdits.push('--type');
-        if (opts.priority)
-            disallowedEdits.push('--priority');
-        if (opts.testPathsManual && opts.testPathsManual.length > 0)
-            disallowedEdits.push('--test-paths-manual');
-        if (opts.testPathsUnit && opts.testPathsUnit.length > 0)
-            disallowedEdits.push('--test-paths-unit');
-        if (opts.testPathsE2e && opts.testPathsE2e.length > 0)
-            disallowedEdits.push('--test-paths-e2e');
-        if (disallowedEdits.length > 0) {
+        const doneValidation = validateDoneWUEdits(opts);
+        if (!doneValidation.valid) {
             die(`Cannot edit WU ${id}: WU is done/immutable.\n\n` +
-                `Completed WUs only allow initiative/phase reassignment.\n` +
-                `Disallowed edits: ${disallowedEdits.join(', ')}\n\n` +
+                `Completed WUs only allow initiative/phase/exposure reassignment.\n` +
+                `Disallowed edits: ${doneValidation.disallowedEdits.join(', ')}\n\n` +
                 `Allowed for done WUs:\n` +
                 `  --initiative <initId>     Reassign to different initiative\n` +
-                `  --phase <number>          Update phase within initiative`);
+                `  --phase <number>          Update phase within initiative\n` +
+                `  --exposure <type>         Update exposure level`);
         }
     }
     // Check we have something to edit
@@ -698,7 +771,9 @@ async function main() {
         opts.phase ||
         // WU-2564: Add blocked_by and add_dep to hasEdits check
         opts.blockedBy ||
-        opts.addDep;
+        opts.addDep ||
+        // WU-1039: Add exposure to hasEdits check
+        opts.exposure;
     if (!hasEdits) {
         die('No edits specified.\n\n' +
             'Provide one of:\n' +
@@ -716,7 +791,8 @@ async function main() {
             '  --test-paths-unit <path>  Add unit test paths (repeatable; use --append to add)\n' +
             '  --test-paths-e2e <path>   Add e2e test paths (repeatable; use --append to add)\n' +
             '  --blocked-by <wuIds>      WU IDs that block this WU (comma-separated; use --append to add)\n' +
-            '  --add-dep <wuIds>         Add WU IDs to dependencies (comma-separated; use --append to add)');
+            '  --add-dep <wuIds>         Add WU IDs to dependencies (comma-separated; use --append to add)\n' +
+            '  --exposure <type>         Update exposure level (ui, api, backend-only, documentation)');
     }
     // Apply edits to get updated WU
     const updatedWU = applyEdits(originalWU, opts);
@@ -814,39 +890,54 @@ async function main() {
         const oldInitiative = originalWU.initiative;
         const newInitiative = opts.initiative;
         const initiativeChanged = newInitiative && newInitiative !== oldInitiative;
-        await withMicroWorktree({
-            operation: MICRO_WORKTREE_OPERATIONS.WU_EDIT,
-            id: id,
-            logPrefix: PREFIX,
-            execute: async ({ worktreePath }) => {
-                const files = [WU_PATHS.WU(id)];
-                // Write updated WU to micro-worktree (WU-1750: use normalized data)
-                const wuPath = join(worktreePath, WU_PATHS.WU(id));
-                // WU-1442: Normalize dates before dumping to prevent ISO timestamp corruption
-                normalizeWUDates(normalizedWU);
-                // Emergency fix Session 2: Use centralized stringifyYAML helper
-                const yamlContent = stringifyYAML(normalizedWU);
-                // eslint-disable-next-line security/detect-non-literal-fs-filename -- CLI tool writes WU files
-                writeFileSync(wuPath, yamlContent, { encoding: FILE_SYSTEM.ENCODING });
-                console.log(`${PREFIX} ✅ Updated ${id}.yaml in micro-worktree`);
-                // WU-1929: Handle bidirectional initiative updates
-                if (initiativeChanged) {
-                    const initiativeFiles = updateInitiativeWusArrays(worktreePath, id, oldInitiative, newInitiative);
-                    files.push(...initiativeFiles);
-                }
-                return {
-                    commitMessage: COMMIT_FORMATS.EDIT(id),
-                    files,
-                };
-            },
-        });
+        const previousWuTool = process.env.LUMENFLOW_WU_TOOL;
+        process.env.LUMENFLOW_WU_TOOL = MICRO_WORKTREE_OPERATIONS.WU_EDIT;
+        try {
+            await withMicroWorktree({
+                operation: MICRO_WORKTREE_OPERATIONS.WU_EDIT,
+                id: id,
+                logPrefix: PREFIX,
+                execute: async ({ worktreePath }) => {
+                    const files = [WU_PATHS.WU(id)];
+                    // Write updated WU to micro-worktree (WU-1750: use normalized data)
+                    const wuPath = join(worktreePath, WU_PATHS.WU(id));
+                    // WU-1442: Normalize dates before dumping to prevent ISO timestamp corruption
+                    normalizeWUDates(normalizedWU);
+                    // Emergency fix Session 2: Use centralized stringifyYAML helper
+                    const yamlContent = stringifyYAML(normalizedWU);
+                    // eslint-disable-next-line security/detect-non-literal-fs-filename -- CLI tool writes WU files
+                    writeFileSync(wuPath, yamlContent, { encoding: FILE_SYSTEM.ENCODING });
+                    console.log(`${PREFIX} ✅ Updated ${id}.yaml in micro-worktree`);
+                    // WU-1929: Handle bidirectional initiative updates
+                    if (initiativeChanged) {
+                        const initiativeFiles = updateInitiativeWusArrays(worktreePath, id, oldInitiative, newInitiative);
+                        files.push(...initiativeFiles);
+                    }
+                    return {
+                        commitMessage: COMMIT_FORMATS.EDIT(id),
+                        files,
+                    };
+                },
+            });
+        }
+        finally {
+            if (previousWuTool === undefined) {
+                delete process.env.LUMENFLOW_WU_TOOL;
+            }
+            else {
+                process.env.LUMENFLOW_WU_TOOL = previousWuTool;
+            }
+        }
         console.log(`${PREFIX} ✅ Successfully edited ${id}`);
         console.log(`${PREFIX} Changes pushed to origin/main`);
         // WU-1620: Display readiness summary
         displayReadinessSummary(id);
     }
 }
-main().catch((err) => {
-    console.error(`${PREFIX} ❌ ${err.message}`);
-    process.exit(EXIT_CODES.ERROR);
-});
+// Guard main() execution for testability (WU-1366)
+if (process.argv[1] === fileURLToPath(import.meta.url)) {
+    main().catch((err) => {
+        console.error(`${PREFIX} ❌ ${err.message}`);
+        process.exit(EXIT_CODES.ERROR);
+    });
+}

package/dist/wu-infer-lane.js

@@ -16,7 +16,7 @@
  */
 import { readFileSync, existsSync } from 'node:fs';
 import path from 'node:path';
-import yaml from 'js-yaml';
+import { parseYAML } from '@lumenflow/core/dist/wu-yaml.js';
 import { inferSubLane } from '@lumenflow/core/dist/lane-inference.js';
 import { die } from '@lumenflow/core/dist/error-handler.js';
 import { FILE_SYSTEM, EXIT_CODES } from '@lumenflow/core/dist/wu-constants.js';
@@ -81,7 +81,7 @@ function loadWuYaml(id) {
             `  2. Ensure you have read access to the repository`);
     }
     try {
-        const doc = yaml.load(content);
+        const doc = parseYAML(content);
         return doc;
     }
     catch (err) {
@@ -93,7 +93,7 @@ function loadWuYaml(id) {
             `  2. Fix YAML errors manually and retry`);
     }
 }
-function main() {
+async function main() {
     const args = parseArgs(process.argv);
     let codePaths = [];
     let description = '';
@@ -130,6 +130,7 @@ function main() {
 }
 // Guard main() for testability (WU-1366)
 import { fileURLToPath } from 'node:url';
+import { runCLI } from './cli-entry-point.js';
 if (process.argv[1] === fileURLToPath(import.meta.url)) {
-    main();
+    runCLI(main);
 }

package/dist/wu-preflight.js

@@ -160,8 +160,9 @@ async function main() {
     process.exit(EXIT_CODES.SUCCESS);
 }
 // Guard main() for testability
+import { runCLI } from './cli-entry-point.js';
 if (process.argv[1] === fileURLToPath(import.meta.url)) {
-    main();
+    runCLI(main);
 }
 // Export for testing
 export { parseArgs, detectWorktreePath };

package/dist/wu-prune.js

@@ -19,8 +19,8 @@ import { readWUYaml, validateBranchName, extractWUFromBranch, } from '@lumenflow
 import { WU_PATHS } from '@lumenflow/core/dist/wu-paths.js';
 import { die } from '@lumenflow/core/dist/error-handler.js';
 import { getGitForCwd } from '@lumenflow/core/dist/git-adapter.js';
-import { detectOrphanWorktrees, removeOrphanDirectory, } from '@lumenflow/core/dist/orphan-detector.js';
-import { BRANCHES, WU_STATUS, CLI_FLAGS, EXIT_CODES, STRING_LITERALS, EMOJI, LOG_PREFIX, } from '@lumenflow/core/dist/wu-constants.js';
+import { detectOrphanWorktrees, detectMissingTrackedWorktrees, removeOrphanDirectory, } from '@lumenflow/core/dist/orphan-detector.js';
+import { BRANCHES, WU_STATUS, CLI_FLAGS, EXIT_CODES, STRING_LITERALS, EMOJI, LOG_PREFIX, WORKTREE_WARNINGS, } from '@lumenflow/core/dist/wu-constants.js';
 function parseArgs(argv) {
     const args = { dryRun: true }; // Default to dry-run for safety
     for (let i = 2; i < argv.length; i++) {
@@ -145,6 +145,14 @@ This tool:
     }
     console.log(`${PREFIX} Worktree Hygiene Check`);
     console.log(`${PREFIX} =====================\n`);
+    const missingTracked = await detectMissingTrackedWorktrees(process.cwd());
+    if (missingTracked.length > 0) {
+        console.warn(`${PREFIX} ${EMOJI.WARNING} ${WORKTREE_WARNINGS.MISSING_TRACKED_HEADER}`);
+        for (const missingPath of missingTracked) {
+            console.warn(`${PREFIX} ${WORKTREE_WARNINGS.MISSING_TRACKED_LINE(missingPath)}`);
+        }
+        console.warn('');
+    }
     if (args.dryRun) {
         console.log(`${PREFIX} ${EMOJI.INFO} DRY-RUN MODE (use --execute to apply changes)\n`);
     }
@@ -254,6 +262,7 @@ This tool:
 }
 // Guard main() for testability (WU-1366)
 import { fileURLToPath } from 'node:url';
+import { runCLI } from './cli-entry-point.js';
 if (process.argv[1] === fileURLToPath(import.meta.url)) {
-    main();
+    runCLI(main);
 }

package/dist/wu-repair.js

@@ -219,8 +219,9 @@ async function main() {
 }
 // Guard main() for testability (WU-1366)
 import { fileURLToPath } from 'node:url';
+import { runCLI } from './cli-entry-point.js';
 if (process.argv[1] === fileURLToPath(import.meta.url)) {
-    main();
+    runCLI(main);
 }
 // Export for testing
 export { normaliseWUId, isValidWUId };