@lumenflow/cli 2.2.2 → 2.3.1

package/dist/wu-edit.js

@@ -24,9 +24,8 @@
  *   pnpm wu:edit --id WU-123 --acceptance "Criterion 1" --acceptance "Criterion 2"
  *
  * Part of WU-1274: Add wu:edit command for spec-only changes
- * @see {@link tools/lib/micro-worktree.mjs} - Shared micro-worktree logic
+ * @see {@link packages/@lumenflow/cli/src/lib/micro-worktree.ts} - 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';
@@ -182,19 +181,30 @@ const EDIT_OPTIONS = {
     codePaths: {
         name: 'codePaths',
         flags: '--code-paths <path>',
-        description: 'Code path (repeatable, replaces existing; use --append to add)',
+        description: 'Code path (repeatable, appends to existing; use --replace-code-paths to overwrite)',
         isRepeatable: true,
     },
+    replaceCodePaths: {
+        name: 'replaceCodePaths',
+        flags: '--replace-code-paths',
+        description: 'Replace existing code_paths instead of appending',
+    },
     risks: {
         name: 'risks',
         flags: '--risks <risk>',
-        description: 'Risk entry (repeatable, replaces existing; use --append to add)',
+        description: 'Risk entry (repeatable, appends to existing; use --replace-risks to overwrite)',
         isRepeatable: true,
     },
+    replaceRisks: {
+        name: 'replaceRisks',
+        flags: '--replace-risks',
+        description: 'Replace existing risks instead of appending',
+    },
+    // WU-1225: Deprecated --append flag (kept for backwards compatibility)
     append: {
         name: 'append',
         flags: '--append',
-        description: 'Append to existing array values instead of replacing (for --code-paths, --test-paths-*, --blocked-by, --add-dep)',
+        description: '[DEPRECATED] Arrays now append by default. Use --replace-* flags to replace.',
     },
     // WU-1456: Add lane reassignment support
     lane: {
@@ -228,12 +238,22 @@ const EDIT_OPTIONS = {
     blockedBy: {
         name: 'blockedBy',
         flags: '--blocked-by <wuIds>',
-        description: 'Comma-separated WU IDs that block this WU (replaces existing; use --append to add)',
+        description: 'Comma-separated WU IDs that block this WU (appends to existing; use --replace-blocked-by to overwrite)',
+    },
+    replaceBlockedBy: {
+        name: 'replaceBlockedBy',
+        flags: '--replace-blocked-by',
+        description: 'Replace existing blocked_by instead of appending',
     },
     addDep: {
         name: 'addDep',
         flags: '--add-dep <wuIds>',
-        description: 'Comma-separated WU IDs to add to dependencies array (replaces existing; use --append to add)',
+        description: 'Comma-separated WU IDs to add to dependencies array (appends to existing; use --replace-dependencies to overwrite)',
+    },
+    replaceDependencies: {
+        name: 'replaceDependencies',
+        flags: '--replace-dependencies',
+        description: 'Replace existing dependencies instead of appending',
     },
 };
 /**
@@ -334,7 +354,9 @@ function parseArgs() {
             EDIT_OPTIONS.replaceNotes,
             EDIT_OPTIONS.replaceAcceptance,
             EDIT_OPTIONS.codePaths,
+            EDIT_OPTIONS.replaceCodePaths,
             EDIT_OPTIONS.risks,
+            EDIT_OPTIONS.replaceRisks,
             EDIT_OPTIONS.append,
             // WU-1390: Add test path flags
             WU_OPTIONS.testPathsManual,
@@ -350,7 +372,9 @@ function parseArgs() {
             EDIT_OPTIONS.phase,
             // WU-2564: Add blocked_by and dependencies
             EDIT_OPTIONS.blockedBy,
+            EDIT_OPTIONS.replaceBlockedBy,
             EDIT_OPTIONS.addDep,
+            EDIT_OPTIONS.replaceDependencies,
             // WU-1039: Add exposure for done WU metadata updates
             WU_OPTIONS.exposure,
         ],
@@ -702,7 +726,7 @@ export function applyEdits(wu, opts) {
         }
         updated.phase = phaseNum;
     }
-    // Handle repeatable --code-paths flags (WU-1388: replace by default, append with --append)
+    // Handle repeatable --code-paths flags (WU-1225: append by default, replace with --replace-code-paths)
     // WU-1816: Split comma-separated string into array (same pattern as test paths)
     // WU-1870: Fix to split comma-separated values WITHIN array elements (Commander passes ['a,b'] not 'a,b')
     if (opts.codePaths && opts.codePaths.length > 0) {
@@ -716,9 +740,12 @@ export function applyEdits(wu, opts) {
                 .split(',')
                 .map((p) => p.trim())
                 .filter(Boolean);
-        updated.code_paths = mergeArrayField(wu.code_paths, codePaths, opts.append);
+        // WU-1225: Invert logic - append by default, replace with --replace-code-paths
+        // Also support legacy --append flag for backwards compatibility
+        const shouldAppend = !opts.replaceCodePaths || opts.append;
+        updated.code_paths = mergeArrayField(wu.code_paths, codePaths, shouldAppend);
     }
-    // WU-1073: Handle repeatable --risks flags (replace by default, append with --append)
+    // WU-1225: Handle repeatable --risks flags (append by default, replace with --replace-risks)
     // Split comma-separated values within each entry for consistency with other list fields
     if (opts.risks && opts.risks.length > 0) {
         const rawRisks = opts.risks;
@@ -731,9 +758,12 @@ export function applyEdits(wu, opts) {
                 .split(',')
                 .map((risk) => risk.trim())
                 .filter(Boolean);
-        updated.risks = mergeArrayField(wu.risks, risks, opts.append);
+        // WU-1225: Invert logic - append by default
+        const shouldAppend = !opts.replaceRisks || opts.append;
+        updated.risks = mergeArrayField(wu.risks, risks, shouldAppend);
     }
     // WU-1390: Handle test path flags (DRY refactor)
+    // WU-1225: Test paths now append by default (consistent with --acceptance and --code-paths)
     const testPathMappings = [
         { optKey: 'testPathsManual', field: 'manual' },
         { optKey: 'testPathsUnit', field: 'unit' },
@@ -754,28 +784,32 @@ export function applyEdits(wu, opts) {
                     .map((p) => p.trim())
                     .filter(Boolean);
             updated.tests = updated.tests || {};
-            updated.tests[field] = mergeArrayField(wu.tests?.[field], paths, opts.append);
+            // WU-1225: Append by default (no individual replace flags for test paths yet)
+            const shouldAppend = true;
+            updated.tests[field] = mergeArrayField(wu.tests?.[field], paths, shouldAppend);
         }
     }
     // WU-2564: Handle --blocked-by flag
-    // Comma-separated WU IDs that block this WU
+    // WU-1225: Append by default, replace with --replace-blocked-by
     if (opts.blockedBy) {
         const rawBlockedBy = opts.blockedBy;
         const blockedByIds = rawBlockedBy
             .split(',')
             .map((id) => id.trim())
             .filter(Boolean);
-        updated.blocked_by = mergeArrayField(wu.blocked_by, blockedByIds, opts.append);
+        const shouldAppend = !opts.replaceBlockedBy || opts.append;
+        updated.blocked_by = mergeArrayField(wu.blocked_by, blockedByIds, shouldAppend);
     }
     // WU-2564: Handle --add-dep flag
-    // Comma-separated WU IDs to add to dependencies array
+    // WU-1225: Append by default, replace with --replace-dependencies
     if (opts.addDep) {
         const rawAddDep = opts.addDep;
         const depIds = rawAddDep
             .split(',')
             .map((id) => id.trim())
             .filter(Boolean);
-        updated.dependencies = mergeArrayField(wu.dependencies, depIds, opts.append);
+        const shouldAppend = !opts.replaceDependencies || opts.append;
+        updated.dependencies = mergeArrayField(wu.dependencies, depIds, shouldAppend);
     }
     // WU-1039: Handle --exposure flag with validation
     if (opts.exposure) {
@@ -845,21 +879,20 @@ async function main() {
             '  --description <text>      Update description field\n' +
             '  --acceptance <text>       Append acceptance criteria (repeatable; use --replace-acceptance to overwrite)\n' +
             '  --notes <text>            Append to notes (use --replace-notes to overwrite)\n' +
-            '  --replace-notes           Replace existing notes instead of appending\n' +
-            '  --replace-acceptance      Replace existing acceptance instead of appending\n' +
-            '  --code-paths <paths>      Replace code paths (repeatable; use --append to add)\n' +
-            '  --risks <risk>            Replace risks (repeatable; use --append to add)\n' +
+            '  --code-paths <paths>      Append code paths (repeatable; use --replace-code-paths to overwrite)\n' +
+            '  --risks <risk>            Append risks (repeatable; use --replace-risks to overwrite)\n' +
             '  --lane <lane>             Update lane assignment (e.g., "Operations: Tooling")\n' +
             '  --type <type>             Update WU type (feature, bug, refactor, documentation)\n' +
             '  --priority <priority>     Update priority (P0, P1, P2, P3)\n' +
             '  --initiative <initId>     Update initiative (bidirectional update)\n' +
             '  --phase <number>          Update phase within initiative\n' +
-            '  --test-paths-manual <t>   Add manual test descriptions (repeatable; use --append to add)\n' +
-            '  --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)\n' +
-            '  --exposure <type>         Update exposure level (ui, api, backend-only, documentation)');
+            '  --test-paths-manual <t>   Append manual test descriptions (repeatable)\n' +
+            '  --test-paths-unit <path>  Append unit test paths (repeatable)\n' +
+            '  --test-paths-e2e <path>   Append e2e test paths (repeatable)\n' +
+            '  --blocked-by <wuIds>      Append WU IDs that block this WU (use --replace-blocked-by to overwrite)\n' +
+            '  --add-dep <wuIds>         Append WU IDs to dependencies (use --replace-dependencies to overwrite)\n' +
+            '  --exposure <type>         Update exposure level (ui, api, backend-only, documentation)\n\n' +
+            'Note: All array fields now append by default (WU-1225). Use --replace-* flags to overwrite.');
     }
     // Apply edits to get updated WU
     const updatedWU = applyEdits(originalWU, opts);
@@ -1001,8 +1034,10 @@ async function main() {
         displayReadinessSummary(id);
     }
 }
-// Guard main() execution for testability (WU-1366)
-if (process.argv[1] === fileURLToPath(import.meta.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
+if (import.meta.main) {
     main().catch((err) => {
         console.error(`${PREFIX} ❌ ${err.message}`);
         process.exit(EXIT_CODES.ERROR);

package/dist/wu-infer-lane.js

@@ -3,14 +3,14 @@
  * WU Lane Inference CLI (WU-908)
  *
  * Suggests sub-lane for a WU based on code paths and description.
- * Wrapper around lib/lane-inference.mjs for standalone CLI usage.
+ * Wrapper around lib/lane-inference.ts for standalone CLI usage.
  *
  * Usage:
  *   # Infer from existing WU
- *   node tools/wu-infer-lane.mjs --id WU-123
+ *   node tools/wu-infer-lane.ts --id WU-123
  *
  *   # Infer from manual inputs
- *   node tools/wu-infer-lane.mjs --paths "tools/**" "docs/**" --desc "Tooling improvements"
+ *   node tools/wu-infer-lane.ts --paths "tools/**" "docs/**" --desc "Tooling improvements"
  *
  * Returns suggested lane and confidence score (0-100).
  */
@@ -128,9 +128,10 @@ async function main() {
         die(`Lane inference failed: ${err.message}`);
     }
 }
-// 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);
 }

package/dist/wu-preflight.js

@@ -5,6 +5,9 @@
  * WU-1803: Fast validation of code_paths and test paths before gates run.
  * Completes in under 5 seconds vs 2+ minutes for full gates.
  *
+ * WU-1180: Migrated from deprecated parseWUArgs to createWUParser for
+ * proper Commander --help output and consistency with other WU commands.
+ *
  * This catches YAML mismatches early, preventing wasted time running full
  * gates only to fail on code_paths validation at the end of wu:done.
  *
@@ -17,78 +20,14 @@
  *   - test file paths exist (unit, e2e, integration)
  *   - WU YAML schema is valid
  */
-import { fileURLToPath } from 'node:url';
 import { existsSync } from 'node:fs';
-import { parseWUArgs } from '@lumenflow/core/dist/arg-parser.js';
+import { createWUParser, WU_OPTIONS } from '@lumenflow/core/dist/arg-parser.js';
 import { validatePreflight, formatPreflightResult, } from '@lumenflow/core/dist/wu-preflight-validators.js';
 import { PATTERNS, EXIT_CODES, LOG_PREFIX, EMOJI } from '@lumenflow/core/dist/wu-constants.js';
 import { defaultWorktreeFrom, WU_PATHS } from '@lumenflow/core/dist/wu-paths.js';
 import { readWURaw } from '@lumenflow/core/dist/wu-yaml.js';
+import { die } from '@lumenflow/core/dist/error-handler.js';
 /* eslint-disable security/detect-non-literal-fs-filename */
-/**
- * Parse command-line arguments
- * @param {string[]} argv - Process arguments
- * @returns {object} Parsed arguments
- */
-function parseArgs(argv) {
-    const args = parseWUArgs(argv);
-    // Handle help
-    if (args.help) {
-        return { help: true };
-    }
-    // Validate WU ID
-    if (!args.id) {
-        return { error: 'Missing required argument: --id WU-XXX' };
-    }
-    const id = args.id.toUpperCase();
-    if (!PATTERNS.WU_ID.test(id)) {
-        return { error: `Invalid WU ID format: ${args.id}. Expected WU-NNN` };
-    }
-    return {
-        id,
-        worktree: args.worktree || null,
-        help: false,
-    };
-}
-/**
- * Display help message
- */
-function showHelp() {
-    console.log(`
-WU Preflight Validation - Fast code_paths and test paths check
-
-Usage:
-  pnpm wu:preflight --id WU-XXX [OPTIONS]
-
-Options:
-  --id <WU-ID>           WU ID to validate (required)
-  --worktree <path>      Worktree path to validate files in (auto-detected if not provided)
-  --help, -h             Show this help
-
-Description:
-  Validates code_paths and test file paths exist BEFORE running full gates.
-  Completes in under 5 seconds vs 2+ minutes for gates.
-
-  This prevents wasting time running full gates only to fail on
-  code_paths validation at the end of wu:done.
-
-Checks performed:
-  ${EMOJI.SUCCESS} code_paths files exist in worktree/main
-  ${EMOJI.SUCCESS} Test file paths exist (unit, e2e, integration)
-  ${EMOJI.SUCCESS} WU YAML schema is valid (required fields present)
-  ${EMOJI.SUCCESS} Manual tests are skipped (descriptions, not files)
-
-Recommended workflow:
-  1. Implement feature/fix
-  2. Run: pnpm wu:preflight --id WU-XXX  (fast check)
-  3. Run: pnpm gates                      (full validation)
-  4. Run: pnpm wu:done --id WU-XXX        (complete WU)
-
-Example:
-  pnpm wu:preflight --id WU-1803
-  pnpm wu:preflight --id WU-1803 --worktree worktrees/operations-gates-wu-1803
-`);
-}
 /**
  * Detect worktree path from WU YAML or calculate from lane
  * @param {string} id - WU ID
@@ -116,23 +55,23 @@ function detectWorktreePath(id) {
  */
 async function main() {
     const PREFIX = LOG_PREFIX.PREFLIGHT;
-    const args = parseArgs(process.argv);
-    // Handle help
-    if (args.help) {
-        showHelp();
-        process.exit(EXIT_CODES.SUCCESS);
-    }
-    // Handle parse errors
-    if (args.error) {
-        console.error(`${PREFIX} ${EMOJI.FAILURE} ${args.error}`);
-        console.error(`${PREFIX} Run: pnpm wu:preflight --help for usage`);
-        process.exit(EXIT_CODES.ERROR);
+    // WU-1180: Use createWUParser for proper Commander help output
+    const args = createWUParser({
+        name: 'wu-preflight',
+        description: 'Fast validation of code_paths and test paths before gates run. ' +
+            'Completes in under 5 seconds vs 2+ minutes for full gates.',
+        options: [WU_OPTIONS.id, WU_OPTIONS.worktree],
+        required: ['id'],
+        allowPositionalId: true,
+    });
+    const id = args.id.toUpperCase();
+    if (!PATTERNS.WU_ID.test(id)) {
+        die(`Invalid WU ID format: ${args.id}. Expected WU-NNN`);
     }
-    const { id, worktree } = args;
     console.log(`${PREFIX} Preflight Validation for ${id}`);
     console.log(`${PREFIX} ${'='.repeat(30)}\n`);
     // Determine worktree path
-    let worktreePath = worktree;
+    let worktreePath = args.worktree || null;
     if (!worktreePath) {
         worktreePath = detectWorktreePath(id);
         if (worktreePath) {
@@ -160,9 +99,12 @@ async function main() {
     process.exit(EXIT_CODES.SUCCESS);
 }
 // Guard main() for testability
+// WU-1071: 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);
 }
 // Export for testing
-export { parseArgs, detectWorktreePath };
+export { detectWorktreePath };

package/dist/wu-prep.js

@@ -0,0 +1,125 @@
+#!/usr/bin/env node
+/**
+ * WU Prep Helper (WU-1223)
+ *
+ * Prepares a WU for completion by running gates and generating docs in the worktree.
+ * After successful prep, prints copy-paste instruction to run wu:done from main.
+ *
+ * Workflow:
+ * 1. Verify we're in a worktree (error if in main checkout)
+ * 2. Run gates in the worktree
+ * 3. Generate docs (if applicable)
+ * 4. Print copy-paste instruction for wu:done from main
+ *
+ * Usage:
+ *   pnpm wu:prep --id WU-XXX [--docs-only]
+ *
+ * @module
+ */
+import { createWUParser, WU_OPTIONS } from '@lumenflow/core/dist/arg-parser.js';
+import { die } from '@lumenflow/core/dist/error-handler.js';
+import { resolveLocation } from '@lumenflow/core/dist/context/location-resolver.js';
+import { readWU } from '@lumenflow/core/dist/wu-yaml.js';
+import { WU_PATHS } from '@lumenflow/core/dist/wu-paths.js';
+import { CONTEXT_VALIDATION, PATTERNS, EXIT_CODES, WU_STATUS, EMOJI, } from '@lumenflow/core/dist/wu-constants.js';
+import { runGates } from './gates.js';
+const { LOCATION_TYPES } = CONTEXT_VALIDATION;
+/**
+ * Log prefix for wu:prep command output.
+ */
+const PREP_PREFIX = '[wu-prep]';
+/**
+ * GATES_OPTIONS for wu:prep command.
+ * Subset of gates options relevant for prep.
+ */
+const PREP_OPTIONS = {
+    docsOnly: {
+        name: 'docsOnly',
+        flags: '--docs-only',
+        description: 'Run docs-only gates (format, spec-linter)',
+    },
+};
+/**
+ * Print success message with copy-paste instruction.
+ */
+function printSuccessMessage(wuId, mainCheckout) {
+    console.log('');
+    console.log(`${PREP_PREFIX} ${EMOJI.SUCCESS} ${wuId}: Prep completed successfully!`);
+    console.log('');
+    console.log(`${PREP_PREFIX} Gates passed in worktree.`);
+    console.log('');
+    console.log(`${PREP_PREFIX} Next step - copy and paste this command:`);
+    console.log('');
+    console.log(`    cd ${mainCheckout} && pnpm wu:done --id ${wuId}`);
+    console.log('');
+}
+/**
+ * Main entry point.
+ */
+async function main() {
+    // Parse arguments
+    const args = createWUParser({
+        name: 'wu-prep',
+        description: 'Prepare WU for completion (run gates in worktree)',
+        options: [WU_OPTIONS.id, PREP_OPTIONS.docsOnly],
+        required: ['id'],
+        allowPositionalId: true,
+    });
+    const id = args.id.toUpperCase();
+    if (!PATTERNS.WU_ID.test(id)) {
+        die(`Invalid WU id '${args.id}'. Expected format WU-123`);
+    }
+    // Detect location
+    const location = await resolveLocation();
+    // WU-1223: wu:prep MUST be run from worktree, not main
+    if (location.type !== LOCATION_TYPES.WORKTREE) {
+        die(`${EMOJI.FAILURE} wu:prep must be run from a worktree, not ${location.type}.\n\n` +
+            `Current location: ${location.cwd}\n\n` +
+            `If you have a worktree for ${id}, navigate to it first:\n` +
+            `  cd worktrees/<lane>-${id.toLowerCase()}\n\n` +
+            `If you don't have a worktree yet, claim the WU first:\n` +
+            `  pnpm wu:claim --id ${id} --lane "<lane>"`);
+    }
+    // Verify the worktree is for the correct WU
+    if (location.worktreeWuId && location.worktreeWuId !== id) {
+        console.warn(`${PREP_PREFIX} ${EMOJI.WARNING} Worktree is for ${location.worktreeWuId}, but you specified ${id}.`);
+        console.warn(`${PREP_PREFIX} Proceeding with ${id} as specified.`);
+    }
+    // Read WU YAML to validate it exists and check status
+    const wuPath = WU_PATHS.WU(id);
+    let doc;
+    try {
+        doc = readWU(wuPath, id);
+    }
+    catch (error) {
+        die(`Failed to read WU ${id}: ${error.message}\n\n` +
+            `Options:\n` +
+            `  1. Check if WU file exists: ls -la ${wuPath}\n` +
+            `  2. Validate YAML syntax: pnpm wu:validate --id ${id}`);
+    }
+    // Validate WU status is in_progress
+    if (doc.status !== WU_STATUS.IN_PROGRESS) {
+        die(`${EMOJI.FAILURE} WU ${id} status is '${doc.status}', expected '${WU_STATUS.IN_PROGRESS}'.\n\n` +
+            `wu:prep can only be run on WUs that are in progress.`);
+    }
+    console.log(`${PREP_PREFIX} Preparing ${id} for completion...`);
+    console.log(`${PREP_PREFIX} Location: ${location.cwd}`);
+    console.log(`${PREP_PREFIX} Main checkout: ${location.mainCheckout}`);
+    console.log('');
+    // Run gates in the worktree
+    console.log(`${PREP_PREFIX} Running gates in worktree...`);
+    const gatesResult = await runGates({
+        cwd: location.cwd,
+        docsOnly: args.docsOnly,
+    });
+    if (!gatesResult) {
+        die(`${EMOJI.FAILURE} Gates failed in worktree.\n\n` +
+            `Fix the gate failures and run wu:prep again.`);
+    }
+    // Success - print copy-paste instruction
+    printSuccessMessage(id, location.mainCheckout);
+}
+main().catch((e) => {
+    console.error(e.message);
+    process.exit(EXIT_CODES.ERROR);
+});

package/dist/wu-prune.js

@@ -260,9 +260,10 @@ This tool:
     }
     process.exit(totalErrors > 0 ? EXIT_CODES.ERROR : EXIT_CODES.SUCCESS);
 }
-// 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);
 }