@lumenflow/core 2.9.0 → 2.11.0

package/dist/wu-constants.js

@@ -1066,6 +1066,7 @@ export const DIRECTORIES = {
     WORKTREES: 'worktrees/',
     AI: 'ai/',
     CLAUDE: '.claude/',
+    CLAUDE_HOOKS: '.claude/hooks/',
     DOCS: 'docs/',
     PACKAGES: 'packages/',
     TOOLS: 'tools/',
@@ -1076,6 +1077,43 @@ export const DIRECTORIES = {
     BACKLOG_PATH: 'docs/04-operations/tasks/backlog.md',
     STATUS_PATH: 'docs/04-operations/tasks/status.md',
 };
+/**
+ * Claude Code hook script constants (WU-1394)
+ *
+ * Centralized constants for Claude Code enforcement and recovery hooks.
+ * Used by enforcement-generator.ts, enforcement-sync.ts, and init.ts.
+ *
+ * @see packages/@lumenflow/cli/src/hooks/enforcement-generator.ts
+ * @see packages/@lumenflow/cli/src/hooks/enforcement-sync.ts
+ */
+export const CLAUDE_HOOKS = {
+    /** Hook script filenames */
+    SCRIPTS: {
+        ENFORCE_WORKTREE: 'enforce-worktree.sh',
+        REQUIRE_WU: 'require-wu.sh',
+        WARN_INCOMPLETE: 'warn-incomplete.sh',
+        PRE_COMPACT_CHECKPOINT: 'pre-compact-checkpoint.sh',
+        SESSION_START_RECOVERY: 'session-start-recovery.sh',
+    },
+    /** Hook command path prefix (uses Claude Code's $CLAUDE_PROJECT_DIR variable) */
+    PATH_PREFIX: '$CLAUDE_PROJECT_DIR/.claude/hooks',
+    /** Hook matchers for settings.json */
+    MATCHERS: {
+        ALL: '.*',
+        WRITE_EDIT: 'Write|Edit',
+        COMPACT: 'compact',
+        RESUME: 'resume',
+        CLEAR: 'clear',
+    },
+    /** Template paths (relative to templates directory) */
+    TEMPLATES: {
+        SETTINGS: 'vendors/claude/.claude/settings.json.template',
+        PRE_COMPACT: 'vendors/claude/.claude/hooks/pre-compact-checkpoint.sh',
+        SESSION_START: 'vendors/claude/.claude/hooks/session-start-recovery.sh',
+    },
+};
+/** Build full hook command path from script name */
+export const getHookCommand = (scriptName) => `${CLAUDE_HOOKS.PATH_PREFIX}/${scriptName}`;
 /**
  * ESLint cache strategy values
  */
@@ -1171,8 +1209,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 (supports both .beacon and .lumenflow for migration) */
-    STAMP: /\.(?:beacon|lumenflow)\/stamps\/(WU-\d+)\.done$/i,
+    /** Matches stamp file paths */
+    STAMP: /\.lumenflow\/stamps\/(WU-\d+)\.done$/i,
 };
 /**
  * Common shell commands
@@ -1286,8 +1324,6 @@ export const LOCK_DIR_NAME = '.lumenflow-locks';
  *
  * 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 LUMENFLOW_PATHS = {
     /** Base directory for all LumenFlow runtime data */
@@ -1296,6 +1332,8 @@ export const LUMENFLOW_PATHS = {
     STATE_DIR: '.lumenflow/state',
     /** Stamp directory (WU completion markers) */
     STAMPS_DIR: '.lumenflow/stamps',
+    /** Archive directory for old WU events (WU-1430) */
+    ARCHIVE_DIR: '.lumenflow/archive',
     /** Merge lock file (runtime coordination, WU-1747) */
     MERGE_LOCK: '.lumenflow/merge.lock',
     /** Base telemetry directory */
@@ -1326,6 +1364,30 @@ export const LUMENFLOW_PATHS = {
     LOCKS_DIR: '.lumenflow/locks',
     /** Force bypass audit log */
     FORCE_BYPASSES: '.lumenflow/force-bypasses.log',
+    /** Test baseline file for ratchet pattern (WU-1430) */
+    TEST_BASELINE: '.lumenflow/test-baseline.json',
+    /** Templates directory (WU-1430) */
+    TEMPLATES_DIR: '.lumenflow/templates',
+    /** Spawn prompt templates (WU-1430) */
+    SPAWN_PROMPT_DIR: '.lumenflow/templates/spawn-prompt',
+    /** Template manifest file (WU-1430) */
+    TEMPLATE_MANIFEST: '.lumenflow/templates/manifest.yaml',
+    /** Skills directory for agent skills (WU-1430) */
+    SKILLS_DIR: '.lumenflow/skills',
+    /** Agents directory for agent definitions (WU-1430) */
+    AGENTS_DIR: '.lumenflow/agents',
+    /** Methodology log for spawn telemetry (WU-1430) */
+    METHODOLOGY_LOG: '.lumenflow/telemetry/methodology.ndjson',
+    /** Prompt metrics cache (WU-1430) */
+    PROMPT_METRICS: '.lumenflow/telemetry/prompt-metrics.json',
+    /** Prompt lint results (WU-1430) */
+    PROMPT_LINT: '.lumenflow/telemetry/prompt-lint.ndjson',
+    /** Recovery markers directory (WU-1430) */
+    RECOVERY_DIR: '.lumenflow/recovery',
+    /** Checkpoints directory (WU-1430) */
+    CHECKPOINTS_DIR: '.lumenflow/checkpoints',
+    /** Cache directory under user home (WU-1430) */
+    HOME_CACHE: 'cache',
     /**
      * WU-1174: Runtime lock directory for merge/cleanup locks
      *
@@ -1340,10 +1402,6 @@ export const LUMENFLOW_PATHS = {
      */
     LOCK_DIR: path.join(tmpdir(), LOCK_DIR_NAME),
 };
-/**
- * @deprecated Use LUMENFLOW_PATHS instead. Will be removed in v2.0.
- */
-export const BEACON_PATHS = LUMENFLOW_PATHS;
 /**
  * File extensions
  *
@@ -1401,6 +1459,10 @@ export const PATH_LITERALS = {
     PLAN_FILE_SUFFIX: '-plan.md',
     /** Trailing slash regex pattern */
     TRAILING_SLASH_REGEX: /\/+$/,
+    /** .lumenflow path prefix for internal path detection (WU-1430) */
+    LUMENFLOW_PREFIX: '.lumenflow/',
+    /** Current directory prefix for repo-internal paths (WU-1430) */
+    CURRENT_DIR_PREFIX: './',
 };
 /**
  * Slice lengths for path operations

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

@@ -86,6 +86,13 @@ export declare function validateSpecRefs(specRefs: string[]): {
  * @returns {boolean} True if any spec_ref is an external path
  */
 export declare function hasExternalSpecRefs(specRefs: string[]): boolean;
+/**
+ * WU-1429: Check if spec_refs is non-empty
+ *
+ * @param {string[]|undefined} specRefs - Array of spec reference paths
+ * @returns {boolean} True if spec_refs contains at least one entry
+ */
+export declare function hasSpecRefs(specRefs: string[] | undefined): boolean;
 /**
  * WU-1062: Normalize all spec_refs paths
  *

package/dist/wu-create-validators.js

@@ -15,10 +15,11 @@
  * No external library exists for LumenFlow lane inference validation.
  */
 import { isExternalPath, normalizeSpecRef } from './lumenflow-home.js';
+import { PATH_LITERALS } from './wu-constants.js';
 /** Confidence threshold for showing suggestion (percentage) */
 const CONFIDENCE_THRESHOLD_LOW = 30;
-/** Prefixes that indicate repo-internal paths (WU-1069) */
-const REPO_INTERNAL_PREFIXES = ['./', '.lumenflow/'];
+/** Prefixes that indicate repo-internal paths (WU-1069, WU-1430: Use centralized constants) */
+const REPO_INTERNAL_PREFIXES = [PATH_LITERALS.CURRENT_DIR_PREFIX, PATH_LITERALS.LUMENFLOW_PREFIX];
 /**
  * WU-1069: Check if a path is a repo-internal path that should be rejected
  *
@@ -186,6 +187,15 @@ export function hasExternalSpecRefs(specRefs) {
     }
     return specRefs.some((ref) => isExternalPath(ref));
 }
+/**
+ * WU-1429: Check if spec_refs is non-empty
+ *
+ * @param {string[]|undefined} specRefs - Array of spec reference paths
+ * @returns {boolean} True if spec_refs contains at least one entry
+ */
+export function hasSpecRefs(specRefs) {
+    return Array.isArray(specRefs) && specRefs.length > 0;
+}
 /**
  * WU-1062: Normalize all spec_refs paths
  *

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

@@ -18,7 +18,7 @@ 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, BEACON_PATHS } from './wu-constants.js';
+import { REMOTES, BRANCHES, LUMENFLOW_PATHS } 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.
@@ -46,7 +46,7 @@ export async function fetchMainEventsContent() {
             console.warn('[wu-done] Warning: Could not fetch latest main, using cached version');
         }
         // Try to read wu-events.jsonl from origin/main
-        const eventsPath = `${BEACON_PATHS.STATE_DIR}/${WU_EVENTS_FILE_NAME}`;
+        const eventsPath = `${LUMENFLOW_PATHS.STATE_DIR}/${WU_EVENTS_FILE_NAME}`;
         const content = await git.raw(['show', `${REMOTES.ORIGIN}/${BRANCHES.MAIN}:${eventsPath}`]);
         return content;
     }

package/dist/wu-done-metadata.js

@@ -11,7 +11,7 @@ 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, 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 { DEFAULTS, LOG_PREFIX, EMOJI, PKG_MANAGER, SCRIPTS, PRETTIER_FLAGS, LUMENFLOW_PATHS, } from './wu-constants.js';
 import { applyExposureDefaults } from './wu-done-validation.js';
 import { createFileNotFoundError, createValidationError } from './wu-done-errors.js';
 import { writeWU } from './wu-yaml.js';
@@ -170,7 +170,7 @@ export async function stageAndFormatMetadata({ id, wuPath, statusPath, backlogPa
     // The singleton git adapter captures cwd at import time, which is wrong after process.chdir()
     const gitCwd = getGitForCwd();
     // Stage files
-    const wuEventsPath = path.join(BEACON_PATHS.STATE_DIR, WU_EVENTS_FILE_NAME);
+    const wuEventsPath = path.join(LUMENFLOW_PATHS.STATE_DIR, WU_EVENTS_FILE_NAME);
     const filesToStage = [wuPath, statusPath, backlogPath, stampsDir];
     if (existsSync(wuEventsPath)) {
         filesToStage.push(wuEventsPath);

package/dist/wu-done-validation.js

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

package/dist/wu-done-worktree.js

@@ -24,7 +24,7 @@ import { generateCommitMessage, collectMetadataToTransaction, stageAndFormatMeta
 import { getGitForCwd } from './git-adapter.js';
 import { readWU, writeWU } from './wu-yaml.js';
 import { WU_PATHS } from './wu-paths.js';
-import { BRANCHES, REMOTES, THRESHOLDS, LOG_PREFIX, EMOJI, COMMIT_FORMATS, BOX, STRING_LITERALS, WU_STATUS, GIT_COMMANDS, GIT_FLAGS, } from './wu-constants.js';
+import { BRANCHES, REMOTES, THRESHOLDS, LOG_PREFIX, EMOJI, COMMIT_FORMATS, BOX, STRING_LITERALS, WU_STATUS, GIT_COMMANDS, GIT_FLAGS, LUMENFLOW_PATHS, } from './wu-constants.js';
 import { RECOVERY, REBASE, PREFLIGHT, MERGE } from './wu-done-messages.js';
 import { getDriftLevel, DRIFT_LEVELS } from './branch-drift.js';
 import { createError, ErrorCodes } from './error-handler.js';
@@ -242,7 +242,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('.lumenflow', 'state', WU_EVENTS_FILE_NAME);
+        const workingEventsPath = path.join(LUMENFLOW_PATHS.STATE_DIR, WU_EVENTS_FILE_NAME);
         const pathsToSnapshot = [
             workingWUPath,
             workingStatusPath,
@@ -580,13 +580,14 @@ export async function checkBranchDrift(branch) {
  * that would break if paths are rearranged.
  */
 const APPEND_ONLY_FILES = [
-    // State store events file (append-only by design)
-    path.join('.lumenflow', 'state', WU_EVENTS_FILE_NAME),
+    // State store events file (append-only by design) - WU-1430: Use centralized constant
+    path.join(LUMENFLOW_PATHS.STATE_DIR, 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('.lumenflow', 'state', WU_EVENTS_FILE_NAME);
+// WU-1430: Use centralized constant
+const WU_EVENTS_PATH = path.join(LUMENFLOW_PATHS.STATE_DIR, WU_EVENTS_FILE_NAME);
 function normalizeEventForKey(event) {
     const normalized = {};
     for (const key of Object.keys(event).sort()) {

package/dist/wu-events-cleanup.js

@@ -29,12 +29,9 @@ import { WUStateStore, WU_EVENTS_FILE_NAME } from './wu-state-store.js';
  */
 const ONE_DAY_MS = 24 * 60 * 60 * 1000;
 /**
- * LumenFlow paths for state and archive
+ * Import centralized path constants (WU-1430)
  */
-const LUMENFLOW_PATHS = {
-    STATE_DIR: '.lumenflow/state',
-    ARCHIVE_DIR: '.lumenflow/archive',
-};
+import { LUMENFLOW_PATHS } from './wu-constants.js';
 /**
  * Default event archival configuration
  */

package/dist/wu-list.d.ts

@@ -0,0 +1,92 @@
+/**
+ * WU List Helper (WU-1411)
+ *
+ * Provides a consistent list of WUs by merging WUStateStore with YAML metadata.
+ * MCP server and other tools can use this instead of duplicating listing logic.
+ *
+ * Key behaviors:
+ * - Status from state store takes precedence over YAML status (more current)
+ * - Falls back to YAML status when WU is not in state store
+ * - Supports filtering by status and lane
+ * - Gracefully handles errors (missing files, invalid YAML)
+ *
+ * @module wu-list
+ * @see {@link ./wu-state-store.ts} - State store for runtime status
+ * @see {@link ./wu-yaml.ts} - YAML operations
+ * @see {@link ./wu-paths.ts} - Path utilities
+ */
+/**
+ * WU list entry returned by listWUs.
+ * Contains essential fields for display and filtering.
+ */
+export interface WUListEntry {
+    /** WU identifier (e.g., 'WU-100') */
+    id: string;
+    /** Short title describing the work */
+    title: string;
+    /** Lane assignment (e.g., 'Framework: Core') */
+    lane: string;
+    /** Current status (from state store or YAML) */
+    status: string;
+    /** Work type (feature, bug, documentation, etc.) */
+    type: string;
+    /** Priority level (P0-P3) */
+    priority: string;
+    /** Parent initiative reference (optional) */
+    initiative?: string;
+    /** Phase number within parent initiative (optional) */
+    phase?: number;
+    /** Creation date (YYYY-MM-DD) */
+    created?: string;
+}
+/**
+ * Options for listWUs function.
+ */
+export interface ListWUsOptions {
+    /** Project root directory (default: cwd) */
+    projectRoot?: string;
+    /** Filter by status (e.g., 'in_progress', 'blocked', 'done') */
+    status?: string;
+    /** Filter by lane (e.g., 'Framework: Core') */
+    lane?: string;
+    /**
+     * Direct path to WU directory (overrides config-based path).
+     * Useful for testing with virtual filesystems.
+     */
+    wuDir?: string;
+    /**
+     * Direct path to state directory (overrides config-based path).
+     * Useful for testing with virtual filesystems.
+     */
+    stateDir?: string;
+}
+/**
+ * Lists WUs by merging state store status with YAML metadata.
+ *
+ * The state store contains the most current status (claim, block, complete events),
+ * while YAML files contain the full metadata (title, lane, type, etc.).
+ *
+ * Status precedence:
+ * 1. State store status (if WU has events)
+ * 2. YAML status (fallback if not in state store)
+ *
+ * @param options - Listing options
+ * @returns Array of WU list entries
+ *
+ * @example
+ * // List all WUs
+ * const allWUs = await listWUs();
+ *
+ * @example
+ * // Filter by status
+ * const inProgress = await listWUs({ status: 'in_progress' });
+ *
+ * @example
+ * // Filter by lane
+ * const coreWUs = await listWUs({ lane: 'Framework: Core' });
+ *
+ * @example
+ * // Filter by both
+ * const blockedCore = await listWUs({ status: 'blocked', lane: 'Framework: Core' });
+ */
+export declare function listWUs(options?: ListWUsOptions): Promise<WUListEntry[]>;

package/dist/wu-list.js

@@ -0,0 +1,177 @@
+/**
+ * WU List Helper (WU-1411)
+ *
+ * Provides a consistent list of WUs by merging WUStateStore with YAML metadata.
+ * MCP server and other tools can use this instead of duplicating listing logic.
+ *
+ * Key behaviors:
+ * - Status from state store takes precedence over YAML status (more current)
+ * - Falls back to YAML status when WU is not in state store
+ * - Supports filtering by status and lane
+ * - Gracefully handles errors (missing files, invalid YAML)
+ *
+ * @module wu-list
+ * @see {@link ./wu-state-store.ts} - State store for runtime status
+ * @see {@link ./wu-yaml.ts} - YAML operations
+ * @see {@link ./wu-paths.ts} - Path utilities
+ */
+import { readdir } from 'node:fs/promises';
+import { join } from 'node:path';
+import { parse as parseYaml } from 'yaml';
+import { readFile } from 'node:fs/promises';
+import { WUStateStore } from './wu-state-store.js';
+import { getConfig } from './lumenflow-config.js';
+/**
+ * Lists WUs by merging state store status with YAML metadata.
+ *
+ * The state store contains the most current status (claim, block, complete events),
+ * while YAML files contain the full metadata (title, lane, type, etc.).
+ *
+ * Status precedence:
+ * 1. State store status (if WU has events)
+ * 2. YAML status (fallback if not in state store)
+ *
+ * @param options - Listing options
+ * @returns Array of WU list entries
+ *
+ * @example
+ * // List all WUs
+ * const allWUs = await listWUs();
+ *
+ * @example
+ * // Filter by status
+ * const inProgress = await listWUs({ status: 'in_progress' });
+ *
+ * @example
+ * // Filter by lane
+ * const coreWUs = await listWUs({ lane: 'Framework: Core' });
+ *
+ * @example
+ * // Filter by both
+ * const blockedCore = await listWUs({ status: 'blocked', lane: 'Framework: Core' });
+ */
+export async function listWUs(options = {}) {
+    const { projectRoot = process.cwd(), status: filterStatus, lane: filterLane, wuDir: wuDirOverride, stateDir: stateDirOverride, } = options;
+    // Determine paths: use overrides if provided, otherwise use config
+    let wuDir;
+    let stateDir;
+    if (wuDirOverride && stateDirOverride) {
+        // Direct paths provided (e.g., for testing)
+        wuDir = wuDirOverride;
+        stateDir = stateDirOverride;
+    }
+    else {
+        // Get configuration for paths
+        const config = getConfig({ projectRoot });
+        wuDir = wuDirOverride ?? join(projectRoot, config.directories.wuDir);
+        stateDir = stateDirOverride ?? join(projectRoot, config.state.stateDir);
+    }
+    // Load state store for runtime statuses
+    const stateMap = await loadStateStore(stateDir);
+    // Read all WU YAML files
+    const wuEntries = await readWUYamlFiles(wuDir);
+    // Merge state store status with YAML data
+    const entries = [];
+    for (const yamlData of wuEntries) {
+        // Skip invalid entries
+        if (!yamlData.id || typeof yamlData.id !== 'string') {
+            continue;
+        }
+        const wuId = yamlData.id;
+        // Get status: state store takes precedence
+        const stateEntry = stateMap.get(wuId);
+        const yamlStatus = typeof yamlData.status === 'string' ? yamlData.status : 'ready';
+        const status = stateEntry?.status ?? yamlStatus;
+        // Get lane: prefer state store (more current), fall back to YAML
+        const yamlLane = typeof yamlData.lane === 'string' ? yamlData.lane : '';
+        const lane = stateEntry?.lane ?? yamlLane;
+        // Extract string fields with type guards
+        const yamlTitle = typeof yamlData.title === 'string' ? yamlData.title : '';
+        const yamlType = typeof yamlData.type === 'string' ? yamlData.type : 'feature';
+        const yamlPriority = typeof yamlData.priority === 'string' ? yamlData.priority : 'P2';
+        // Build entry
+        const entry = {
+            id: wuId,
+            title: stateEntry?.title ?? yamlTitle,
+            lane,
+            status,
+            type: yamlType,
+            priority: yamlPriority,
+        };
+        // Add optional fields if present with type guards
+        if (typeof yamlData.initiative === 'string') {
+            entry.initiative = yamlData.initiative;
+        }
+        if (typeof yamlData.phase === 'number') {
+            entry.phase = yamlData.phase;
+        }
+        if (typeof yamlData.created === 'string') {
+            entry.created = yamlData.created;
+        }
+        // Apply filters
+        if (filterStatus && status !== filterStatus) {
+            continue;
+        }
+        if (filterLane && lane !== filterLane) {
+            continue;
+        }
+        entries.push(entry);
+    }
+    return entries;
+}
+/**
+ * Loads state store and returns a map of WU ID to state entry.
+ * Returns empty map on errors (graceful degradation).
+ */
+async function loadStateStore(stateDir) {
+    const map = new Map();
+    try {
+        const store = new WUStateStore(stateDir);
+        await store.load();
+        // Collect all known statuses
+        const statuses = ['in_progress', 'blocked', 'done', 'ready'];
+        for (const status of statuses) {
+            const wuIds = store.getByStatus(status);
+            for (const wuId of wuIds) {
+                const state = store.getWUState(wuId);
+                if (state) {
+                    map.set(wuId, state);
+                }
+            }
+        }
+    }
+    catch {
+        // Graceful degradation: return empty map on errors
+    }
+    return map;
+}
+/**
+ * Reads all WU YAML files from the WU directory.
+ * Skips invalid files (graceful degradation).
+ */
+async function readWUYamlFiles(wuDir) {
+    const entries = [];
+    try {
+        const files = await readdir(wuDir);
+        for (const file of files) {
+            // Only process WU-*.yaml files
+            if (!file.startsWith('WU-') || !file.endsWith('.yaml')) {
+                continue;
+            }
+            try {
+                const content = await readFile(join(wuDir, file), 'utf-8');
+                const parsed = parseYaml(content);
+                if (parsed && typeof parsed === 'object') {
+                    entries.push(parsed);
+                }
+            }
+            catch {
+                // Skip invalid YAML files
+            }
+        }
+    }
+    catch {
+        // Directory doesn't exist or can't be read
+    }
+    return entries;
+}

package/dist/wu-paths.js

@@ -45,7 +45,7 @@ export function resolveRepoRoot(absolutePath, depth) {
 export function getStateStoreDirFromBacklog(backlogPath) {
     const config = getConfig();
     const repoRoot = resolveRepoRoot(backlogPath, PATH_DEPTHS.BACKLOG);
-    return path.join(repoRoot, config.beacon.stateDir);
+    return path.join(repoRoot, config.state.stateDir);
 }
 /**
  * Create WU paths object with configurable base paths
@@ -82,18 +82,18 @@ export function createWuPaths(options = {}) {
          * Get path to stamps directory
          * @returns Path to stamps directory
          */
-        STAMPS_DIR: () => config.beacon.stampsDir,
+        STAMPS_DIR: () => config.state.stampsDir,
         /**
          * Get path to WU done stamp file
          * @param id - WU ID (e.g., 'WU-123')
          * @returns Path to stamp file
          */
-        STAMP: (id) => path.join(config.beacon.stampsDir, `${id}.done`),
+        STAMP: (id) => path.join(config.state.stampsDir, `${id}.done`),
         /**
          * Get path to state directory
          * @returns Path to state directory
          */
-        STATE_DIR: () => config.beacon.stateDir,
+        STATE_DIR: () => config.state.stateDir,
         /**
          * Get path to initiatives directory
          * @returns Path to initiatives directory

package/dist/wu-spawn-context.js

@@ -22,15 +22,16 @@
  */
 import { existsSync, statSync } from 'node:fs';
 import path from 'node:path';
+import { LUMENFLOW_PATHS } from './wu-constants.js';
 /**
  * Default maximum context size in bytes (4KB)
  */
 const DEFAULT_MAX_SIZE = 4096;
 /**
- * Memory layer paths
+ * Memory layer paths (WU-1430: Use centralized constants)
  */
 const MEMORY_PATHS = {
-    MEMORY_DIR: '.lumenflow/memory',
+    MEMORY_DIR: LUMENFLOW_PATHS.MEMORY_DIR,
     MEMORY_FILE: 'memory.jsonl',
 };
 /**

package/dist/wu-spawn-skills.js

@@ -1,12 +1,15 @@
 import { existsSync } from 'node:fs';
+import { LUMENFLOW_PATHS } from './wu-constants.js';
+/** WU-1430: Compose known skills directories from centralized constants */
 const KNOWN_SKILLS_DIRS = [
-    '.lumenflow/skills',
+    LUMENFLOW_PATHS.SKILLS_DIR,
     '.claude/skills',
     '.codex/skills',
     '.gemini/skills',
 ];
+/** WU-1430: Compose known agents directories from centralized constants */
 const KNOWN_AGENTS_DIRS = [
-    '.lumenflow/agents',
+    LUMENFLOW_PATHS.AGENTS_DIR,
     '.claude/agents',
     '.codex/agents',
     '.gemini/agents',
@@ -30,7 +33,7 @@ const CONTEXT_HINTS = {
     tddWorkflow: '- `tdd-workflow` — TDD is mandatory for feature/enhancement WUs',
     bugClassification: '- `bug-classification` — Bug severity assessment',
     lumenflowGates: '- `lumenflow-gates` — Tooling often affects gates',
-    beaconCompliance: '- `beacon-compliance` — Intelligence lane requires Beacon validation',
+    llmCompliance: '- `llm-compliance` — Intelligence lane requires LLM validation',
     promptManagement: '- `prompt-management` — For prompt template work',
     frontendDesign: '- `frontend-design` — For UI component work',
 };
@@ -38,7 +41,7 @@ const ADDITIONAL_SKILLS_TABLE = `| Skill | Use When |
 |-------|----------|
 | lumenflow-gates | Gates fail, debugging format/lint/typecheck errors |
 | bug-classification | Bug discovered mid-WU, need priority classification |
-| beacon-compliance | Code touches LLM, prompts, classification |
+| llm-compliance | Code touches LLM, prompts, classification |
 | prompt-management | Working with prompt templates, golden datasets |
 | frontend-design | Building UI components, pages |
 | initiative-management | Multi-phase projects, INIT-XXX coordination |
@@ -159,7 +162,7 @@ export function generateSkillsSelectionSection(doc, config, clientName) {
         contextHints.push(CONTEXT_HINTS.lumenflowGates);
     }
     if (laneParent === 'Intelligence') {
-        contextHints.push(CONTEXT_HINTS.beaconCompliance);
+        contextHints.push(CONTEXT_HINTS.llmCompliance);
         contextHints.push(CONTEXT_HINTS.promptManagement);
     }
     if (laneParent === 'Experience') {