@lumenflow/core 2.10.0 → 2.11.0

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') {

package/dist/wu-spawn.js

@@ -1191,9 +1191,8 @@ export function emitMethodologyTelemetry(config, policy) {
         methodology_architecture: policy.architecture,
         event_context: 'spawn',
     };
-    // Use the telemetry emit function from telemetry.ts
-    const METHODOLOGY_LOG = '.lumenflow/telemetry/methodology.ndjson';
-    emitTelemetry(METHODOLOGY_LOG, event);
+    // Use the telemetry emit function from telemetry.ts - WU-1430: Use centralized constant
+    emitTelemetry(LUMENFLOW_PATHS.METHODOLOGY_LOG, event);
 }
 /**
  * Generate Lane Selection section (WU-2107)
@@ -1261,10 +1260,10 @@ When creating \`.lumenflow/\` stamps or other artifacts:
 # CORRECT: Create stamp in worktree
 WORKTREE_ROOT=$(git rev-parse --show-toplevel)
 mkdir -p "$WORKTREE_ROOT/.lumenflow/agent-runs"
-touch "$WORKTREE_ROOT/.lumenflow/agent-runs/beacon-guardian.stamp"
+touch "$WORKTREE_ROOT/.lumenflow/agent-runs/code-reviewer.stamp"
 
 # WRONG: Hardcoded path to main
-# touch /path/to/main/.lumenflow/agent-runs/beacon-guardian.stamp
+# touch /path/to/main/.lumenflow/agent-runs/code-reviewer.stamp
 \`\`\`
 
 ### Why This Matters

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lumenflow/core",
-  "version": "2.10.0",
+  "version": "2.11.0",
   "description": "Core WU lifecycle tools for LumenFlow workflow framework",
   "keywords": [
     "lumenflow",
@@ -99,7 +99,7 @@
     "vitest": "^4.0.17"
   },
   "peerDependencies": {
-    "@lumenflow/memory": "2.10.0"
+    "@lumenflow/memory": "2.11.0"
   },
   "peerDependenciesMeta": {
     "@lumenflow/memory": {

package/dist/beacon-migration.d.ts

@@ -1,56 +0,0 @@
-/**
- * @file beacon-migration.ts
- * @description Migration utility for renaming .beacon directories to .lumenflow (WU-1075)
- *
- * This module provides a one-time migration function that renames the legacy
- * .beacon directory to .lumenflow. It's safe to run multiple times - it will
- * only migrate if .beacon exists and .lumenflow does not.
- *
- * @example
- * ```typescript
- * import { migrateBeaconToLumenflow } from '@lumenflow/core';
- *
- * // Run migration in project root
- * const result = migrateBeaconToLumenflow();
- * if (result.migrated) {
- *   console.log('Successfully migrated .beacon/ → .lumenflow/');
- * }
- * ```
- */
-/**
- * Result of a migration attempt
- */
-export interface MigrationResult {
-    /** Whether migration was performed */
-    migrated: boolean;
-    /** Reason for the result */
-    reason: 'migrated' | 'already_migrated' | 'no_legacy_dir' | 'both_exist';
-    /** Path that was migrated from (if migrated) */
-    fromPath?: string;
-    /** Path that was migrated to (if migrated) */
-    toPath?: string;
-    /** Error message if migration failed */
-    error?: string;
-}
-/**
- * Migrate .beacon directory to .lumenflow
- *
- * This function safely renames the legacy .beacon directory to .lumenflow.
- * It handles the following scenarios:
- *
- * - .beacon exists, .lumenflow does not → Migrate (rename)
- * - .beacon does not exist, .lumenflow exists → Already migrated (no-op)
- * - Neither exists → No legacy directory (no-op)
- * - Both exist → Conflict, manual resolution needed
- *
- * @param {string} [baseDir=process.cwd()] - Base directory to check for migration
- * @returns {MigrationResult} Result of the migration attempt
- */
-export declare function migrateBeaconToLumenflow(baseDir?: string): MigrationResult;
-/**
- * Check if migration is needed without performing it
- *
- * @param {string} [baseDir=process.cwd()] - Base directory to check
- * @returns {boolean} True if .beacon exists and .lumenflow does not
- */
-export declare function needsMigration(baseDir?: string): boolean;