@lumenflow/core 3.1.3 → 3.2.1

package/dist/wu-done-cleanup.js

@@ -0,0 +1,161 @@
+// Copyright (c) 2026 Hellmai Ltd
+// SPDX-License-Identifier: AGPL-3.0-only
+/**
+ * Cleanup helpers for wu:done.
+ */
+import { existsSync } from 'node:fs';
+import { getGitForCwd } from './git-adapter.js';
+import { withCleanupLock } from './cleanup-lock.js';
+import { validateWorktreeOwnership } from './worktree-ownership.js';
+import { getCleanupInstallConfig, CLEANUP_INSTALL_TIMEOUT_MS } from './cleanup-install-config.js';
+import { createValidationError } from './wu-done-errors.js';
+import { defaultWorktreeFrom, defaultBranchFrom, branchExists } from './wu-done-paths.js';
+import { isBranchAlreadyMerged } from './wu-done-branch-utils.js';
+import { BRANCHES, CLAIMED_MODES, EMOJI, LOG_PREFIX, REMOTES } from './wu-constants.js';
+import { exec as execCallback } from 'node:child_process';
+import { promisify } from 'node:util';
+const execAsync = promisify(execCallback);
+/**
+ * Run cleanup operations after successful merge
+ * Removes worktree and optionally deletes lane branch
+ */
+export async function runCleanup(docMain, args) {
+    const wuId = docMain.id;
+    const worktreePath = args.worktree || (await defaultWorktreeFrom(docMain));
+    // WU-2278: Validate worktree ownership before cleanup
+    // Prevents cross-agent worktree deletion
+    if (!args.overrideOwner) {
+        const ownershipResult = validateWorktreeOwnership({ worktreePath, wuId });
+        if (!ownershipResult.valid) {
+            throw createValidationError(`${ownershipResult.error}\n\nTo override (DANGEROUS): pnpm wu:done --id ${wuId} --override-owner --reason "explanation"`, { wuId, worktreePath, error: ownershipResult.error });
+        }
+    }
+    // WU-2241: Wrap cleanup operations in cleanup lock to prevent concurrent collision
+    await withCleanupLock(wuId, async () => {
+        await runCleanupInternal(docMain, args, worktreePath);
+    }, { worktreePath });
+}
+/**
+ * Internal cleanup implementation (runs under cleanup lock)
+ */
+async function runCleanupInternal(docMain, args, worktreePath) {
+    // Step 6: Remove worktree (runs even if commit/push failed)
+    // Skip removal in PR mode (worktree needed for cleanup after PR merge)
+    const claimedMode = docMain.claimed_mode || CLAIMED_MODES.WORKTREE;
+    const requiresReview = docMain.requires_review === true;
+    // WU-1492: Include branch-pr in PR-mode check (preserves worktree for post-merge cleanup)
+    const prModeEnabled = claimedMode === CLAIMED_MODES.WORKTREE_PR ||
+        claimedMode === CLAIMED_MODES.BRANCH_PR ||
+        args.createPR ||
+        requiresReview;
+    // WU-2241: Track branch for cleanup after worktree removal
+    const laneBranch = await defaultBranchFrom(docMain);
+    if (!args.noRemove && !prModeEnabled) {
+        if (worktreePath && existsSync(worktreePath)) {
+            try {
+                await getGitForCwd().worktreeRemove(worktreePath, { force: true });
+                console.log(`${LOG_PREFIX.DONE} ${EMOJI.SUCCESS} Removed worktree ${worktreePath}`);
+                // WU-2241: Delete branch AFTER worktree removal (correct ordering)
+                // This ensures we don't leave orphan branches when worktree is removed
+                if (laneBranch && (await branchExists(laneBranch))) {
+                    await deleteBranchWithCleanup(laneBranch);
+                }
+                // WU-1743: Re-run pnpm install to fix broken symlinks
+                // When pnpm install runs in a worktree, it may create symlinks with absolute paths
+                // to the worktree. After worktree removal, these symlinks break.
+                // Re-running pnpm install regenerates them with correct paths.
+                // WU-2278: Use timeout and CI=true to prevent hangs
+                console.log(`${LOG_PREFIX.DONE} Reinstalling dependencies to fix symlinks...`);
+                try {
+                    const installConfig = getCleanupInstallConfig();
+                    await execAsync(installConfig.command, {
+                        timeout: installConfig.timeout,
+                        env: installConfig.env,
+                    });
+                    console.log(`${LOG_PREFIX.DONE} ${EMOJI.SUCCESS} Dependencies reinstalled`);
+                }
+                catch (installErr) {
+                    // Non-fatal: warn but don't fail wu:done
+                    // WU-2278: Include timeout info in error message
+                    const isTimeout = installErr.killed || installErr.signal === 'SIGTERM';
+                    const errorMsg = isTimeout
+                        ? `pnpm install timed out after ${CLEANUP_INSTALL_TIMEOUT_MS / 1000}s`
+                        : `pnpm install failed: ${installErr.message}`;
+                    console.warn(`${LOG_PREFIX.DONE} ${EMOJI.WARNING} ${errorMsg}`);
+                }
+            }
+            catch (e) {
+                console.warn(`${LOG_PREFIX.DONE} Could not remove worktree ${worktreePath}: ${e.message}`);
+            }
+        }
+        else {
+            console.log(`${LOG_PREFIX.DONE} Worktree not found; skipping removal`);
+            // WU-2241: Still cleanup branch if worktree doesn't exist (orphan branch scenario)
+            if (!prModeEnabled && laneBranch && (await branchExists(laneBranch))) {
+                await deleteBranchWithCleanup(laneBranch);
+            }
+        }
+    }
+    else if (prModeEnabled) {
+        console.log(`${LOG_PREFIX.DONE} ${EMOJI.WARNING} Worktree preserved (PR mode - run wu:cleanup after PR merge)`);
+    }
+}
+/**
+ * WU-2241: Delete both local and remote branch with proper error handling
+ */
+async function deleteBranchWithCleanup(laneBranch) {
+    const gitAdapter = getGitForCwd();
+    // WU-1440: Check if branch is merged before deletion
+    // Use -D (force) when confirmed merged to handle rebased branches
+    const isMerged = await isBranchAlreadyMerged(laneBranch);
+    const isMergedIntoRemoteMain = async () => {
+        try {
+            await gitAdapter.fetch(REMOTES.ORIGIN, BRANCHES.MAIN);
+            await gitAdapter.raw([
+                'merge-base',
+                '--is-ancestor',
+                laneBranch,
+                `${REMOTES.ORIGIN}/${BRANCHES.MAIN}`,
+            ]);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    };
+    try {
+        await gitAdapter.deleteBranch(laneBranch, { force: isMerged });
+        const modeIndicator = isMerged ? ' (force: merged)' : '';
+        console.log(`${LOG_PREFIX.DONE} ${EMOJI.SUCCESS} Deleted local branch ${laneBranch}${modeIndicator}`);
+        // Also delete remote if it exists
+        try {
+            await gitAdapter.raw(['push', REMOTES.ORIGIN, '--delete', laneBranch]);
+            console.log(`${LOG_PREFIX.DONE} ${EMOJI.SUCCESS} Deleted remote branch ${laneBranch}`);
+        }
+        catch (e) {
+            // WU-2241: Non-fatal - remote branch may already be deleted or never existed
+            console.warn(`${LOG_PREFIX.DONE} Could not delete remote branch: ${e.message}`);
+        }
+    }
+    catch (e) {
+        const errorMessage = e instanceof Error ? e.message : String(e);
+        // WU-1657: If local merge state lags and branch reports "not fully merged",
+        // check against origin/main and force-delete when remote already contains the branch.
+        if (/not fully merged/i.test(errorMessage)) {
+            const mergedOnRemoteMain = await isMergedIntoRemoteMain();
+            if (mergedOnRemoteMain) {
+                try {
+                    await gitAdapter.deleteBranch(laneBranch, { force: true });
+                    console.log(`${LOG_PREFIX.DONE} ${EMOJI.SUCCESS} Deleted local branch ${laneBranch} (force: merged on origin/main)`);
+                    return;
+                }
+                catch (forceErr) {
+                    const forceMessage = forceErr instanceof Error ? forceErr.message : String(forceErr);
+                    console.warn(`${LOG_PREFIX.DONE} Could not force-delete branch ${laneBranch} after remote-merge verification: ${forceMessage}`);
+                }
+            }
+        }
+        console.warn(`${LOG_PREFIX.DONE} Could not delete branch ${laneBranch}: ${e.message}`);
+    }
+}
+//# sourceMappingURL=wu-done-cleanup.js.map

package/dist/wu-done-cleanup.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"wu-done-cleanup.js","sourceRoot":"","sources":["../src/wu-done-cleanup.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,103 @@
+import { WUStateStore } from './wu-state-store.js';
+/**
+ * Fetch wu-events.jsonl content from origin/main using git show.
+ *
+ * This allows us to read the state from main without switching branches
+ * or having access to the main checkout directory.
+ *
+ * @returns Events content from origin/main, or null if not available
+ */
+export declare function fetchMainEventsContent(): Promise<string | null>;
+/**
+ * Merge state stores from worktree and main.
+ *
+ * This creates a new WUStateStore instance that contains the merged
+ * state from both sources, preserving all concurrent modifications.
+ *
+ * @param worktreeStateDir - Path to worktree's .lumenflow/state directory
+ * @param mainStateDir - Path to main's .lumenflow/state directory
+ * @returns A WUStateStore with merged state
+ */
+export declare function mergeStateStores(worktreeStateDir: string, mainStateDir: string): Promise<WUStateStore>;
+/**
+ * Compute backlog content with merged state from worktree and main.
+ *
+ * This is a drop-in replacement for computeBacklogContent that handles
+ * concurrent modifications by merging state stores before generation.
+ *
+ * @param backlogPath - Path to backlog.md in the worktree
+ * @param wuId - WU ID being completed
+ * @param title - WU title
+ * @param mainStateDir - Path to main's .lumenflow/state directory
+ * @returns Merged backlog.md content
+ */
+export declare function computeBacklogContentWithMerge(backlogPath: string, wuId: string, title: string, mainStateDir: string): Promise<string>;
+/**
+ * Get the merged events content for wu-events.jsonl
+ *
+ * This returns the content that should be written to wu-events.jsonl
+ * after merging worktree and main state stores.
+ *
+ * @param worktreeStateDir - Path to worktree's .lumenflow/state directory
+ * @param mainStateDir - Path to main's .lumenflow/state directory
+ * @param wuId - WU ID being completed (to add complete event)
+ * @returns JSONL content for the merged events file
+ */
+export declare function getMergedEventsContent(worktreeStateDir: string, mainStateDir: string, wuId: string): Promise<string>;
+/**
+ * Merge worktree state with origin/main state using git show.
+ *
+ * This function:
+ * 1. Fetches the wu-events.jsonl content from origin/main using git show
+ * 2. Parses events from both worktree and main
+ * 3. Merges them with deduplication
+ * 4. Returns a store with the merged state
+ *
+ * This is the integration point for wu:done to preserve concurrent changes.
+ *
+ * @param worktreeStateDir - Path to worktree's .lumenflow/state directory
+ * @returns A WUStateStore with merged state, or just worktree state if main unavailable
+ */
+export declare function mergeWithMainState(worktreeStateDir: string): Promise<WUStateStore>;
+/**
+ * Compute backlog content with merged state from origin/main.
+ *
+ * This is the main integration function for wu:done. It:
+ * 1. Loads the worktree's state
+ * 2. Fetches and merges state from origin/main
+ * 3. Applies the complete event for the WU being done
+ * 4. Generates backlog from the merged state
+ *
+ * @param backlogPath - Path to backlog.md in the worktree
+ * @param wuId - WU ID being completed
+ * @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.
+ *
+ * Returns the JSONL content that should be written to wu-events.jsonl,
+ * containing merged events from both worktree and main, plus the completion event.
+ *
+ * @param backlogPath - Path to backlog.md in the worktree
+ * @param wuId - WU ID being completed
+ * @returns Object with events path and merged content, or null if no update needed
+ */
+export declare function computeWUEventsContentWithMainMerge(backlogPath: string, wuId: string): Promise<{
+    eventsPath: string;
+    content: string;
+} | null>;
+//# sourceMappingURL=wu-done-concurrent-merge.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"wu-done-concurrent-merge.d.ts","sourceRoot":"","sources":["../src/wu-done-concurrent-merge.ts"],"names":[],"mappings":"AAmBA,OAAO,EAAE,YAAY,EAAuB,MAAM,qBAAqB,CAAC;AAexE;;;;;;;GAOG;AACH,wBAAsB,sBAAsB,IAAI,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAqBrE;AA8FD;;;;;;;;;GASG;AACH,wBAAsB,gBAAgB,CACpC,gBAAgB,EAAE,MAAM,EACxB,YAAY,EAAE,MAAM,GACnB,OAAO,CAAC,YAAY,CAAC,CAgBvB;AAED;;;;;;;;;;;GAWG;AACH,wBAAsB,8BAA8B,CAClD,WAAW,EAAE,MAAM,EACnB,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,MAAM,EACb,YAAY,EAAE,MAAM,GACnB,OAAO,CAAC,MAAM,CAAC,CAqBjB;AAED;;;;;;;;;;GAUG;AACH,wBAAsB,sBAAsB,CAC1C,gBAAgB,EAAE,MAAM,EACxB,YAAY,EAAE,MAAM,EACpB,IAAI,EAAE,MAAM,GACX,OAAO,CAAC,MAAM,CAAC,CA2BjB;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAsB,kBAAkB,CAAC,gBAAgB,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC,CAyBxF;AAED;;;;;;;;;;;;GAYG;AACH,wBAAsB,kCAAkC,CACtD,WAAW,EAAE,MAAM,EACnB,IAAI,EAAE,MAAM,GACX,OAAO,CAAC,MAAM,CAAC,CA6BjB;AAED;;;;;;;;;;;GAWG;AACH,wBAAsB,iCAAiC,CACrD,WAAW,EAAE,MAAM,EACnB,IAAI,EAAE,MAAM,EACZ,YAAY,CAAC,EAAE,MAAM,GACpB,OAAO,CAAC,MAAM,CAAC,CAoCjB;AAED;;;;;;;;;GASG;AACH,wBAAsB,mCAAmC,CACvD,WAAW,EAAE,MAAM,EACnB,IAAI,EAAE,MAAM,GACX,OAAO,CAAC;IAAE,UAAU,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAAC,CA2CzD"}

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

@@ -0,0 +1,375 @@
+// Copyright (c) 2026 Hellmai Ltd
+// SPDX-License-Identifier: AGPL-3.0-only
+/**
+ * WU-1145: Concurrent backlog merge utilities
+ *
+ * This module provides utilities for merging state stores from worktree
+ * and main branches to prevent loss of concurrent WU completions.
+ *
+ * Problem: When wu:done regenerates backlog.md, it only uses the worktree's
+ * state store, losing UnsafeAny WUs that were completed on main since the worktree
+ * was created.
+ *
+ * Solution: Before regenerating backlog.md, merge events from both state
+ * stores using event deduplication by identity (type, wuId, timestamp).
+ */
+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, generateStatus } from './backlog-generator.js';
+import { getStateStoreDirFromBacklog } from './wu-paths.js';
+import { getGitForCwd } from './git-adapter.js';
+import { REMOTES, BRANCHES, LUMENFLOW_PATHS, WU_STATUS } from './wu-constants.js';
+/**
+ * Creates a unique key for an event to detect duplicates.
+ * Events are considered identical if they have the same type, wuId, and timestamp.
+ */
+function getEventKey(event) {
+    return `${event.type}:${event.wuId}:${event.timestamp}`;
+}
+/**
+ * Fetch wu-events.jsonl content from origin/main using git show.
+ *
+ * This allows us to read the state from main without switching branches
+ * or having access to the main checkout directory.
+ *
+ * @returns Events content from origin/main, or null if not available
+ */
+export async function fetchMainEventsContent() {
+    try {
+        const git = getGitForCwd();
+        // First, fetch to ensure we have the latest main
+        try {
+            await git.fetch(REMOTES.ORIGIN, BRANCHES.MAIN);
+        }
+        catch {
+            // If fetch fails (e.g., offline), continue with cached version
+            console.warn('[wu-done] Warning: Could not fetch latest main, using cached version');
+        }
+        // Try to read wu-events.jsonl from origin/main
+        const eventsPath = `${LUMENFLOW_PATHS.STATE_DIR}/${WU_EVENTS_FILE_NAME}`;
+        const content = await git.raw(['show', `${REMOTES.ORIGIN}/${BRANCHES.MAIN}:${eventsPath}`]);
+        return content;
+    }
+    catch (error) {
+        // File may not exist on main (e.g., new repo or first WU)
+        // Or we may not be in a git repo
+        return null;
+    }
+}
+/**
+ * Parse wu-events.jsonl content into validated events
+ */
+function parseEventsFile(content, sourceLabel) {
+    const events = [];
+    const lines = content
+        .split('\n')
+        .map((line) => line.trim())
+        .filter(Boolean);
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        if (!line)
+            continue;
+        let parsed;
+        try {
+            parsed = JSON.parse(line);
+        }
+        catch (error) {
+            console.warn(`[wu-done] Warning: Malformed JSON in ${sourceLabel} line ${i + 1}, skipping`);
+            continue;
+        }
+        const validation = validateWUEvent(parsed);
+        if (!validation.success) {
+            console.warn(`[wu-done] Warning: Invalid event in ${sourceLabel} line ${i + 1}, skipping`);
+            continue;
+        }
+        events.push(validation.data);
+    }
+    return events;
+}
+/**
+ * Load events from a state directory
+ */
+function loadEventsFromDir(stateDir, label) {
+    const eventsPath = join(stateDir, WU_EVENTS_FILE_NAME);
+    if (!existsSync(eventsPath)) {
+        return [];
+    }
+    const content = readFileSync(eventsPath, { encoding: 'utf-8' });
+    return parseEventsFile(content, label);
+}
+/**
+ * Merge events from two sources, preserving order and deduplicating.
+ *
+ * The merge strategy:
+ * 1. Start with all events from main (the "base" timeline)
+ * 2. Add UnsafeAny events from worktree that aren't in main
+ *
+ * This ensures:
+ * - Concurrent completions on main are preserved
+ * - The worktree's claim/in_progress events are included
+ * - No duplicate events
+ */
+function mergeEvents(mainEvents, worktreeEvents) {
+    const seen = new Set();
+    const merged = [];
+    // First, add all main events
+    for (const event of mainEvents) {
+        const key = getEventKey(event);
+        if (!seen.has(key)) {
+            seen.add(key);
+            merged.push(event);
+        }
+    }
+    // Then add worktree events that aren't in main
+    for (const event of worktreeEvents) {
+        const key = getEventKey(event);
+        if (!seen.has(key)) {
+            seen.add(key);
+            merged.push(event);
+        }
+    }
+    // Sort by timestamp to ensure chronological order
+    merged.sort((a, b) => {
+        const timeA = new Date(a.timestamp).getTime();
+        const timeB = new Date(b.timestamp).getTime();
+        return timeA - timeB;
+    });
+    return merged;
+}
+/**
+ * Merge state stores from worktree and main.
+ *
+ * This creates a new WUStateStore instance that contains the merged
+ * state from both sources, preserving all concurrent modifications.
+ *
+ * @param worktreeStateDir - Path to worktree's .lumenflow/state directory
+ * @param mainStateDir - Path to main's .lumenflow/state directory
+ * @returns A WUStateStore with merged state
+ */
+export async function mergeStateStores(worktreeStateDir, mainStateDir) {
+    // Load events from both sources
+    const worktreeEvents = loadEventsFromDir(worktreeStateDir, 'worktree');
+    const mainEvents = loadEventsFromDir(mainStateDir, 'main');
+    // Merge events
+    const mergedEvents = mergeEvents(mainEvents, worktreeEvents);
+    // Create a new store and replay merged events
+    const store = new WUStateStore(worktreeStateDir);
+    for (const event of mergedEvents) {
+        store.applyEvent(event);
+    }
+    return store;
+}
+/**
+ * Compute backlog content with merged state from worktree and main.
+ *
+ * This is a drop-in replacement for computeBacklogContent that handles
+ * concurrent modifications by merging state stores before generation.
+ *
+ * @param backlogPath - Path to backlog.md in the worktree
+ * @param wuId - WU ID being completed
+ * @param title - WU title
+ * @param mainStateDir - Path to main's .lumenflow/state directory
+ * @returns Merged backlog.md content
+ */
+export async function computeBacklogContentWithMerge(backlogPath, wuId, title, mainStateDir) {
+    const worktreeStateDir = getStateStoreDirFromBacklog(backlogPath);
+    // Merge state stores
+    const mergedStore = await mergeStateStores(worktreeStateDir, mainStateDir);
+    // Check if the WU is already done in the merged state
+    const currentState = mergedStore.getWUState(wuId);
+    if (!currentState) {
+        throw new Error(`WU ${wuId} not found in merged state store`);
+    }
+    // If not already done, create and apply the complete event
+    if (currentState.status !== WU_STATUS.DONE) {
+        const completeEvent = mergedStore.createCompleteEvent(wuId);
+        mergedStore.applyEvent(completeEvent);
+    }
+    // Generate backlog from merged state
+    return generateBacklog(mergedStore);
+}
+/**
+ * Get the merged events content for wu-events.jsonl
+ *
+ * This returns the content that should be written to wu-events.jsonl
+ * after merging worktree and main state stores.
+ *
+ * @param worktreeStateDir - Path to worktree's .lumenflow/state directory
+ * @param mainStateDir - Path to main's .lumenflow/state directory
+ * @param wuId - WU ID being completed (to add complete event)
+ * @returns JSONL content for the merged events file
+ */
+export async function getMergedEventsContent(worktreeStateDir, mainStateDir, wuId) {
+    // Load events from both sources
+    const worktreeEvents = loadEventsFromDir(worktreeStateDir, 'worktree');
+    const mainEvents = loadEventsFromDir(mainStateDir, 'main');
+    // Merge events
+    const mergedEvents = mergeEvents(mainEvents, worktreeEvents);
+    // Check if we need to add a complete event
+    const lastEventForWU = [...mergedEvents].reverse().find((e) => e.wuId === wuId);
+    if (!lastEventForWU || lastEventForWU.type !== 'complete') {
+        // Create a temporary store to generate the complete event
+        const tempStore = new WUStateStore(worktreeStateDir);
+        for (const event of mergedEvents) {
+            tempStore.applyEvent(event);
+        }
+        const currentState = tempStore.getWUState(wuId);
+        if (currentState && currentState.status === WU_STATUS.IN_PROGRESS) {
+            const completeEvent = tempStore.createCompleteEvent(wuId);
+            mergedEvents.push(completeEvent);
+        }
+    }
+    // Convert to JSONL
+    return mergedEvents.map((event) => JSON.stringify(event)).join('\n') + '\n';
+}
+/**
+ * Merge worktree state with origin/main state using git show.
+ *
+ * This function:
+ * 1. Fetches the wu-events.jsonl content from origin/main using git show
+ * 2. Parses events from both worktree and main
+ * 3. Merges them with deduplication
+ * 4. Returns a store with the merged state
+ *
+ * This is the integration point for wu:done to preserve concurrent changes.
+ *
+ * @param worktreeStateDir - Path to worktree's .lumenflow/state directory
+ * @returns A WUStateStore with merged state, or just worktree state if main unavailable
+ */
+export async function mergeWithMainState(worktreeStateDir) {
+    // Load worktree events
+    const worktreeEvents = loadEventsFromDir(worktreeStateDir, 'worktree');
+    // Try to fetch main events via git show
+    const mainContent = await fetchMainEventsContent();
+    const mainEvents = mainContent ? parseEventsFile(mainContent, 'origin/main') : [];
+    if (mainEvents.length > 0) {
+        console.log(`[wu-done] Merging state: ${worktreeEvents.length} worktree events + ${mainEvents.length} main events`);
+    }
+    // Merge events
+    const mergedEvents = mergeEvents(mainEvents, worktreeEvents);
+    // Create a new store and replay merged events
+    const store = new WUStateStore(worktreeStateDir);
+    for (const event of mergedEvents) {
+        store.applyEvent(event);
+    }
+    return store;
+}
+/**
+ * Compute backlog content with merged state from origin/main.
+ *
+ * This is the main integration function for wu:done. It:
+ * 1. Loads the worktree's state
+ * 2. Fetches and merges state from origin/main
+ * 3. Applies the complete event for the WU being done
+ * 4. Generates backlog from the merged state
+ *
+ * @param backlogPath - Path to backlog.md in the worktree
+ * @param wuId - WU ID being completed
+ * @returns Merged backlog.md content
+ */
+export async function computeBacklogContentWithMainMerge(backlogPath, wuId) {
+    const worktreeStateDir = getStateStoreDirFromBacklog(backlogPath);
+    // Merge with main state
+    const 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 !== WU_STATUS.DONE) {
+        if (currentState.status !== WU_STATUS.IN_PROGRESS) {
+            throw new Error(`WU ${wuId} is in status "${currentState.status}", expected "${WU_STATUS.IN_PROGRESS}"`);
+        }
+        const completeEvent = mergedStore.createCompleteEvent(wuId);
+        mergedStore.applyEvent(completeEvent);
+    }
+    // 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 !== WU_STATUS.DONE) {
+        if (currentState.status !== WU_STATUS.IN_PROGRESS) {
+            throw new Error(`WU ${wuId} is in status "${currentState.status}", expected "${WU_STATUS.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.
+ *
+ * Returns the JSONL content that should be written to wu-events.jsonl,
+ * containing merged events from both worktree and main, plus the completion event.
+ *
+ * @param backlogPath - Path to backlog.md in the worktree
+ * @param wuId - WU ID being completed
+ * @returns Object with events path and merged content, or null if no update needed
+ */
+export async function computeWUEventsContentWithMainMerge(backlogPath, wuId) {
+    const worktreeStateDir = getStateStoreDirFromBacklog(backlogPath);
+    // Load worktree events
+    const worktreeEvents = loadEventsFromDir(worktreeStateDir, 'worktree');
+    // Try to fetch main events via git show
+    const mainContent = await fetchMainEventsContent();
+    const mainEvents = mainContent ? parseEventsFile(mainContent, 'origin/main') : [];
+    // Merge events
+    const mergedEvents = mergeEvents(mainEvents, worktreeEvents);
+    // Check if WU is already done
+    const tempStore = new WUStateStore(worktreeStateDir);
+    for (const event of mergedEvents) {
+        tempStore.applyEvent(event);
+    }
+    const currentState = tempStore.getWUState(wuId);
+    if (!currentState) {
+        throw new Error(`WU ${wuId} not found in merged state store`);
+    }
+    if (currentState.status === WU_STATUS.DONE) {
+        // Already done, no update needed
+        return null;
+    }
+    if (currentState.status !== WU_STATUS.IN_PROGRESS) {
+        throw new Error(`WU ${wuId} is in status "${currentState.status}", expected "${WU_STATUS.IN_PROGRESS}"`);
+    }
+    // Add complete event
+    const completeEvent = tempStore.createCompleteEvent(wuId);
+    mergedEvents.push(completeEvent);
+    const eventsPath = join(worktreeStateDir, WU_EVENTS_FILE_NAME);
+    const content = mergedEvents.map((event) => JSON.stringify(event)).join('\n') + '\n';
+    return { eventsPath, content };
+}
+//# sourceMappingURL=wu-done-concurrent-merge.js.map