@lumenflow/core 2.2.1 → 2.3.1

package/dist/test-baseline.js

@@ -0,0 +1,282 @@
+/**
+ * Test Baseline - Test Ratchet Pattern (WU-1253)
+ *
+ * Implements a "ratchet" pattern for test failures:
+ * - Track known failures in a baseline file (.lumenflow/test-baseline.json)
+ * - Block NEW failures (not in baseline)
+ * - Allow pre-existing failures with warning
+ * - Auto-update baseline when tests are fixed (ratchet forward)
+ *
+ * This enables agents to work on WUs without being blocked by unrelated
+ * test failures, while still preventing introduction of NEW failures.
+ *
+ * @see https://lumenflow.dev/reference/test-ratchet/
+ */
+import { z } from 'zod';
+import { parseISO, isValid } from 'date-fns';
+// ============================================================================
+// Constants
+// ============================================================================
+/** Default path for the test baseline file */
+export const DEFAULT_BASELINE_PATH = '.lumenflow/test-baseline.json';
+/** Environment variable to override baseline path */
+export const BASELINE_PATH_ENV = 'LUMENFLOW_TEST_BASELINE';
+/** Current schema version */
+export const BASELINE_VERSION = 1;
+/**
+ * Zod schema for ISO8601 datetime strings.
+ * Uses date-fns (well-maintained library) for validation instead of regex.
+ */
+const isoDateTimeString = z.string().refine((val) => {
+    const parsed = parseISO(val);
+    return isValid(parsed);
+}, { message: 'Invalid ISO8601 datetime string' });
+// ============================================================================
+// Schema Definitions
+// ============================================================================
+/**
+ * Schema for a known test failure entry
+ */
+export const KnownFailureSchema = z.object({
+    /** Name of the failing test (describe > it format) */
+    test_name: z.string().min(1),
+    /** Path to the test file */
+    file_path: z.string().min(1),
+    /** Why this failure is in the baseline */
+    failure_reason: z.string().min(1),
+    /** When this failure was added to baseline */
+    added_at: isoDateTimeString,
+    /** Which WU added this to baseline */
+    added_by_wu: z.string().regex(/^WU-\d+$/),
+    /** WU expected to fix this failure (optional) */
+    expected_fix_wu: z
+        .string()
+        .regex(/^WU-\d+$/)
+        .optional(),
+    /** Optional reason for skipping this test */
+    skip_reason: z.string().optional(),
+});
+/**
+ * Schema for baseline statistics
+ */
+export const BaselineStatsSchema = z.object({
+    /** Total number of known failures */
+    total_known_failures: z.number().int().min(0),
+    /** Last time the baseline ratcheted forward (tests fixed) */
+    last_ratchet_forward: isoDateTimeString.optional(),
+});
+/**
+ * Schema for the complete test baseline file
+ */
+export const TestBaselineSchema = z.object({
+    /** Schema version for future migrations */
+    version: z.literal(BASELINE_VERSION),
+    /** When the baseline was last updated */
+    updated_at: isoDateTimeString,
+    /** Which WU last updated the baseline */
+    updated_by: z.string().regex(/^WU-\d+$/),
+    /** List of known test failures */
+    known_failures: z.array(KnownFailureSchema),
+    /** Baseline statistics */
+    stats: BaselineStatsSchema,
+});
+// ============================================================================
+// Core Functions
+// ============================================================================
+/**
+ * Parse a test baseline JSON string
+ *
+ * @param json - JSON string content of baseline file
+ * @returns Parse result with baseline data or error
+ */
+export function parseTestBaseline(json) {
+    let parsed;
+    try {
+        parsed = JSON.parse(json);
+    }
+    catch (e) {
+        return {
+            success: false,
+            error: `Invalid JSON: ${e instanceof Error ? e.message : 'Unknown error'}`,
+        };
+    }
+    const result = TestBaselineSchema.safeParse(parsed);
+    if (!result.success) {
+        return {
+            success: false,
+            error: `Schema validation failed: ${result.error.message}`,
+        };
+    }
+    return { success: true, data: result.data };
+}
+/**
+ * Create a new test baseline
+ *
+ * @param wuId - WU creating the baseline
+ * @param initialFailures - Optional initial failures to add
+ * @returns New test baseline
+ */
+export function createTestBaseline(wuId, initialFailures) {
+    const now = new Date().toISOString();
+    const knownFailures = (initialFailures ?? []).map((f) => ({
+        test_name: f.test_name,
+        file_path: f.file_path,
+        failure_reason: f.failure_reason,
+        added_at: now,
+        added_by_wu: wuId,
+        expected_fix_wu: f.expected_fix_wu,
+    }));
+    return {
+        version: BASELINE_VERSION,
+        updated_at: now,
+        updated_by: wuId,
+        known_failures: knownFailures,
+        stats: {
+            total_known_failures: knownFailures.length,
+        },
+    };
+}
+/**
+ * Compare current test results against the baseline
+ *
+ * This is the core ratchet logic:
+ * - NEW failures (not in baseline) block the gate
+ * - Pre-existing failures (in baseline) show warning
+ * - Fixed tests (in baseline but now passing) trigger ratchet forward
+ *
+ * @param baseline - The test baseline
+ * @param currentFailures - Current test failures from test run
+ * @returns Comparison result
+ */
+export function compareTestResults(baseline, currentFailures) {
+    const failingTests = currentFailures.filter((t) => !t.passed);
+    // Build lookup sets for efficient comparison
+    const baselineTestNames = new Set(baseline.known_failures.map((f) => f.test_name));
+    const currentFailingNames = new Set(failingTests.map((f) => f.test_name));
+    // Find NEW failures (in current failures, NOT in baseline)
+    const newFailures = failingTests.filter((f) => !baselineTestNames.has(f.test_name));
+    // Find pre-existing failures (in current failures AND in baseline)
+    const preExistingFailures = baseline.known_failures.filter((f) => currentFailingNames.has(f.test_name));
+    // Find fixed tests (in baseline but NOT in current failures)
+    const fixedTests = baseline.known_failures.filter((f) => !currentFailingNames.has(f.test_name));
+    return {
+        newFailures,
+        preExistingFailures,
+        fixedTests,
+        shouldBlock: newFailures.length > 0,
+        hasWarnings: preExistingFailures.length > 0,
+        shouldRatchetForward: fixedTests.length > 0,
+    };
+}
+/**
+ * Update the baseline (ratchet forward or add new known failures)
+ *
+ * @param baseline - Current baseline
+ * @param wuId - WU making the update
+ * @param options - Update options
+ * @returns Updated baseline (immutable)
+ */
+export function updateBaseline(baseline, wuId, options) {
+    const now = new Date().toISOString();
+    const { fixedTests = [], newKnownFailures = [] } = options;
+    // Remove fixed tests (ratchet forward)
+    const fixedTestSet = new Set(fixedTests);
+    let knownFailures = baseline.known_failures.filter((f) => !fixedTestSet.has(f.test_name));
+    // Add new known failures
+    const newEntries = newKnownFailures.map((f) => ({
+        test_name: f.test_name,
+        file_path: f.file_path,
+        failure_reason: f.failure_reason,
+        added_at: now,
+        added_by_wu: wuId,
+        expected_fix_wu: f.expected_fix_wu,
+    }));
+    knownFailures = [...knownFailures, ...newEntries];
+    const stats = {
+        total_known_failures: knownFailures.length,
+    };
+    // Record ratchet forward if we removed tests
+    if (fixedTests.length > 0) {
+        stats.last_ratchet_forward = now;
+    }
+    return {
+        version: BASELINE_VERSION,
+        updated_at: now,
+        updated_by: wuId,
+        known_failures: knownFailures,
+        stats,
+    };
+}
+// ============================================================================
+// Formatting Functions
+// ============================================================================
+/**
+ * Format a warning message for pre-existing failures
+ *
+ * @param preExisting - Pre-existing failures from baseline
+ * @returns Formatted warning string
+ */
+export function formatBaselineWarning(preExisting) {
+    const lines = [
+        '',
+        '='.repeat(70),
+        '  Pre-existing test failures (from baseline)',
+        '='.repeat(70),
+        '',
+        `  These failures are tracked in .lumenflow/test-baseline.json`,
+        '  They do not block your WU, but should be fixed eventually.',
+        '',
+    ];
+    for (const failure of preExisting) {
+        lines.push(`  - ${failure.test_name}`);
+        lines.push(`    File: ${failure.file_path}`);
+        lines.push(`    Reason: ${failure.failure_reason}`);
+        if (failure.expected_fix_wu) {
+            lines.push(`    Expected fix: ${failure.expected_fix_wu}`);
+        }
+        lines.push('');
+    }
+    lines.push('='.repeat(70));
+    return lines.join('\n');
+}
+/**
+ * Format an error message for new failures
+ *
+ * @param newFailures - New test failures
+ * @returns Formatted error string
+ */
+export function formatNewFailureError(newFailures) {
+    const lines = [
+        '',
+        '='.repeat(70),
+        '  NEW test failure(s) detected!',
+        '='.repeat(70),
+        '',
+        '  The following tests failed and are NOT in the baseline.',
+        '  This blocks your WU from completion.',
+        '',
+        '  Options:',
+        '    1. Fix the test or add to baseline with:',
+        '       pnpm baseline:add --test "<test_name>" --reason "<why>" --fix-wu WU-XXXX',
+        '    2. If this is a pre-existing failure on main, it should be in the baseline.',
+        '',
+    ];
+    for (const failure of newFailures) {
+        lines.push(`  - ${failure.test_name}`);
+        lines.push(`    File: ${failure.file_path}`);
+        if (failure.error_message) {
+            lines.push(`    Error: ${failure.error_message.substring(0, 100)}...`);
+        }
+        lines.push('');
+    }
+    lines.push('='.repeat(70));
+    return lines.join('\n');
+}
+/**
+ * Get the path to the test baseline file
+ *
+ * @returns Baseline file path
+ */
+export function getBaselineFilePath() {
+    return process.env[BASELINE_PATH_ENV] ?? DEFAULT_BASELINE_PATH;
+}

package/dist/usecases/get-suggestions.usecase.d.ts

@@ -29,7 +29,7 @@ export interface GetSuggestionsOptions {
      * When provided, suggestions for high-impact WUs are ranked higher
      * within the same priority level.
      *
-     * @see flow-bottlenecks.mjs for score calculation
+     * @see flow-bottlenecks.ts for score calculation
      */
     bottleneckScores?: BottleneckScores;
 }

package/dist/validation/command-registry.js

@@ -92,8 +92,44 @@ const wuClaim = {
         ];
     },
 };
+/**
+ * Predicate: Check if worktree has no uncommitted changes.
+ * For wu:prep running from worktree itself.
+ */
+const gitCleanPredicate = {
+    id: 'git-clean',
+    description: 'Worktree must not have uncommitted changes',
+    severity: SEVERITY.ERROR,
+    check: (context) => !context.git.isDirty,
+    getFixMessage: () => 'Commit or stash changes in worktree before running wu:prep',
+};
+/**
+ * Command definition for wu:prep (WU-1223).
+ *
+ * Runs gates and generates docs in the worktree, then prints copy-paste
+ * instruction to run wu:done from main checkout for merge/cleanup.
+ */
+const wuPrep = {
+    name: COMMANDS.WU_PREP,
+    description: 'Run gates + docs in worktree, prepare for wu:done',
+    requiredLocation: LOCATION_TYPES.WORKTREE,
+    requiredWuStatus: WU_STATUS.IN_PROGRESS,
+    predicates: [gitCleanPredicate, stateConsistentPredicate],
+    getNextSteps: (context) => {
+        const mainPath = context.location.mainCheckout || '/path/to/main';
+        const wuId = context.wu?.id || 'WU-XXX';
+        return [
+            `1. Gates and docs generated in worktree`,
+            `2. Return to main checkout and complete:`,
+            `   cd ${mainPath} && pnpm wu:done --id ${wuId}`,
+        ];
+    },
+};
 /**
  * Command definition for wu:done.
+ *
+ * WU-1223: Now requires main checkout (merge + cleanup only).
+ * Use wu:prep from worktree for gates and docs generation.
  */
 const wuDone = {
     name: COMMANDS.WU_DONE,
@@ -161,6 +197,7 @@ const wuRecover = {
 export const COMMAND_REGISTRY = new Map([
     [COMMANDS.WU_CREATE, wuCreate],
     [COMMANDS.WU_CLAIM, wuClaim],
+    [COMMANDS.WU_PREP, wuPrep],
     [COMMANDS.WU_DONE, wuDone],
     [COMMANDS.WU_BLOCK, wuBlock],
     [COMMANDS.WU_UNBLOCK, wuUnblock],

package/dist/validators/backlog-sync.d.ts

@@ -0,0 +1,14 @@
+/**
+ * @file backlog-sync.ts
+ * @description Validates backlog.md is in sync with WU YAML files (WU-1111)
+ */
+export interface BacklogSyncResult {
+    valid: boolean;
+    errors: string[];
+    warnings: string[];
+    wuCount: number;
+    backlogCount: number;
+}
+export declare function validateBacklogSync(options?: {
+    cwd?: string;
+}): Promise<BacklogSyncResult>;

package/dist/validators/backlog-sync.js

@@ -0,0 +1,62 @@
+/**
+ * @file backlog-sync.ts
+ * @description Validates backlog.md is in sync with WU YAML files (WU-1111)
+ */
+import { existsSync, readFileSync, readdirSync } from 'node:fs';
+import path from 'node:path';
+import { FILE_SYSTEM } from '../wu-constants.js';
+import { createWuPaths } from '../wu-paths.js';
+function extractWUIDsFromBacklog(content) {
+    const wuIds = [];
+    const pattern = /WU-\d+/gi;
+    let match;
+    while ((match = pattern.exec(content)) !== null) {
+        const wuId = match[0].toUpperCase();
+        if (!wuIds.includes(wuId)) {
+            wuIds.push(wuId);
+        }
+    }
+    return wuIds;
+}
+function getWUIDsFromFiles(wuDir) {
+    if (!existsSync(wuDir)) {
+        return [];
+    }
+    return readdirSync(wuDir)
+        .filter((f) => f.endsWith('.yaml'))
+        .map((f) => f.replace('.yaml', '').toUpperCase());
+}
+export async function validateBacklogSync(options = {}) {
+    const { cwd = process.cwd() } = options;
+    const errors = [];
+    const warnings = [];
+    const paths = createWuPaths({ projectRoot: cwd });
+    const backlogPath = path.join(cwd, paths.BACKLOG());
+    const wuDir = path.join(cwd, paths.WU_DIR());
+    if (!existsSync(backlogPath)) {
+        errors.push(`Backlog file not found: ${backlogPath}`);
+        return { valid: false, errors, warnings, wuCount: 0, backlogCount: 0 };
+    }
+    const wuIdsFromFiles = getWUIDsFromFiles(wuDir);
+    const backlogContent = readFileSync(backlogPath, {
+        encoding: FILE_SYSTEM.UTF8,
+    });
+    const wuIdsFromBacklog = extractWUIDsFromBacklog(backlogContent);
+    for (const wuId of wuIdsFromFiles) {
+        if (!wuIdsFromBacklog.includes(wuId)) {
+            errors.push(`${wuId} not found in backlog.md (exists as ${wuId}.yaml)`);
+        }
+    }
+    for (const wuId of wuIdsFromBacklog) {
+        if (!wuIdsFromFiles.includes(wuId)) {
+            warnings.push(`${wuId} referenced in backlog.md but ${wuId}.yaml not found`);
+        }
+    }
+    return {
+        valid: errors.length === 0,
+        errors,
+        warnings,
+        wuCount: wuIdsFromFiles.length,
+        backlogCount: wuIdsFromBacklog.length,
+    };
+}

package/dist/validators/supabase-docs-linter.d.ts

@@ -0,0 +1,18 @@
+/**
+ * @file supabase-docs-linter.ts
+ * @description Runs Supabase docs linter when available (optional in consumer repos)
+ */
+export interface SupabaseDocsLinterResult {
+    ok: boolean;
+    skipped: boolean;
+    message?: string;
+    errors?: string[];
+}
+export interface SupabaseDocsLinterOptions {
+    cwd?: string;
+    logger?: {
+        log: (message: string) => void;
+        warn?: (message: string) => void;
+    };
+}
+export declare function runSupabaseDocsLinter(options?: SupabaseDocsLinterOptions): Promise<SupabaseDocsLinterResult>;

package/dist/validators/supabase-docs-linter.js

@@ -0,0 +1,42 @@
+/**
+ * @file supabase-docs-linter.ts
+ * @description Runs Supabase docs linter when available (optional in consumer repos)
+ */
+import { existsSync } from 'node:fs';
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+export async function runSupabaseDocsLinter(options = {}) {
+    const { cwd = process.cwd(), logger = console } = options;
+    const linterPath = path.join(cwd, 'packages', 'linters', 'supabase-docs-linter.js');
+    if (!existsSync(linterPath)) {
+        return {
+            ok: true,
+            skipped: true,
+            message: 'Supabase docs linter not found; skipping.',
+        };
+    }
+    const moduleUrl = pathToFileURL(linterPath).href;
+    const module = await import(moduleUrl);
+    const runFn = module.runSupabaseDocsLinter ?? module.default;
+    if (typeof runFn !== 'function') {
+        return {
+            ok: false,
+            skipped: false,
+            errors: ['Supabase docs linter does not export runSupabaseDocsLinter.'],
+        };
+    }
+    const result = await runFn({ cwd, logger });
+    if (result && typeof result === 'object' && 'ok' in result) {
+        return {
+            ok: Boolean(result.ok),
+            skipped: Boolean(result.skipped),
+            message: result.message,
+            errors: result.errors,
+        };
+    }
+    return {
+        ok: true,
+        skipped: false,
+        message: 'Supabase docs linter completed.',
+    };
+}

package/dist/validators/wu-tasks.d.ts

@@ -0,0 +1,24 @@
+/**
+ * @file wu-tasks.ts
+ * @description WU YAML validation helpers (shared by CLI and preflight)
+ */
+export interface ValidationResult {
+    valid: boolean;
+    warnings: string[];
+    errors: string[];
+}
+export interface ValidationSummary {
+    totalValid: number;
+    totalInvalid: number;
+    totalWarnings: number;
+    results: Array<{
+        wuId: string;
+    } & ValidationResult>;
+}
+export declare function validateSingleWU(wuPath: string, options?: {
+    strict?: boolean;
+}): ValidationResult;
+export declare function validateAllWUs(options?: {
+    strict?: boolean;
+    doneOnly?: boolean;
+}): ValidationSummary;

package/dist/validators/wu-tasks.js

@@ -0,0 +1,90 @@
+/**
+ * @file wu-tasks.ts
+ * @description WU YAML validation helpers (shared by CLI and preflight)
+ */
+import { existsSync, readFileSync, readdirSync } from 'node:fs';
+import { WU_PATHS } from '../wu-paths.js';
+import { parseYAML } from '../wu-yaml.js';
+import { validateWU, validateWUCompleteness } from '../wu-schema.js';
+import { FILE_SYSTEM } from '../wu-constants.js';
+export function validateSingleWU(wuPath, options = {}) {
+    const { strict = false } = options;
+    const errors = [];
+    const warnings = [];
+    if (!existsSync(wuPath)) {
+        errors.push(`WU file not found: ${wuPath}`);
+        return { valid: false, warnings, errors };
+    }
+    let doc;
+    try {
+        const text = readFileSync(wuPath, { encoding: FILE_SYSTEM.UTF8 });
+        doc = parseYAML(text);
+    }
+    catch (e) {
+        errors.push(`Failed to parse YAML: ${e.message}`);
+        return { valid: false, warnings, errors };
+    }
+    const schemaResult = validateWU(doc);
+    if (!schemaResult.success) {
+        const schemaErrors = schemaResult.error.issues.map((issue) => `${issue.path.join('.')}: ${issue.message}`);
+        errors.push(...schemaErrors);
+        return { valid: false, warnings, errors };
+    }
+    const completenessResult = validateWUCompleteness(schemaResult.data);
+    warnings.push(...completenessResult.warnings);
+    if (strict && warnings.length > 0) {
+        errors.push(...warnings.map((w) => `[STRICT] ${w}`));
+        return { valid: false, warnings: [], errors };
+    }
+    return { valid: true, warnings, errors };
+}
+export function validateAllWUs(options = {}) {
+    const { strict = false, doneOnly = false } = options;
+    const wuDir = WU_PATHS.WU_DIR();
+    if (!existsSync(wuDir)) {
+        return {
+            totalValid: 0,
+            totalInvalid: 1,
+            totalWarnings: 0,
+            results: [
+                {
+                    wuId: 'DIRECTORY',
+                    valid: false,
+                    warnings: [],
+                    errors: [`WU directory not found: ${wuDir}`],
+                },
+            ],
+        };
+    }
+    const files = readdirSync(wuDir).filter((f) => f.endsWith('.yaml'));
+    const results = [];
+    let totalValid = 0;
+    let totalInvalid = 0;
+    let totalWarnings = 0;
+    for (const file of files) {
+        const wuPath = `${wuDir}/${file}`;
+        const wuId = file.replace('.yaml', '');
+        if (doneOnly) {
+            try {
+                const text = readFileSync(wuPath, { encoding: FILE_SYSTEM.UTF8 });
+                const doc = parseYAML(text);
+                if (doc.status !== 'done') {
+                    continue;
+                }
+            }
+            catch {
+                // If we can't read, still validate to catch the error
+            }
+        }
+        const result = validateSingleWU(wuPath, { strict });
+        results.push({ wuId, ...result });
+        if (result.valid) {
+            totalValid++;
+            totalWarnings += result.warnings.length;
+        }
+        else {
+            totalInvalid++;
+        }
+    }
+    return { totalValid, totalInvalid, totalWarnings, results };
+}

package/dist/worktree-scanner.d.ts

@@ -10,7 +10,7 @@
  * - Reports last activity timestamp
  * - Identifies potentially abandoned WUs
  *
- * @see {@link tools/lib/__tests__/worktree-scanner.test.mjs} - Tests
+ * @see {@link packages/@lumenflow/cli/src/lib/__tests__/worktree-scanner.test.ts} - Tests
  */
 /**
  * @typedef {object} WorktreeInfo

package/dist/worktree-scanner.js

@@ -10,7 +10,7 @@
  * - Reports last activity timestamp
  * - Identifies potentially abandoned WUs
  *
- * @see {@link tools/lib/__tests__/worktree-scanner.test.mjs} - Tests
+ * @see {@link packages/@lumenflow/cli/src/lib/__tests__/worktree-scanner.test.ts} - Tests
  */
 import { exec } from 'node:child_process';
 import { promisify } from 'node:util';

package/dist/worktree-symlink.d.ts

@@ -10,7 +10,7 @@
  * auto-create the node_modules symlink pointing to the main repo's
  * node_modules directory, including nested package node_modules.
  *
- * @module tools/lib/worktree-symlink.mjs
+ * @module tools/lib/worktree-symlink.ts
  */
 /**
  * List of nested package/app paths that have their own node_modules
@@ -55,7 +55,7 @@ export declare function hasWorktreePathSymlinks(nodeModulesPath: any): {
  * @returns {{created: boolean, skipped: boolean, refused?: boolean, reason?: string, error?: Error}}
  *
  * @example
- * // In wu-claim.mjs after worktree creation:
+ * // In wu-claim.ts after worktree creation:
  * symlinkNodeModules('/path/to/worktrees/operations-tooling-wu-1443');
  */
 export declare function symlinkNodeModules(worktreePath: any, logger?: Console, mainRepoPath?: any): {
@@ -90,7 +90,7 @@ export declare function symlinkNodeModules(worktreePath: any, logger?: Console,
  * @returns {{created: number, skipped: number, errors: Error[]}}
  *
  * @example
- * // In wu-claim.mjs after worktree creation:
+ * // In wu-claim.ts after worktree creation:
  * symlinkNestedNodeModules(
  *   '/path/to/worktrees/operations-tooling-wu-1579',
  *   '/path/to/main-repo'

package/dist/worktree-symlink.js

@@ -10,7 +10,7 @@
  * auto-create the node_modules symlink pointing to the main repo's
  * node_modules directory, including nested package node_modules.
  *
- * @module tools/lib/worktree-symlink.mjs
+ * @module tools/lib/worktree-symlink.ts
  */
 import fs from 'node:fs';
 import path from 'node:path';
@@ -202,7 +202,7 @@ function checkMainNodeModulesHealth(mainRepoPath, logger) {
  * @returns {{created: boolean, skipped: boolean, refused?: boolean, reason?: string, error?: Error}}
  *
  * @example
- * // In wu-claim.mjs after worktree creation:
+ * // In wu-claim.ts after worktree creation:
  * symlinkNodeModules('/path/to/worktrees/operations-tooling-wu-1443');
  */
 export function symlinkNodeModules(worktreePath, logger = console, mainRepoPath = null) {
@@ -310,7 +310,7 @@ function handleExistingNestedNodeModules(targetNodeModules, pkgPath, logger, err
  * @returns {{created: number, skipped: number, errors: Error[]}}
  *
  * @example
- * // In wu-claim.mjs after worktree creation:
+ * // In wu-claim.ts after worktree creation:
  * symlinkNestedNodeModules(
  *   '/path/to/worktrees/operations-tooling-wu-1579',
  *   '/path/to/main-repo'

package/dist/wu-backlog-updater.d.ts

@@ -1,7 +1,7 @@
 /**
  * Backlog.md Update Utilities
  *
- * Centralized backlog.md update functions (extracted from wu-done.mjs)
+ * Centralized backlog.md update functions (extracted from wu-done.ts)
  * Refactored to use BacklogManager (WU-1212) for AST-based manipulation
  *
  * Used by both main wu:done flow AND recovery mode (DRY principle)