@lumenflow/core 2.3.2 → 2.5.0

package/dist/micro-worktree.js

@@ -32,7 +32,9 @@ import { existsSync, rmSync, mkdtempSync } from 'node:fs';
 import { execSync } from 'node:child_process';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
+import pRetry from 'p-retry';
 import { BRANCHES, REMOTES, GIT_REFS, PKG_MANAGER, SCRIPTS, PRETTIER_FLAGS, STDIO_MODES, } from './wu-constants.js';
+import { getConfig } from './lumenflow-config.js';
 /**
  * Maximum retry attempts for ff-only merge when main moves
  *
@@ -46,8 +48,23 @@ export const MAX_MERGE_RETRIES = 3;
  * WU-1179: When push fails due to race condition (origin advanced while we
  * were working), rollback local main to origin/main and retry.
  * Each retry: fetch -> rebase temp branch -> re-merge -> push.
+ *
+ * @deprecated Use DEFAULT_PUSH_RETRY_CONFIG.retries instead (WU-1332)
  */
 export const MAX_PUSH_RETRIES = 3;
+/**
+ * WU-1332: Default push retry configuration
+ *
+ * Provides sensible defaults for micro-worktree push operations.
+ * Can be overridden via .lumenflow.config.yaml git.push_retry section.
+ */
+export const DEFAULT_PUSH_RETRY_CONFIG = {
+    enabled: true,
+    retries: 3,
+    min_delay_ms: 100,
+    max_delay_ms: 1000,
+    jitter: true,
+};
 /**
  * Environment variable name for LUMENFLOW_FORCE bypass
  *
@@ -66,6 +83,130 @@ export const LUMENFLOW_FORCE_REASON_ENV = 'LUMENFLOW_FORCE_REASON';
  * Extracted to constant to satisfy sonarjs/no-duplicate-string rule.
  */
 export const DEFAULT_LOG_PREFIX = '[micro-wt]';
+/**
+ * WU-1336: Pattern to detect retry exhaustion errors from error messages
+ *
+ * Matches error messages like "Push failed after N attempts"
+ * Used for backwards compatibility with legacy error messages.
+ */
+const RETRY_EXHAUSTION_PATTERN = /Push failed after \d+ attempts/;
+/**
+ * WU-1336: Typed error for retry exhaustion in micro-worktree operations
+ *
+ * Thrown when push retries are exhausted due to race conditions with parallel agents.
+ * CLI commands should use `isRetryExhaustionError` to detect this error type and
+ * `formatRetryExhaustionError` to generate actionable user-facing messages.
+ *
+ * This centralizes retry exhaustion handling so CLI commands do not need to
+ * duplicate detection logic or error formatting.
+ *
+ * @example
+ * ```typescript
+ * import { RetryExhaustionError, isRetryExhaustionError, formatRetryExhaustionError } from '@lumenflow/core';
+ *
+ * try {
+ *   await withMicroWorktree({ ... });
+ * } catch (error) {
+ *   if (isRetryExhaustionError(error)) {
+ *     console.error(formatRetryExhaustionError(error, { command: 'pnpm initiative:add-wu ...' }));
+ *   } else {
+ *     throw error;
+ *   }
+ * }
+ * ```
+ */
+export class RetryExhaustionError extends Error {
+    /** Name of the error class (for instanceof checks across module boundaries) */
+    name = 'RetryExhaustionError';
+    /** Operation that was being performed (e.g., 'initiative-add-wu') */
+    operation;
+    /** Number of retry attempts that were exhausted */
+    retries;
+    constructor(operation, retries) {
+        super(`Push failed after ${retries} attempts. ` +
+            `Origin main may have significant traffic during ${operation}.`);
+        this.operation = operation;
+        this.retries = retries;
+        // Maintain proper prototype chain for instanceof checks
+        Object.setPrototypeOf(this, RetryExhaustionError.prototype);
+    }
+}
+/**
+ * WU-1336: Type guard to check if an error is a retry exhaustion error
+ *
+ * Detects both the typed `RetryExhaustionError` class and legacy error messages
+ * that match the "Push failed after N attempts" pattern.
+ *
+ * @param {unknown} error - Error to check
+ * @returns {boolean} True if this is a retry exhaustion error
+ *
+ * @example
+ * ```typescript
+ * if (isRetryExhaustionError(error)) {
+ *   // Handle retry exhaustion
+ * }
+ * ```
+ */
+export function isRetryExhaustionError(error) {
+    if (error instanceof RetryExhaustionError) {
+        return true;
+    }
+    // Also detect legacy error messages for backwards compatibility
+    if (error instanceof Error) {
+        return RETRY_EXHAUSTION_PATTERN.test(error.message);
+    }
+    return false;
+}
+/**
+ * WU-1336: Format retry exhaustion error with actionable next steps
+ *
+ * When push retries are exhausted, provides clear guidance on how to proceed.
+ * CLI commands should use this instead of duplicating error formatting logic.
+ *
+ * @param {Error} error - The retry exhaustion error
+ * @param {FormatRetryExhaustionOptions} options - Formatting options
+ * @returns {string} Formatted error message with next steps
+ *
+ * @example
+ * ```typescript
+ * const message = formatRetryExhaustionError(error, {
+ *   command: 'pnpm initiative:add-wu --wu WU-123 --initiative INIT-001',
+ * });
+ * console.error(message);
+ * ```
+ */
+export function formatRetryExhaustionError(error, options) {
+    const { command } = options;
+    return (`${error.message}\n\n` +
+        `Next steps:\n` +
+        `  1. Wait a few seconds and retry the operation:\n` +
+        `     ${command}\n` +
+        `  2. If the issue persists, check if another agent is rapidly pushing changes\n` +
+        `  3. Consider increasing git.push_retry.retries in .lumenflow.config.yaml`);
+}
+/**
+ * WU-1308: Check if remote operations should be skipped based on git.requireRemote config
+ *
+ * When git.requireRemote is false, micro-worktree operations skip:
+ * - Fetching origin/main before starting
+ * - Pushing to origin/main after completion
+ *
+ * This enables local-only development without a remote repository.
+ *
+ * @returns {boolean} True if remote operations should be skipped (requireRemote=false)
+ *
+ * @example
+ * ```yaml
+ * # .lumenflow.config.yaml
+ * git:
+ *   requireRemote: false  # Enable local-only mode
+ * ```
+ */
+export function shouldSkipRemoteOperations() {
+    const config = getConfig();
+    // Default is requireRemote=true, so only skip if explicitly set to false
+    return config.git.requireRemote === false;
+}
 /**
  * Temp branch prefix for micro-worktree operations
  *
@@ -392,15 +533,17 @@ export async function mergeWithRetry(tempBranchName, microWorktreePath, logPrefi
  * @throws {Error} If push fails after all retries
  */
 export async function pushWithRetry(mainGit, worktreeGit, remote, branch, tempBranchName, logPrefix = DEFAULT_LOG_PREFIX) {
-    for (let attempt = 1; attempt <= MAX_PUSH_RETRIES; attempt++) {
+    // eslint-disable-next-line sonarjs/deprecation -- Using deprecated constant for backwards compatibility
+    const maxRetries = MAX_PUSH_RETRIES;
+    for (let attempt = 1; attempt <= maxRetries; attempt++) {
         try {
-            console.log(`${logPrefix} Pushing to ${remote}/${branch} (attempt ${attempt}/${MAX_PUSH_RETRIES})...`);
+            console.log(`${logPrefix} Pushing to ${remote}/${branch} (attempt ${attempt}/${maxRetries})...`);
             await mainGit.push(remote, branch);
             console.log(`${logPrefix} ✅ Pushed to ${remote}/${branch}`);
             return;
         }
         catch (pushErr) {
-            if (attempt < MAX_PUSH_RETRIES) {
+            if (attempt < maxRetries) {
                 console.log(`${logPrefix} ⚠️  Push failed (origin moved). Rolling back and retrying...`);
                 // Step 1: Rollback local main to origin/main
                 console.log(`${logPrefix} Rolling back local ${branch} to ${remote}/${branch}...`);
@@ -420,13 +563,86 @@ export async function pushWithRetry(mainGit, worktreeGit, remote, branch, tempBr
             }
             else {
                 const errMsg = pushErr instanceof Error ? pushErr.message : String(pushErr);
-                throw new Error(`Push failed after ${MAX_PUSH_RETRIES} attempts. ` +
+                throw new Error(`Push failed after ${maxRetries} attempts. ` +
                     `Origin ${branch} may have significant traffic.\n` +
                     `Error: ${errMsg}`);
             }
         }
     }
 }
+/**
+ * WU-1332: Push to origin with configurable retry using p-retry
+ *
+ * Enhanced version of pushWithRetry that uses p-retry for exponential backoff
+ * and supports configuration via PushRetryConfig. When push fails due to
+ * non-fast-forward (origin moved), automatically rebases and retries.
+ *
+ * @param {Object} mainGit - GitAdapter instance for main checkout
+ * @param {Object} worktreeGit - GitAdapter instance for micro-worktree
+ * @param {string} remote - Remote name (e.g., 'origin')
+ * @param {string} branch - Branch name (e.g., 'main')
+ * @param {string} tempBranchName - Temp branch that was merged (for rebase)
+ * @param {string} logPrefix - Log prefix for console output
+ * @param {PushRetryConfig} config - Push retry configuration
+ * @throws {Error} If push fails after all retries or if retry is disabled
+ */
+export async function pushWithRetryConfig(mainGit, worktreeGit, remote, branch, tempBranchName, logPrefix = DEFAULT_LOG_PREFIX, config = DEFAULT_PUSH_RETRY_CONFIG) {
+    // If retry is disabled, just try once and throw on failure
+    if (!config.enabled) {
+        console.log(`${logPrefix} Pushing to ${remote}/${branch} (retry disabled)...`);
+        await mainGit.push(remote, branch);
+        console.log(`${logPrefix} ✅ Pushed to ${remote}/${branch}`);
+        return;
+    }
+    let attemptNumber = 0;
+    await pRetry(async () => {
+        attemptNumber++;
+        console.log(`${logPrefix} Pushing to ${remote}/${branch} (attempt ${attemptNumber}/${config.retries})...`);
+        try {
+            await mainGit.push(remote, branch);
+            console.log(`${logPrefix} ✅ Pushed to ${remote}/${branch}`);
+        }
+        catch (pushErr) {
+            console.log(`${logPrefix} ⚠️  Push failed (origin moved). Rolling back and retrying...`);
+            // Rollback local main to origin/main
+            console.log(`${logPrefix} Rolling back local ${branch} to ${remote}/${branch}...`);
+            await mainGit.reset(`${remote}/${branch}`, { hard: true });
+            // Fetch latest origin/main
+            console.log(`${logPrefix} Fetching ${remote}/${branch}...`);
+            await mainGit.fetch(remote, branch);
+            // Update local main to match origin/main (ff-only)
+            console.log(`${logPrefix} Updating local ${branch}...`);
+            await mainGit.merge(`${remote}/${branch}`, { ffOnly: true });
+            // Rebase temp branch onto updated main
+            console.log(`${logPrefix} Rebasing temp branch onto ${branch}...`);
+            await worktreeGit.rebase(branch);
+            // Re-merge temp branch to local main
+            console.log(`${logPrefix} Re-merging temp branch to ${branch}...`);
+            await mainGit.merge(tempBranchName, { ffOnly: true });
+            // Re-throw to trigger p-retry
+            throw pushErr;
+        }
+    }, {
+        retries: config.retries - 1, // p-retry counts retries after first attempt
+        minTimeout: config.min_delay_ms,
+        maxTimeout: config.max_delay_ms,
+        randomize: config.jitter,
+        onFailedAttempt: (error) => {
+            // Log is handled in the try/catch above
+            if (error.retriesLeft === 0) {
+                // This will be the final failure
+            }
+        },
+    }).catch(() => {
+        // p-retry exhausted all retries, throw descriptive error
+        throw new Error(`Push failed after ${config.retries} attempts. ` +
+            `Origin ${branch} may have significant traffic.\n\n` +
+            `Suggestions:\n` +
+            `  - Wait a few seconds and retry the operation\n` +
+            `  - Increase git.push_retry.retries in .lumenflow.config.yaml\n` +
+            `  - Check if another agent is rapidly pushing changes`);
+    });
+}
 /**
  * Push using refspec with LUMENFLOW_FORCE to bypass pre-push hooks
  *
@@ -472,6 +688,72 @@ export async function pushRefspecWithForce(gitAdapter, remote, localRef, remoteR
         }
     }
 }
+/**
+ * WU-1337: Push using refspec with LUMENFLOW_FORCE and retry logic
+ *
+ * Enhanced version of pushRefspecWithForce that adds retry with rebase
+ * on non-fast-forward errors. Uses p-retry for exponential backoff and
+ * respects git.push_retry configuration.
+ *
+ * On each retry:
+ * 1. Fetch origin/main to get latest state
+ * 2. Rebase the temp branch onto the updated main
+ * 3. Retry the push with LUMENFLOW_FORCE
+ *
+ * This is used by pushOnly mode in withMicroWorktree to handle race conditions
+ * when multiple agents are pushing to origin/main concurrently.
+ *
+ * @param {GitAdapter} gitWorktree - GitAdapter instance for the worktree (for rebase)
+ * @param {GitAdapter} mainGit - GitAdapter instance for main checkout (for fetch)
+ * @param {string} remote - Remote name (e.g., 'origin')
+ * @param {string} localRef - Local ref to push (e.g., 'tmp/wu-claim/wu-123')
+ * @param {string} remoteRef - Remote ref to update (e.g., 'main')
+ * @param {string} reason - Audit reason for the LUMENFLOW_FORCE bypass
+ * @param {string} logPrefix - Log prefix for console output
+ * @param {PushRetryConfig} config - Push retry configuration
+ * @returns {Promise<void>}
+ * @throws {RetryExhaustionError} If push fails after all retries
+ */
+export async function pushRefspecWithRetry(gitWorktree, mainGit, remote, localRef, remoteRef, reason, logPrefix = DEFAULT_LOG_PREFIX, config = DEFAULT_PUSH_RETRY_CONFIG) {
+    // If retry is disabled, just try once and throw on failure
+    if (!config.enabled) {
+        console.log(`${logPrefix} Pushing to ${remote}/${remoteRef} (push-only, retry disabled)...`);
+        await pushRefspecWithForce(gitWorktree, remote, localRef, remoteRef, reason);
+        console.log(`${logPrefix} ✅ Pushed to ${remote}/${remoteRef}`);
+        return;
+    }
+    let attemptNumber = 0;
+    await pRetry(async () => {
+        attemptNumber++;
+        console.log(`${logPrefix} Pushing to ${remote}/${remoteRef} (push-only, attempt ${attemptNumber}/${config.retries})...`);
+        try {
+            await pushRefspecWithForce(gitWorktree, remote, localRef, remoteRef, reason);
+            console.log(`${logPrefix} ✅ Pushed to ${remote}/${remoteRef}`);
+        }
+        catch (pushErr) {
+            console.log(`${logPrefix} ⚠️  Push failed (origin moved). Fetching and rebasing before retry...`);
+            // Fetch latest origin/main
+            console.log(`${logPrefix} Fetching ${remote}/${remoteRef}...`);
+            await mainGit.fetch(remote, remoteRef);
+            // Rebase temp branch onto updated main
+            console.log(`${logPrefix} Rebasing temp branch onto ${remoteRef}...`);
+            await gitWorktree.rebase(remoteRef);
+            // Re-throw to trigger p-retry
+            throw pushErr;
+        }
+    }, {
+        retries: config.retries - 1, // p-retry counts retries after first attempt
+        minTimeout: config.min_delay_ms,
+        maxTimeout: config.max_delay_ms,
+        randomize: config.jitter,
+        onFailedAttempt: () => {
+            // Logging is handled in the try/catch above
+        },
+    }).catch(() => {
+        // p-retry exhausted all retries, throw typed error
+        throw new RetryExhaustionError('push-only', config.retries);
+    });
+}
 /**
  * Execute an operation in a micro-worktree with full isolation
  *
@@ -481,6 +763,7 @@ export async function pushRefspecWithForce(gitAdapter, remote, localRef, remoteR
  *
  * WU-1435: Added pushOnly option to keep local main pristine.
  * WU-2237: Added pre-creation cleanup of orphaned temp branches/worktrees.
+ * WU-1337: Push-only path now uses retry with rebase.
  *
  * @param {Object} options - Options for the operation
  * @param {string} options.operation - Operation name (e.g., 'wu-create', 'wu-edit')
@@ -496,18 +779,24 @@ export async function pushRefspecWithForce(gitAdapter, remote, localRef, remoteR
 export async function withMicroWorktree(options) {
     const { operation, id, logPrefix = `[${operation}]`, execute, pushOnly = false } = options;
     const mainGit = getGitForCwd();
+    // WU-1308: Check if remote operations should be skipped (local-only mode)
+    const skipRemote = shouldSkipRemoteOperations();
     // WU-2237: Clean up any orphaned temp branch/worktree from previous interrupted operations
     // This makes the operation idempotent - a retry after crash/timeout will succeed
     await cleanupOrphanedMicroWorktree(operation, id, mainGit, logPrefix);
     // WU-1179: Fetch origin/main before starting to minimize race condition window
     // This ensures we start from the latest origin state, reducing push failures
-    if (!pushOnly) {
+    // WU-1308: Skip when git.requireRemote=false (local-only mode)
+    if (!pushOnly && !skipRemote) {
         console.log(`${logPrefix} Fetching ${REMOTES.ORIGIN}/${BRANCHES.MAIN} before starting...`);
         await mainGit.fetch(REMOTES.ORIGIN, BRANCHES.MAIN);
         // Update local main to match origin/main
         await mainGit.merge(`${REMOTES.ORIGIN}/${BRANCHES.MAIN}`, { ffOnly: true });
         console.log(`${logPrefix} ✅ Local main synced with ${REMOTES.ORIGIN}/${BRANCHES.MAIN}`);
     }
+    else if (skipRemote) {
+        console.log(`${logPrefix} Local-only mode (git.requireRemote=false): skipping origin sync`);
+    }
     const tempBranchName = getTempBranchName(operation, id);
     const microWorktreePath = createMicroWorktreeDir(`${operation}-`);
     console.log(`${logPrefix} Using micro-worktree isolation (WU-1262)`);
@@ -536,12 +825,22 @@ export async function withMicroWorktree(options) {
         await gitWorktree.commit(result.commitMessage);
         console.log(`${logPrefix} ✅ Committed: ${result.commitMessage}`);
         // Step 6: Push to origin (different paths for pushOnly vs standard)
-        if (pushOnly) {
+        // WU-1308: Skip push when git.requireRemote=false (local-only mode)
+        if (skipRemote) {
+            // Local-only mode: merge to local main but skip push
+            console.log(`${logPrefix} Local-only mode: merging to local main (skipping push)`);
+            await mainGit.merge(tempBranchName, { ffOnly: true });
+            console.log(`${logPrefix} ✅ Merged to local main (no remote push)`);
+            return { ...result, ref: BRANCHES.MAIN };
+        }
+        else if (pushOnly) {
             // WU-1435: Push directly to origin/main without touching local main
             // WU-1081: Use LUMENFLOW_FORCE to bypass pre-push hooks for micro-worktree pushes
-            console.log(`${logPrefix} Pushing directly to ${REMOTES.ORIGIN}/${BRANCHES.MAIN} (push-only)...`);
-            await pushRefspecWithForce(gitWorktree, REMOTES.ORIGIN, tempBranchName, BRANCHES.MAIN, `micro-worktree push for ${operation} (automated)`);
-            console.log(`${logPrefix} ✅ Pushed to ${REMOTES.ORIGIN}/${BRANCHES.MAIN}`);
+            // WU-1337: Use pushRefspecWithRetry to handle race conditions with rebase
+            // Get push_retry config from LumenFlow config
+            const config = getConfig();
+            const pushRetryConfig = config.git.push_retry || DEFAULT_PUSH_RETRY_CONFIG;
+            await pushRefspecWithRetry(gitWorktree, mainGit, REMOTES.ORIGIN, tempBranchName, BRANCHES.MAIN, `micro-worktree push for ${operation} (automated)`, logPrefix, pushRetryConfig);
             // Fetch to update remote tracking ref (FETCH_HEAD)
             console.log(`${logPrefix} Fetching ${REMOTES.ORIGIN}/${BRANCHES.MAIN}...`);
             await mainGit.fetch(REMOTES.ORIGIN, BRANCHES.MAIN);

package/dist/wu-constants.d.ts

@@ -253,6 +253,10 @@ export declare const LOG_PREFIX: {
     CONSISTENCY: string;
     PREFLIGHT: string;
     INITIATIVE_PLAN: string;
+    PLAN_CREATE: string;
+    PLAN_LINK: string;
+    PLAN_EDIT: string;
+    PLAN_PROMOTE: string;
 };
 /**
  * Consistency check types (WU-1276)
@@ -940,6 +944,8 @@ export declare const GATE_NAMES: {
     SYSTEM_MAP_VALIDATE: string;
     /** WU-1191: Lane health check (overlap detection) */
     LANE_HEALTH: string;
+    /** WU-1315: Onboarding smoke test (init + wu:create validation) */
+    ONBOARDING_SMOKE_TEST: string;
 };
 /**
  * Gate command sentinels (special values for non-shell commands)
@@ -959,6 +965,8 @@ export declare const GATE_COMMANDS: {
     SAFETY_CRITICAL_TEST: string;
     /** WU-2062: Triggers tiered test execution based on risk */
     TIERED_TEST: string;
+    /** WU-1315: Triggers onboarding smoke test */
+    ONBOARDING_SMOKE_TEST: string;
 };
 /**
  * CLI mode flags

package/dist/wu-constants.js

@@ -269,6 +269,10 @@ export const LOG_PREFIX = {
     CONSISTENCY: '[wu-consistency]',
     PREFLIGHT: '[wu-preflight]',
     INITIATIVE_PLAN: '[initiative:plan]',
+    PLAN_CREATE: '[plan:create]',
+    PLAN_LINK: '[plan:link]',
+    PLAN_EDIT: '[plan:edit]',
+    PLAN_PROMOTE: '[plan:promote]',
 };
 /**
  * Consistency check types (WU-1276)
@@ -985,6 +989,8 @@ export const GATE_NAMES = {
     SYSTEM_MAP_VALIDATE: 'system-map:validate',
     /** WU-1191: Lane health check (overlap detection) */
     LANE_HEALTH: 'lane-health',
+    /** WU-1315: Onboarding smoke test (init + wu:create validation) */
+    ONBOARDING_SMOKE_TEST: 'onboarding-smoke-test',
 };
 /**
  * Gate command sentinels (special values for non-shell commands)
@@ -1004,6 +1010,8 @@ export const GATE_COMMANDS = {
     SAFETY_CRITICAL_TEST: 'safety-critical-test',
     /** WU-2062: Triggers tiered test execution based on risk */
     TIERED_TEST: 'tiered-test',
+    /** WU-1315: Triggers onboarding smoke test */
+    ONBOARDING_SMOKE_TEST: 'onboarding-smoke-test',
 };
 /**
  * CLI mode flags

package/dist/wu-done-concurrent-merge.d.ts

@@ -86,6 +86,19 @@ export declare function mergeWithMainState(worktreeStateDir: string): Promise<WU
  * @returns Merged backlog.md content
  */
 export declare function computeBacklogContentWithMainMerge(backlogPath: string, wuId: string): Promise<string>;
+/**
+ * Compute status.md content with merged state from origin/main.
+ *
+ * WU-1319: This function generates status.md from the merged state store
+ * instead of editing the local file snapshot. This prevents reintroducing
+ * stale "In Progress" entries when concurrent WUs complete on main.
+ *
+ * @param backlogPath - Path to backlog.md in the worktree (used to find state dir)
+ * @param wuId - WU ID being completed
+ * @param mainStateDir - Optional explicit path to main state dir (for testing)
+ * @returns Merged status.md content
+ */
+export declare function computeStatusContentWithMainMerge(backlogPath: string, wuId: string, mainStateDir?: string): Promise<string>;
 /**
  * Compute wu-events.jsonl content with merged state from origin/main.
  *

package/dist/wu-done-concurrent-merge.js

@@ -15,7 +15,7 @@ import { existsSync, readFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { WUStateStore, WU_EVENTS_FILE_NAME } from './wu-state-store.js';
 import { validateWUEvent } from './wu-state-schema.js';
-import { generateBacklog } from './backlog-generator.js';
+import { generateBacklog, generateStatus } from './backlog-generator.js';
 import { getStateStoreDirFromBacklog } from './wu-paths.js';
 import { getGitForCwd } from './git-adapter.js';
 import { REMOTES, BRANCHES, BEACON_PATHS } from './wu-constants.js';
@@ -286,6 +286,46 @@ export async function computeBacklogContentWithMainMerge(backlogPath, wuId) {
     // Generate backlog from merged state
     return generateBacklog(mergedStore);
 }
+/**
+ * Compute status.md content with merged state from origin/main.
+ *
+ * WU-1319: This function generates status.md from the merged state store
+ * instead of editing the local file snapshot. This prevents reintroducing
+ * stale "In Progress" entries when concurrent WUs complete on main.
+ *
+ * @param backlogPath - Path to backlog.md in the worktree (used to find state dir)
+ * @param wuId - WU ID being completed
+ * @param mainStateDir - Optional explicit path to main state dir (for testing)
+ * @returns Merged status.md content
+ */
+export async function computeStatusContentWithMainMerge(backlogPath, wuId, mainStateDir) {
+    const worktreeStateDir = getStateStoreDirFromBacklog(backlogPath);
+    let mergedStore;
+    if (mainStateDir) {
+        // Direct merge with provided main state dir (for testing)
+        mergedStore = await mergeStateStores(worktreeStateDir, mainStateDir);
+    }
+    else {
+        // Merge with main state via git show
+        mergedStore = await mergeWithMainState(worktreeStateDir);
+    }
+    // Check if the WU exists in the merged state
+    const currentState = mergedStore.getWUState(wuId);
+    if (!currentState) {
+        throw new Error(`WU ${wuId} not found in merged state store. ` +
+            `This may indicate the WU was never properly claimed.`);
+    }
+    // If not already done, create and apply the complete event
+    if (currentState.status !== 'done') {
+        if (currentState.status !== 'in_progress') {
+            throw new Error(`WU ${wuId} is in status "${currentState.status}", expected "in_progress"`);
+        }
+        const completeEvent = mergedStore.createCompleteEvent(wuId);
+        mergedStore.applyEvent(completeEvent);
+    }
+    // Generate status from merged state
+    return generateStatus(mergedStore);
+}
 /**
  * Compute wu-events.jsonl content with merged state from origin/main.
  *

package/dist/wu-done-metadata.js

@@ -10,7 +10,7 @@ import { updateStatusRemoveInProgress, addToStatusCompleted } from './wu-status-
 import { moveWUToDoneBacklog } from './wu-backlog-updater.js';
 import { createStamp } from './stamp-utils.js';
 import { WU_EVENTS_FILE_NAME } from './wu-state-store.js';
-import { computeWUYAMLContent, computeStatusContent, computeBacklogContent, computeWUEventsContentAfterComplete, computeStampContent, } from './wu-transaction-collectors.js';
+import { computeWUYAMLContent, computeStatusContentFromMergedState, computeBacklogContent, computeWUEventsContentAfterComplete, computeStampContent, } from './wu-transaction-collectors.js';
 import { DEFAULTS, LOG_PREFIX, EMOJI, PKG_MANAGER, SCRIPTS, PRETTIER_FLAGS, BEACON_PATHS, } from './wu-constants.js';
 import { applyExposureDefaults } from './wu-done-validation.js';
 import { createFileNotFoundError, createValidationError } from './wu-done-errors.js';
@@ -139,8 +139,8 @@ export async function collectMetadataToTransaction({ id, title, doc, wuPath, sta
     // Compute WU YAML content (mutates doc, returns YAML string)
     const wuYAMLContent = computeWUYAMLContent(doc);
     transaction.addWrite(wuPath, wuYAMLContent, 'WU YAML');
-    // Compute status.md content
-    const statusContent = computeStatusContent(statusPath, id, title);
+    // Compute status.md content (WU-1319: now uses merged state)
+    const statusContent = await computeStatusContentFromMergedState(backlogPath, id);
     transaction.addWrite(statusPath, statusContent, 'status.md');
     // Compute backlog.md content (WU-1574: now async)
     const backlogContent = await computeBacklogContent(backlogPath, id, title);

package/dist/wu-paths.d.ts

@@ -77,6 +77,21 @@ export declare function createWuPaths(options?: {
      * @returns Path to worktrees directory
      */
     WORKTREES_DIR: () => string;
+    /**
+     * Get path to plans directory
+     * @returns Path to plans directory (WU-1301)
+     */
+    PLANS_DIR: () => string;
+    /**
+     * Get path to templates directory
+     * @returns Path to templates directory (WU-1310)
+     */
+    TEMPLATES_DIR: () => string;
+    /**
+     * Get path to onboarding directory
+     * @returns Path to onboarding directory (WU-1310)
+     */
+    ONBOARDING_DIR: () => string;
 };
 /**
  * Default WU paths using default config
@@ -130,6 +145,21 @@ export declare const WU_PATHS: {
      * @returns Path to worktrees directory
      */
     WORKTREES_DIR: () => string;
+    /**
+     * Get path to plans directory
+     * @returns Path to plans directory (WU-1301)
+     */
+    PLANS_DIR: () => string;
+    /**
+     * Get path to templates directory
+     * @returns Path to templates directory (WU-1310)
+     */
+    TEMPLATES_DIR: () => string;
+    /**
+     * Get path to onboarding directory
+     * @returns Path to onboarding directory (WU-1310)
+     */
+    ONBOARDING_DIR: () => string;
 };
 /**
  * Generate default worktree path from WU document

package/dist/wu-paths.js

@@ -104,6 +104,21 @@ export function createWuPaths(options = {}) {
          * @returns Path to worktrees directory
          */
         WORKTREES_DIR: () => config.directories.worktrees,
+        /**
+         * Get path to plans directory
+         * @returns Path to plans directory (WU-1301)
+         */
+        PLANS_DIR: () => config.directories.plansDir,
+        /**
+         * Get path to templates directory
+         * @returns Path to templates directory (WU-1310)
+         */
+        TEMPLATES_DIR: () => config.directories.templatesDir,
+        /**
+         * Get path to onboarding directory
+         * @returns Path to onboarding directory (WU-1310)
+         */
+        ONBOARDING_DIR: () => config.directories.onboardingDir,
     };
 }
 /**

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

@@ -50,6 +50,36 @@ export declare function createPreflightResult({ valid, errors, missingCodePaths,
     missingTestPaths: any[];
     suggestedTestPaths: {};
 };
+/**
+ * Validate code_paths files exist
+ *
+ * WU-1329: Exported for use by wu:create strict validation.
+ *
+ * @param {string[]} codePaths - List of code paths from WU YAML
+ * @param {string} rootDir - Root directory to resolve paths against
+ * @returns {{ valid: boolean, errors: string[], missing: string[] }}
+ */
+export declare function validateCodePathsExistence(codePaths: any, rootDir: any): {
+    valid: boolean;
+    errors: string[];
+    missing: any[];
+};
+/**
+ * Validate test file paths exist (unit, e2e, integration - not manual)
+ *
+ * Manual tests are descriptions, not file paths, so they're skipped.
+ *
+ * WU-1329: Exported for use by wu:create strict validation.
+ *
+ * @param {object} tests - tests object from WU YAML
+ * @param {string} rootDir - Root directory to resolve paths against
+ * @returns {{ valid: boolean, errors: string[], missing: string[] }}
+ */
+export declare function validateTestPathsExistence(tests: any, rootDir: any): {
+    valid: boolean;
+    errors: string[];
+    missing: any[];
+};
 /**
  * Run preflight validation for a WU
  *