@lumenflow/core 1.3.4 → 1.3.6

package/dist/wu-consistency-checker.js

@@ -13,13 +13,14 @@
  * @see {@link ../wu-repair.mjs} CLI interface
  */
 import { readFile, writeFile, readdir, mkdir, access } from 'node:fs/promises';
-import { constants } from 'node:fs';
+import { constants, existsSync, mkdirSync, writeFileSync, readFileSync } from 'node:fs';
 import path from 'node:path';
 import { parseYAML, stringifyYAML } from './wu-yaml.js';
 import { WU_PATHS } from './wu-paths.js';
 import { CONSISTENCY_TYPES, CONSISTENCY_MESSAGES, LOG_PREFIX, REMOTES, STRING_LITERALS, toKebab, WU_STATUS, YAML_OPTIONS, } from './wu-constants.js';
 import { todayISO } from './date-utils.js';
 import { createGitForPath } from './git-adapter.js';
+import { withMicroWorktree } from './micro-worktree.js';
 /**
  * Check a single WU for state inconsistencies
  *
@@ -238,7 +239,34 @@ export async function checkLaneForOrphanDoneWU(lane, excludeId, projectRoot = pr
     };
 }
 /**
- * Repair WU inconsistencies
+ * Categorize errors into file-based repairs (need micro-worktree) and git-only repairs
+ */
+function categorizeErrors(errors) {
+    const fileRepairs = [];
+    const gitOnlyRepairs = [];
+    const nonRepairable = [];
+    for (const error of errors) {
+        if (!error.canAutoRepair) {
+            nonRepairable.push(error);
+            continue;
+        }
+        // Git-only repairs: worktree/branch cleanup doesn't need micro-worktree
+        if (error.type === CONSISTENCY_TYPES.ORPHAN_WORKTREE_DONE) {
+            gitOnlyRepairs.push(error);
+        }
+        else {
+            // All file-based repairs need micro-worktree isolation
+            fileRepairs.push(error);
+        }
+    }
+    return { fileRepairs, gitOnlyRepairs, nonRepairable };
+}
+/**
+ * Repair WU inconsistencies using micro-worktree isolation (WU-1078)
+ *
+ * All file modifications (stamps, YAML, markdown) are made atomically
+ * in a micro-worktree, then committed and pushed to origin/main.
+ * This prevents direct writes to the main checkout.
  *
  * @param {object} report - Report from checkWUConsistency()
  * @param {RepairWUInconsistencyOptions} [options={}] - Repair options
@@ -249,20 +277,72 @@ export async function repairWUInconsistency(report, options = {}) {
     if (report.valid) {
         return { repaired: 0, skipped: 0, failed: 0 };
     }
+    const { fileRepairs, gitOnlyRepairs, nonRepairable } = categorizeErrors(report.errors);
     let repaired = 0;
-    let skipped = 0;
+    let skipped = nonRepairable.length;
     let failed = 0;
-    for (const error of report.errors) {
-        if (!error.canAutoRepair) {
-            skipped++;
-            continue;
+    // Dry run mode: just count
+    if (dryRun) {
+        return {
+            repaired: fileRepairs.length + gitOnlyRepairs.length,
+            skipped,
+            failed: 0,
+        };
+    }
+    // Step 1: Process file-based repairs via micro-worktree (batched)
+    if (fileRepairs.length > 0) {
+        try {
+            // Generate a batch ID from the WU IDs being repaired
+            const batchId = `batch-${fileRepairs.map((e) => e.wuId).join('-')}`.slice(0, 50);
+            await withMicroWorktree({
+                operation: 'wu-repair',
+                id: batchId,
+                logPrefix: LOG_PREFIX.REPAIR,
+                execute: async ({ worktreePath }) => {
+                    const filesModified = [];
+                    for (const error of fileRepairs) {
+                        try {
+                            const result = await repairSingleErrorInWorktree(error, worktreePath, projectRoot);
+                            if (result.success && result.files) {
+                                filesModified.push(...result.files);
+                                repaired++;
+                            }
+                            else if (result.skipped) {
+                                skipped++;
+                                if (result.reason) {
+                                    console.warn(`${LOG_PREFIX.REPAIR} Skipped ${error.type}: ${result.reason}`);
+                                }
+                            }
+                            else {
+                                failed++;
+                            }
+                        }
+                        catch (err) {
+                            const errMessage = err instanceof Error ? err.message : String(err);
+                            console.error(`${LOG_PREFIX.REPAIR} Failed to repair ${error.type}: ${errMessage}`);
+                            failed++;
+                        }
+                    }
+                    // Deduplicate files
+                    const uniqueFiles = [...new Set(filesModified)];
+                    return {
+                        commitMessage: `fix: repair ${repaired} WU inconsistencies`,
+                        files: uniqueFiles,
+                    };
+                },
+            });
         }
-        if (dryRun) {
-            repaired++;
-            continue;
+        catch (err) {
+            // If micro-worktree fails, mark all file repairs as failed
+            const errMessage = err instanceof Error ? err.message : String(err);
+            console.error(`${LOG_PREFIX.REPAIR} Micro-worktree operation failed: ${errMessage}`);
+            failed += fileRepairs.length - repaired;
         }
+    }
+    // Step 2: Process git-only repairs (worktree/branch cleanup) directly
+    for (const error of gitOnlyRepairs) {
         try {
-            const result = await repairSingleError(error, projectRoot);
+            const result = await repairGitOnlyError(error, projectRoot);
             if (result.success) {
                 repaired++;
             }
@@ -285,34 +365,85 @@ export async function repairWUInconsistency(report, options = {}) {
     return { repaired, skipped, failed };
 }
 /**
- * Repair a single inconsistency error
+ * Repair a single file-based error inside a micro-worktree (WU-1078)
+ *
+ * This function performs file modifications inside the worktree path,
+ * which is then committed and pushed atomically by withMicroWorktree.
+ *
+ * @param {ConsistencyError} error - Error object from checkWUConsistency()
+ * @param {string} worktreePath - Path to the micro-worktree
+ * @param {string} projectRoot - Original project root (for reading source files)
+ * @returns {Promise<RepairResult>} Result with success, skipped, reason, and files modified
+ */
+async function repairSingleErrorInWorktree(error, worktreePath, projectRoot) {
+    switch (error.type) {
+        case CONSISTENCY_TYPES.YAML_DONE_NO_STAMP: {
+            const files = await createStampInWorktree(error.wuId, error.title || `WU ${error.wuId}`, worktreePath);
+            return { success: true, files };
+        }
+        case CONSISTENCY_TYPES.YAML_DONE_STATUS_IN_PROGRESS: {
+            const files = await removeWUFromSectionInWorktree(WU_PATHS.STATUS(), error.wuId, '## In Progress', worktreePath, projectRoot);
+            return { success: true, files };
+        }
+        case CONSISTENCY_TYPES.BACKLOG_DUAL_SECTION: {
+            const files = await removeWUFromSectionInWorktree(WU_PATHS.BACKLOG(), error.wuId, '## 🔧 In progress', worktreePath, projectRoot);
+            return { success: true, files };
+        }
+        case CONSISTENCY_TYPES.STAMP_EXISTS_YAML_NOT_DONE: {
+            const files = await updateYamlToDoneInWorktree(error.wuId, worktreePath, projectRoot);
+            return { success: true, files };
+        }
+        default:
+            return { skipped: true, reason: `Unknown error type: ${error.type}` };
+    }
+}
+/**
+ * Repair git-only errors (worktree/branch cleanup) without micro-worktree
+ *
+ * These operations don't modify files in the repo, they only manage git worktrees
+ * and branches, so they can run directly.
  *
- * @param {object} error - Error object from checkWUConsistency()
+ * @param {ConsistencyError} error - Error object
  * @param {string} projectRoot - Project root directory
  * @returns {Promise<RepairResult>} Result with success, skipped, and reason
  */
-async function repairSingleError(error, projectRoot) {
+async function repairGitOnlyError(error, projectRoot) {
     switch (error.type) {
-        case CONSISTENCY_TYPES.YAML_DONE_NO_STAMP:
-            await createStampInProject(error.wuId, error.title || `WU ${error.wuId}`, projectRoot);
-            return { success: true };
-        case CONSISTENCY_TYPES.YAML_DONE_STATUS_IN_PROGRESS:
-            await removeWUFromSection(path.join(projectRoot, WU_PATHS.STATUS()), error.wuId, '## In Progress');
-            return { success: true };
-        case CONSISTENCY_TYPES.BACKLOG_DUAL_SECTION:
-            await removeWUFromSection(path.join(projectRoot, WU_PATHS.BACKLOG()), error.wuId, '## 🔧 In progress');
-            return { success: true };
         case CONSISTENCY_TYPES.ORPHAN_WORKTREE_DONE:
             return await removeOrphanWorktree(error.wuId, error.lane, projectRoot);
-        case CONSISTENCY_TYPES.STAMP_EXISTS_YAML_NOT_DONE:
-            await updateYamlToDone(error.wuId, projectRoot);
-            return { success: true };
         default:
-            return { skipped: true, reason: `Unknown error type: ${error.type}` };
+            return { skipped: true, reason: `Unknown git-only error type: ${error.type}` };
     }
 }
 /**
- * Create stamp file in a specific project root
+ * Create stamp file inside a micro-worktree (WU-1078)
+ *
+ * @param {string} id - WU ID
+ * @param {string} title - WU title
+ * @param {string} worktreePath - Path to the micro-worktree
+ * @returns {Promise<string[]>} List of files created (relative paths)
+ */
+async function createStampInWorktree(id, title, worktreePath) {
+    const stampsDir = path.join(worktreePath, WU_PATHS.STAMPS_DIR());
+    const stampRelPath = WU_PATHS.STAMP(id);
+    const stampAbsPath = path.join(worktreePath, stampRelPath);
+    // Ensure stamps directory exists
+    if (!existsSync(stampsDir)) {
+        mkdirSync(stampsDir, { recursive: true });
+    }
+    // Don't overwrite existing stamp
+    if (existsSync(stampAbsPath)) {
+        return []; // Stamp already exists
+    }
+    // Create stamp file
+    const body = `WU ${id} — ${title}\nCompleted: ${todayISO()}\n`;
+    writeFileSync(stampAbsPath, body, { encoding: 'utf-8' });
+    return [stampRelPath];
+}
+/**
+ * Create stamp file in a specific project root (DEPRECATED - use createStampInWorktree)
+ *
+ * Kept for backwards compatibility with code that doesn't use micro-worktree.
  *
  * @param {string} id - WU ID
  * @param {string} title - WU title
@@ -342,7 +473,7 @@ async function createStampInProject(id, title, projectRoot) {
     await writeFile(stampPath, body, { encoding: 'utf-8' });
 }
 /**
- * Update WU YAML to done+locked+completed state (WU-2412)
+ * Update WU YAML to done+locked+completed state inside a micro-worktree (WU-1078)
  *
  * Repairs STAMP_EXISTS_YAML_NOT_DONE by setting:
  * - status: done
@@ -350,6 +481,43 @@ async function createStampInProject(id, title, projectRoot) {
  * - completed: YYYY-MM-DD (today, unless already set)
  *
  * @param {string} id - WU ID
+ * @param {string} worktreePath - Path to the micro-worktree
+ * @param {string} projectRoot - Original project root (for reading source file)
+ * @returns {Promise<string[]>} List of files modified (relative paths)
+ */
+async function updateYamlToDoneInWorktree(id, worktreePath, projectRoot) {
+    const wuRelPath = WU_PATHS.WU(id);
+    const wuSrcPath = path.join(projectRoot, wuRelPath);
+    const wuDestPath = path.join(worktreePath, wuRelPath);
+    // Read current YAML from project root
+    const content = readFileSync(wuSrcPath, { encoding: 'utf-8' });
+    const wuDoc = parseYAML(content);
+    if (!wuDoc) {
+        throw new Error(`Failed to parse WU YAML: ${wuSrcPath}`);
+    }
+    // Update fields
+    wuDoc.status = WU_STATUS.DONE;
+    wuDoc.locked = true;
+    // Preserve existing completed date if present, otherwise set to today
+    if (!wuDoc.completed) {
+        wuDoc.completed = todayISO();
+    }
+    // Ensure directory exists in worktree
+    const wuDir = path.dirname(wuDestPath);
+    if (!existsSync(wuDir)) {
+        mkdirSync(wuDir, { recursive: true });
+    }
+    // Write updated YAML to worktree
+    const updatedContent = stringifyYAML(wuDoc, { lineWidth: YAML_OPTIONS.LINE_WIDTH });
+    writeFileSync(wuDestPath, updatedContent, { encoding: 'utf-8' });
+    return [wuRelPath];
+}
+/**
+ * Update WU YAML to done+locked+completed state (DEPRECATED - use updateYamlToDoneInWorktree)
+ *
+ * Kept for backwards compatibility.
+ *
+ * @param {string} id - WU ID
  * @param {string} projectRoot - Project root directory
  * @returns {Promise<void>}
  */
@@ -373,7 +541,69 @@ async function updateYamlToDone(id, projectRoot) {
     await writeFile(wuPath, updatedContent, { encoding: 'utf-8' });
 }
 /**
- * Remove WU entry from a specific section in a markdown file
+ * Remove WU entry from a specific section in a markdown file inside a micro-worktree (WU-1078)
+ *
+ * @param {string} relFilePath - Relative path to the markdown file
+ * @param {string} id - WU ID to remove
+ * @param {string} sectionHeading - Section heading to target
+ * @param {string} worktreePath - Path to the micro-worktree
+ * @param {string} projectRoot - Original project root (for reading source file)
+ * @returns {Promise<string[]>} List of files modified (relative paths)
+ */
+async function removeWUFromSectionInWorktree(relFilePath, id, sectionHeading, worktreePath, projectRoot) {
+    const srcPath = path.join(projectRoot, relFilePath);
+    const destPath = path.join(worktreePath, relFilePath);
+    // Check if source file exists
+    if (!existsSync(srcPath)) {
+        return []; // File doesn't exist
+    }
+    const content = readFileSync(srcPath, { encoding: 'utf-8' });
+    const lines = content.split(/\r?\n/);
+    let inTargetSection = false;
+    let nextSectionIdx = -1;
+    let sectionStartIdx = -1;
+    // Normalize heading for comparison (lowercase, trim)
+    const normalizedHeading = sectionHeading.toLowerCase().trim();
+    // Find section boundaries
+    for (let i = 0; i < lines.length; i++) {
+        const normalizedLine = lines[i].toLowerCase().trim();
+        if (normalizedLine === normalizedHeading || normalizedLine.startsWith(normalizedHeading)) {
+            inTargetSection = true;
+            sectionStartIdx = i;
+            continue;
+        }
+        if (inTargetSection && lines[i].trim().startsWith('## ')) {
+            nextSectionIdx = i;
+            break;
+        }
+    }
+    if (sectionStartIdx === -1)
+        return [];
+    const endIdx = nextSectionIdx === -1 ? lines.length : nextSectionIdx;
+    // Filter out lines containing the WU ID in the target section
+    const newLines = [];
+    let modified = false;
+    for (let i = 0; i < lines.length; i++) {
+        if (i > sectionStartIdx && i < endIdx && lines[i].includes(id)) {
+            modified = true;
+            continue; // Skip this line
+        }
+        newLines.push(lines[i]);
+    }
+    if (!modified)
+        return [];
+    // Ensure directory exists in worktree
+    const destDir = path.dirname(destPath);
+    if (!existsSync(destDir)) {
+        mkdirSync(destDir, { recursive: true });
+    }
+    writeFileSync(destPath, newLines.join(STRING_LITERALS.NEWLINE), { encoding: 'utf-8' });
+    return [relFilePath];
+}
+/**
+ * Remove WU entry from a specific section in a markdown file (DEPRECATED)
+ *
+ * Kept for backwards compatibility.
  *
  * @param {string} filePath - Path to the markdown file
  * @param {string} id - WU ID to remove

package/dist/wu-constants.d.ts

@@ -1102,7 +1102,7 @@ export declare const GIT_COMMAND_STRINGS: {
 export declare const PATH_PATTERNS: {
     /** Matches WU YAML paths in both legacy and current locations */
     WU_YAML: RegExp;
-    /** Matches stamp file paths */
+    /** Matches stamp file paths (supports both .beacon and .lumenflow for migration) */
     STAMP: RegExp;
 };
 /**
@@ -1208,12 +1208,57 @@ export declare const ERROR_CODES: {
     ETIMEDOUT: string;
 };
 /**
- * Beacon directory paths
+ * LumenFlow directory paths
  *
- * Centralized paths for .beacon directory structure to eliminate hardcoded strings.
- * Used by telemetry, agent-session, agent-incidents, and commands-logger modules.
+ * Centralized paths for .lumenflow directory structure to eliminate hardcoded strings.
+ * Used by telemetry, agent-session, agent-incidents, memory, and commands-logger modules.
+ *
+ * @since 1.4.0 Renamed from BEACON_PATHS (WU-1075)
+ */
+export declare const LUMENFLOW_PATHS: {
+    /** Base directory for all LumenFlow runtime data */
+    BASE: string;
+    /** WU state store directory */
+    STATE_DIR: string;
+    /** Stamp directory (WU completion markers) */
+    STAMPS_DIR: string;
+    /** Merge lock file (runtime coordination, WU-1747) */
+    MERGE_LOCK: string;
+    /** Base telemetry directory */
+    TELEMETRY: string;
+    /** Flow log file (WU flow events) */
+    FLOW_LOG: string;
+    /** Agent sessions directory */
+    SESSIONS: string;
+    /** Agent incidents directory */
+    INCIDENTS: string;
+    /** Git commands log file */
+    COMMANDS_LOG: string;
+    /** Memory layer directory */
+    MEMORY_DIR: string;
+    /** Memory layer JSONL file */
+    MEMORY_JSONL: string;
+    /** Audit log for tool calls */
+    AUDIT_LOG: string;
+    /** Feedback drafts directory */
+    FEEDBACK_DRAFTS: string;
+    /** Feedback index file */
+    FEEDBACK_INDEX: string;
+    /** Current session file */
+    SESSION_CURRENT: string;
+    /** WU events log */
+    WU_EVENTS: string;
+    /** Lock files directory */
+    LOCKS_DIR: string;
+    /** Force bypass audit log */
+    FORCE_BYPASSES: string;
+};
+/**
+ * @deprecated Use LUMENFLOW_PATHS instead. Will be removed in v2.0.
  */
 export declare const BEACON_PATHS: {
+    /** Base directory for all LumenFlow runtime data */
+    BASE: string;
     /** WU state store directory */
     STATE_DIR: string;
     /** Stamp directory (WU completion markers) */
@@ -1230,6 +1275,24 @@ export declare const BEACON_PATHS: {
     INCIDENTS: string;
     /** Git commands log file */
     COMMANDS_LOG: string;
+    /** Memory layer directory */
+    MEMORY_DIR: string;
+    /** Memory layer JSONL file */
+    MEMORY_JSONL: string;
+    /** Audit log for tool calls */
+    AUDIT_LOG: string;
+    /** Feedback drafts directory */
+    FEEDBACK_DRAFTS: string;
+    /** Feedback index file */
+    FEEDBACK_INDEX: string;
+    /** Current session file */
+    SESSION_CURRENT: string;
+    /** WU events log */
+    WU_EVENTS: string;
+    /** Lock files directory */
+    LOCKS_DIR: string;
+    /** Force bypass audit log */
+    FORCE_BYPASSES: string;
 };
 /**
  * File extensions

package/dist/wu-constants.js

@@ -1145,8 +1145,8 @@ export const GIT_COMMAND_STRINGS = {
 export const PATH_PATTERNS = {
     /** Matches WU YAML paths in both legacy and current locations */
     WU_YAML: /(?:memory-bank|docs\/04-operations)\/tasks\/wu\/(WU-\d+)\.ya?ml$/i,
-    /** Matches stamp file paths */
-    STAMP: /\.beacon\/stamps\/(WU-\d+)\.done$/i,
+    /** Matches stamp file paths (supports both .beacon and .lumenflow for migration) */
+    STAMP: /\.(?:beacon|lumenflow)\/stamps\/(WU-\d+)\.done$/i,
 };
 /**
  * Common shell commands
@@ -1251,29 +1251,55 @@ export const ERROR_CODES = {
     ETIMEDOUT: 'ETIMEDOUT',
 };
 /**
- * Beacon directory paths
+ * LumenFlow directory paths
  *
- * Centralized paths for .beacon directory structure to eliminate hardcoded strings.
- * Used by telemetry, agent-session, agent-incidents, and commands-logger modules.
+ * Centralized paths for .lumenflow directory structure to eliminate hardcoded strings.
+ * Used by telemetry, agent-session, agent-incidents, memory, and commands-logger modules.
+ *
+ * @since 1.4.0 Renamed from BEACON_PATHS (WU-1075)
  */
-export const BEACON_PATHS = {
+export const LUMENFLOW_PATHS = {
+    /** Base directory for all LumenFlow runtime data */
+    BASE: '.lumenflow',
     /** WU state store directory */
-    STATE_DIR: '.beacon/state',
+    STATE_DIR: '.lumenflow/state',
     /** Stamp directory (WU completion markers) */
-    STAMPS_DIR: '.beacon/stamps',
+    STAMPS_DIR: '.lumenflow/stamps',
     /** Merge lock file (runtime coordination, WU-1747) */
-    MERGE_LOCK: '.beacon/merge.lock',
+    MERGE_LOCK: '.lumenflow/merge.lock',
     /** Base telemetry directory */
-    TELEMETRY: '.beacon/telemetry',
+    TELEMETRY: '.lumenflow/telemetry',
     /** Flow log file (WU flow events) */
-    FLOW_LOG: '.beacon/flow.log',
+    FLOW_LOG: '.lumenflow/flow.log',
     /** Agent sessions directory */
-    SESSIONS: '.beacon/sessions',
+    SESSIONS: '.lumenflow/sessions',
     /** Agent incidents directory */
-    INCIDENTS: '.beacon/incidents',
+    INCIDENTS: '.lumenflow/incidents',
     /** Git commands log file */
-    COMMANDS_LOG: '.beacon/commands.log',
-};
+    COMMANDS_LOG: '.lumenflow/commands.log',
+    /** Memory layer directory */
+    MEMORY_DIR: '.lumenflow/memory',
+    /** Memory layer JSONL file */
+    MEMORY_JSONL: '.lumenflow/memory/memory.jsonl',
+    /** Audit log for tool calls */
+    AUDIT_LOG: '.lumenflow/telemetry/tools.ndjson',
+    /** Feedback drafts directory */
+    FEEDBACK_DRAFTS: '.lumenflow/feedback-drafts',
+    /** Feedback index file */
+    FEEDBACK_INDEX: '.lumenflow/feedback-index.ndjson',
+    /** Current session file */
+    SESSION_CURRENT: '.lumenflow/sessions/current.json',
+    /** WU events log */
+    WU_EVENTS: '.lumenflow/state/wu-events.jsonl',
+    /** Lock files directory */
+    LOCKS_DIR: '.lumenflow/locks',
+    /** Force bypass audit log */
+    FORCE_BYPASSES: '.lumenflow/force-bypasses.log',
+};
+/**
+ * @deprecated Use LUMENFLOW_PATHS instead. Will be removed in v2.0.
+ */
+export const BEACON_PATHS = LUMENFLOW_PATHS;
 /**
  * File extensions
  *

package/dist/wu-done-branch-only.js

@@ -17,7 +17,7 @@ import path from 'node:path';
 import { defaultBranchFrom, branchExists, generateCommitMessage, updateMetadataFiles, stageAndFormatMetadata, } from './wu-done-validators.js';
 import { getGitForCwd } from './git-adapter.js';
 import { readWU } from './wu-yaml.js';
-import { BRANCHES, REMOTES, LOG_PREFIX, EMOJI, STRING_LITERALS } from './wu-constants.js';
+import { BRANCHES, REMOTES, LOG_PREFIX, EMOJI, STRING_LITERALS, LUMENFLOW_PATHS, } from './wu-constants.js';
 import { RECOVERY } from './wu-done-messages.js';
 import { die, createError, ErrorCodes } from './error-handler.js';
 import { validateWU, validateDoneWU } from './wu-schema.js';
@@ -78,7 +78,7 @@ export async function executeBranchOnlyCompletion(context) {
     const metadataWUPath = path.join(metadataBasePath, 'docs', '04-operations', 'tasks', 'wu', `${id}.yaml`);
     const metadataStatusPath = path.join(metadataBasePath, 'docs', '04-operations', 'tasks', 'status.md');
     const metadataBacklogPath = path.join(metadataBasePath, 'docs', '04-operations', 'tasks', 'backlog.md');
-    const metadataStampsDir = path.join(metadataBasePath, '.beacon', 'stamps');
+    const metadataStampsDir = path.join(metadataBasePath, LUMENFLOW_PATHS.STAMPS_DIR);
     const metadataStampPath = path.join(metadataStampsDir, `${id}.done`);
     // Step 3: Read WU YAML and validate current state
     const docForUpdate = readWU(metadataWUPath, id);

package/dist/wu-done-inputs.js

@@ -36,7 +36,7 @@ export function validateInputs(argv) {
             '    • A separate WU exists to fix those failures (specify with --fix-wu)\n' +
             '    • Your WU work is genuinely complete\n\n' +
             '  NEVER use --skip-gates for failures introduced by your WU!\n' +
-            '  All skip-gates events are logged to .beacon/skip-gates-audit.log\n\n' +
+            '  All skip-gates events are logged to .lumenflow/skip-gates-audit.log\n\n' +
             '📝 WU VALIDATOR:\n' +
             '  Automatically scans code_paths for:\n' +
             '    • TODO/FIXME/HACK/XXX comments (fails validation unless --allow-todo)\n' +

package/dist/wu-done-validation.js

@@ -260,7 +260,7 @@ const DOCS_ONLY_ALLOWED_PATTERNS = [
     /^memory-bank\//i,
     /^docs\//i,
     /\.md$/i,
-    /^\.beacon\/stamps\//i,
+    /^\.(?:beacon|lumenflow)\/stamps\//i, // Support both legacy .beacon and .lumenflow
     /^\.claude\//i,
     /^ai\//i,
     /^README\.md$/i,
@@ -332,7 +332,7 @@ Allowed paths for documentation WUs:
   - ai/
   - .claude/
   - memory-bank/
-  - .beacon/stamps/
+  - .lumenflow/stamps/ (or legacy .beacon/stamps/)
   - *.md files
 
 After fixing, retry: pnpm wu:done --id ${id}

package/dist/wu-done-worktree.js

@@ -115,7 +115,7 @@ export async function executeWorktreeCompletion(context) {
             console.log(`${BOX.SIDE}  4. Return to main and retry wu:done`);
             console.log(BOX.SIDE);
             console.log(`${BOX.SIDE}  Or reset the recovery counter:`);
-            console.log(`${BOX.SIDE}  rm .beacon/recovery/${id}.recovery`);
+            console.log(`${BOX.SIDE}  rm .lumenflow/recovery/${id}.recovery`);
             console.log(BOX.BOT);
             throw createRecoveryError(`Recovery loop detected for ${id} after ${attemptCount} attempts. Manual intervention required.`, { wuId: id, attemptCount, maxAttempts: MAX_RECOVERY_ATTEMPTS });
         }
@@ -232,7 +232,7 @@ export async function executeWorktreeCompletion(context) {
         // WU-2310: Capture file state before transaction commit
         // This allows rollback if git commit fails AFTER files are written
         // Note: We use the relative paths since we're already chdir'd into the worktree
-        const workingEventsPath = path.join('.beacon', 'state', WU_EVENTS_FILE_NAME);
+        const workingEventsPath = path.join('.lumenflow', 'state', WU_EVENTS_FILE_NAME);
         const pathsToSnapshot = [
             workingWUPath,
             workingStatusPath,
@@ -571,12 +571,12 @@ export async function checkBranchDrift(branch) {
  */
 const APPEND_ONLY_FILES = [
     // State store events file (append-only by design)
-    path.join('.beacon', 'state', WU_EVENTS_FILE_NAME),
+    path.join('.lumenflow', 'state', WU_EVENTS_FILE_NAME),
     // Status and backlog are generated from state store but may conflict during rebase
     WU_PATHS.STATUS(),
     WU_PATHS.BACKLOG(),
 ];
-const WU_EVENTS_PATH = path.join('.beacon', 'state', WU_EVENTS_FILE_NAME);
+const WU_EVENTS_PATH = path.join('.lumenflow', 'state', WU_EVENTS_FILE_NAME);
 function normalizeEventForKey(event) {
     const normalized = {};
     for (const key of Object.keys(event).sort()) {

package/dist/wu-paths.js

@@ -19,7 +19,7 @@ const PATH_DEPTHS = {
     STATUS: 4,
     /** WU YAML files are 5 levels deep: docs/04-operations/tasks/wu/{id}.yaml */
     WU_YAML: 5,
-    /** State store is 3 levels deep: .beacon/state/wu-events.jsonl */
+    /** State store is 3 levels deep: .lumenflow/state/wu-events.jsonl */
     STATE_STORE: 3,
 };
 /**

package/dist/wu-recovery.d.ts

@@ -23,7 +23,7 @@ export declare const MAX_RECOVERY_ATTEMPTS: 4;
  * WU-1335: Get the path to the recovery marker file for a WU
  *
  * @param {string} id - WU ID
- * @param {string} [baseDir=process.cwd()] - Base directory for .beacon
+ * @param {string} [baseDir=process.cwd()] - Base directory for .lumenflow
  * @returns {string} Path to recovery marker file
  */
 export declare function getRecoveryMarkerPath(id: any, baseDir?: string): string;
@@ -31,7 +31,7 @@ export declare function getRecoveryMarkerPath(id: any, baseDir?: string): string
  * WU-1335: Get the current recovery attempt count for a WU
  *
  * @param {string} id - WU ID
- * @param {string} [baseDir=process.cwd()] - Base directory for .beacon
+ * @param {string} [baseDir=process.cwd()] - Base directory for .lumenflow
  * @returns {number} Current attempt count (0 if no marker exists)
  */
 export declare function getRecoveryAttemptCount(id: any, baseDir?: string): any;
@@ -39,7 +39,7 @@ export declare function getRecoveryAttemptCount(id: any, baseDir?: string): any;
  * WU-1335: Increment recovery attempt count for a WU
  *
  * @param {string} id - WU ID
- * @param {string} [baseDir=process.cwd()] - Base directory for .beacon
+ * @param {string} [baseDir=process.cwd()] - Base directory for .lumenflow
  * @returns {number} New attempt count
  */
 export declare function incrementRecoveryAttempt(id: any, baseDir?: string): any;
@@ -47,7 +47,7 @@ export declare function incrementRecoveryAttempt(id: any, baseDir?: string): any
  * WU-1335: Clear recovery attempts for a WU (called on successful recovery)
  *
  * @param {string} id - WU ID
- * @param {string} [baseDir=process.cwd()] - Base directory for .beacon
+ * @param {string} [baseDir=process.cwd()] - Base directory for .lumenflow
  */
 export declare function clearRecoveryAttempts(id: any, baseDir?: string): void;
 /**