@lumenflow/cli 1.3.3 → 1.3.5

package/dist/orchestrate-monitor.js

@@ -11,11 +11,10 @@
 import { Command } from 'commander';
 import { existsSync, readdirSync, readFileSync } from 'node:fs';
 import { join } from 'node:path';
-import { EXIT_CODES } from '@lumenflow/core/dist/wu-constants.js';
+import { EXIT_CODES, LUMENFLOW_PATHS } from '@lumenflow/core/dist/wu-constants.js';
 import chalk from 'chalk';
 import ms from 'ms';
 const LOG_PREFIX = '[orchestrate:monitor]';
-const MEMORY_DIR = '.beacon/memory';
 function parseTimeString(timeStr) {
     const msValue = ms(timeStr);
     if (typeof msValue === 'number') {
@@ -29,12 +28,12 @@ function parseTimeString(timeStr) {
 }
 function loadRecentSignals(since) {
     const signals = [];
-    if (!existsSync(MEMORY_DIR)) {
+    if (!existsSync(LUMENFLOW_PATHS.MEMORY_DIR)) {
         return signals;
     }
-    const files = readdirSync(MEMORY_DIR).filter((f) => f.endsWith('.ndjson'));
+    const files = readdirSync(LUMENFLOW_PATHS.MEMORY_DIR).filter((f) => f.endsWith('.ndjson'));
     for (const file of files) {
-        const filePath = join(MEMORY_DIR, file);
+        const filePath = join(LUMENFLOW_PATHS.MEMORY_DIR, file);
         const content = readFileSync(filePath, 'utf-8');
         const lines = content.trim().split('\n').filter(Boolean);
         for (const line of lines) {

package/dist/release.js

@@ -0,0 +1,310 @@
+#!/usr/bin/env node
+/**
+ * Release Command
+ *
+ * Orchestrates npm release for all @lumenflow/* packages using micro-worktree isolation.
+ *
+ * Features:
+ * - Validates semver version format
+ * - Bumps all @lumenflow/* package versions atomically
+ * - Uses micro-worktree isolation for version commit (no main branch pollution)
+ * - Builds all packages via turbo
+ * - Publishes to npm with proper auth (requires NPM_TOKEN)
+ * - Creates git tag vX.Y.Z
+ *
+ * Usage:
+ *   pnpm release --version 1.3.0
+ *   pnpm release --version 1.3.0 --dry-run     # Preview without making changes
+ *   pnpm release --version 1.3.0 --skip-publish # Bump and tag only (no npm publish)
+ *
+ * WU-1074: Add release command for npm publishing
+ */
+import { Command } from 'commander';
+import { existsSync, readFileSync, readdirSync, statSync } from 'node:fs';
+import { readFile, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { execSync } from 'node:child_process';
+import { getGitForCwd } from '@lumenflow/core/dist/git-adapter.js';
+import { die } from '@lumenflow/core/dist/error-handler.js';
+import { withMicroWorktree } from '@lumenflow/core/dist/micro-worktree.js';
+import { ensureOnMain } from '@lumenflow/core/dist/wu-helpers.js';
+import { REMOTES, FILE_SYSTEM, PKG_MANAGER, } from '@lumenflow/core/dist/wu-constants.js';
+import { runCLI } from './cli-entry-point.js';
+/** Log prefix for console output */
+const LOG_PREFIX = '[release]';
+/** Micro-worktree operation name */
+const OPERATION_NAME = 'release';
+/** Directory containing @lumenflow packages */
+const LUMENFLOW_PACKAGES_DIR = 'packages/@lumenflow';
+/** Semver regex pattern (strict) */
+const SEMVER_REGEX = /^\d+\.\d+\.\d+(-[a-zA-Z0-9.-]+)?$/;
+/** JSON indent size for package.json files */
+const JSON_INDENT = 2;
+/** Default npm registry */
+const NPM_REGISTRY = 'https://registry.npmjs.org';
+/** Environment variable for npm authentication token */
+const NPM_TOKEN_ENV = 'NPM_TOKEN';
+/** Environment variable for alternative npm auth */
+const NODE_AUTH_TOKEN_ENV = 'NODE_AUTH_TOKEN';
+/**
+ * Validate that a string is a valid semver version
+ *
+ * @param version - Version string to validate
+ * @returns true if valid semver, false otherwise
+ */
+export function validateSemver(version) {
+    if (!version || typeof version !== 'string') {
+        return false;
+    }
+    return SEMVER_REGEX.test(version);
+}
+/**
+ * Find all public @lumenflow/* package.json paths
+ *
+ * @param baseDir - Base directory to search from (defaults to cwd)
+ * @returns Array of absolute paths to package.json files
+ */
+export function findPackageJsonPaths(baseDir = process.cwd()) {
+    const packagesDir = join(baseDir, LUMENFLOW_PACKAGES_DIR);
+    const paths = [];
+    if (!existsSync(packagesDir)) {
+        return paths;
+    }
+    const entries = readdirSync(packagesDir);
+    for (const entry of entries) {
+        const entryPath = join(packagesDir, entry);
+        const packageJsonPath = join(entryPath, 'package.json');
+        if (statSync(entryPath).isDirectory() && existsSync(packageJsonPath)) {
+            // Read package.json to check if it's private
+            const content = JSON.parse(readFileSync(packageJsonPath, { encoding: FILE_SYSTEM.UTF8 }));
+            // Only include public packages (not marked private)
+            if (!content.private) {
+                paths.push(packageJsonPath);
+            }
+        }
+    }
+    return paths;
+}
+/**
+ * Update version in specified package.json files
+ *
+ * @param paths - Array of package.json paths
+ * @param version - New version string
+ */
+export async function updatePackageVersions(paths, version) {
+    for (const packagePath of paths) {
+        const content = await readFile(packagePath, {
+            encoding: FILE_SYSTEM.ENCODING,
+        });
+        const pkg = JSON.parse(content);
+        // Update version
+        pkg.version = version;
+        // Write back with preserved formatting (2-space indent)
+        const updated = JSON.stringify(pkg, null, JSON_INDENT) + '\n';
+        await writeFile(packagePath, updated, { encoding: FILE_SYSTEM.ENCODING });
+    }
+}
+/**
+ * Build commit message for version bump
+ *
+ * @param version - New version string
+ * @returns Commit message
+ */
+export function buildCommitMessage(version) {
+    return `chore: bump all packages to v${version}`;
+}
+/**
+ * Build git tag name from version
+ *
+ * @param version - Version string
+ * @returns Git tag name with 'v' prefix
+ */
+export function buildTagName(version) {
+    return `v${version}`;
+}
+/**
+ * Get relative path from worktree root
+ *
+ * @param absolutePath - Absolute file path
+ * @param worktreePath - Worktree root path
+ * @returns Relative path
+ */
+function getRelativePath(absolutePath, worktreePath) {
+    return absolutePath.replace(worktreePath + '/', '');
+}
+/**
+ * Execute a shell command and handle errors
+ *
+ * @param cmd - Command to execute
+ * @param options - Options for execution
+ */
+function runCommand(cmd, options = {}) {
+    const { cwd = process.cwd(), dryRun = false, label } = options;
+    const prefix = label ? `[${label}] ` : '';
+    if (dryRun) {
+        console.log(`${LOG_PREFIX} ${prefix}Would run: ${cmd}`);
+        return;
+    }
+    console.log(`${LOG_PREFIX} ${prefix}Running: ${cmd}`);
+    try {
+        execSync(cmd, {
+            cwd,
+            stdio: 'inherit',
+            encoding: FILE_SYSTEM.ENCODING,
+        });
+    }
+    catch (error) {
+        throw new Error(`Command failed: ${cmd}`);
+    }
+}
+/**
+ * Check if npm authentication is available
+ *
+ * @returns true if NPM_TOKEN or NODE_AUTH_TOKEN is set
+ */
+function hasNpmAuth() {
+    return Boolean(process.env[NPM_TOKEN_ENV] || process.env[NODE_AUTH_TOKEN_ENV]);
+}
+/**
+ * Main release function
+ */
+async function main() {
+    const program = new Command()
+        .name('release')
+        .description('Release @lumenflow/* packages to npm with version bump, tag, and publish')
+        .requiredOption('-v, --version <version>', 'Semver version to release (e.g., 1.3.0)')
+        .option('--dry-run', 'Preview changes without making them', false)
+        .option('--skip-publish', 'Skip npm publish (only bump and tag)', false)
+        .option('--skip-build', 'Skip build step (use existing dist)', false)
+        .helpOption('-h, --help', 'Display help for command');
+    program.parse();
+    const opts = program.opts();
+    const { version, dryRun, skipPublish, skipBuild } = opts;
+    console.log(`${LOG_PREFIX} Starting release process for v${version}`);
+    if (dryRun) {
+        console.log(`${LOG_PREFIX} DRY RUN MODE - no changes will be made`);
+    }
+    // Validate version format
+    if (!validateSemver(version)) {
+        die(`Invalid semver version: ${version}\n\n` +
+            `Expected format: MAJOR.MINOR.PATCH (e.g., 1.3.0)\n` +
+            `Optional pre-release suffix: 1.3.0-alpha, 1.3.0-beta.1`);
+    }
+    // Ensure we're on main branch
+    const git = getGitForCwd();
+    await ensureOnMain(git);
+    // Check for uncommitted changes
+    const isClean = await git.isClean();
+    if (!isClean) {
+        die(`Working directory has uncommitted changes.\n\n` +
+            `Commit or stash changes before releasing:\n` +
+            `  git status\n` +
+            `  git stash  # or git commit`);
+    }
+    // Find all @lumenflow/* packages to update
+    const packagePaths = findPackageJsonPaths();
+    if (packagePaths.length === 0) {
+        die(`No @lumenflow/* packages found in ${LUMENFLOW_PACKAGES_DIR}`);
+    }
+    console.log(`${LOG_PREFIX} Found ${packagePaths.length} packages to update:`);
+    for (const p of packagePaths) {
+        console.log(`  - ${p.replace(process.cwd() + '/', '')}`);
+    }
+    // Check npm authentication for publish
+    if (!skipPublish && !dryRun && !hasNpmAuth()) {
+        die(`npm authentication not found.\n\n` +
+            `Set one of these environment variables:\n` +
+            `  export NPM_TOKEN=<your-npm-token>\n` +
+            `  export NODE_AUTH_TOKEN=<your-npm-token>\n\n` +
+            `Get a token at: https://www.npmjs.com/settings/tokens\n` +
+            `Or use --skip-publish to only bump versions and create tag.`);
+    }
+    // Execute version bump in micro-worktree
+    if (dryRun) {
+        console.log(`${LOG_PREFIX} Would bump versions to ${version} using micro-worktree isolation`);
+        console.log(`${LOG_PREFIX} Would commit: ${buildCommitMessage(version)}`);
+    }
+    else {
+        console.log(`${LOG_PREFIX} Bumping versions using micro-worktree isolation...`);
+        await withMicroWorktree({
+            operation: OPERATION_NAME,
+            id: `v${version}`,
+            logPrefix: LOG_PREFIX,
+            execute: async ({ worktreePath }) => {
+                // Find package paths within the worktree
+                const worktreePackagePaths = findPackageJsonPaths(worktreePath);
+                // Update versions
+                console.log(`${LOG_PREFIX} Updating ${worktreePackagePaths.length} package versions...`);
+                await updatePackageVersions(worktreePackagePaths, version);
+                // Get relative paths for commit
+                const relativePaths = worktreePackagePaths.map((p) => getRelativePath(p, worktreePath));
+                console.log(`${LOG_PREFIX} ✅ Versions updated to ${version}`);
+                return {
+                    commitMessage: buildCommitMessage(version),
+                    files: relativePaths,
+                };
+            },
+        });
+        console.log(`${LOG_PREFIX} ✅ Version bump committed and pushed`);
+    }
+    // Build packages
+    if (!skipBuild) {
+        runCommand(`${PKG_MANAGER} build`, { dryRun, label: 'build' });
+        console.log(`${LOG_PREFIX} ✅ Build complete`);
+    }
+    else {
+        console.log(`${LOG_PREFIX} Skipping build (--skip-build)`);
+    }
+    // Create git tag
+    const tagName = buildTagName(version);
+    if (dryRun) {
+        console.log(`${LOG_PREFIX} Would create tag: ${tagName}`);
+        console.log(`${LOG_PREFIX} Would push tag to ${REMOTES.ORIGIN}`);
+    }
+    else {
+        console.log(`${LOG_PREFIX} Creating tag ${tagName}...`);
+        await git.raw(['tag', '-a', tagName, '-m', `Release ${tagName}`]);
+        console.log(`${LOG_PREFIX} ✅ Tag created: ${tagName}`);
+        console.log(`${LOG_PREFIX} Pushing tag to ${REMOTES.ORIGIN}...`);
+        await git.push(REMOTES.ORIGIN, tagName);
+        console.log(`${LOG_PREFIX} ✅ Tag pushed`);
+    }
+    // Publish to npm
+    if (!skipPublish) {
+        if (dryRun) {
+            console.log(`${LOG_PREFIX} Would publish packages to npm`);
+        }
+        else {
+            console.log(`${LOG_PREFIX} Publishing packages to npm...`);
+            runCommand(`${PKG_MANAGER} -r publish --access public --no-git-checks`, { label: 'publish' });
+            console.log(`${LOG_PREFIX} ✅ Packages published to npm`);
+        }
+    }
+    else {
+        console.log(`${LOG_PREFIX} Skipping npm publish (--skip-publish)`);
+    }
+    // Summary
+    console.log(`\n${LOG_PREFIX} 🎉 Release complete!`);
+    console.log(`${LOG_PREFIX} Version: ${version}`);
+    console.log(`${LOG_PREFIX} Tag: ${tagName}`);
+    if (!skipPublish && !dryRun) {
+        console.log(`${LOG_PREFIX} npm: https://www.npmjs.com/org/lumenflow`);
+    }
+    console.log(`\n${LOG_PREFIX} Next steps:`);
+    if (dryRun) {
+        console.log(`  - Run without --dry-run to execute the release`);
+    }
+    else {
+        console.log(`  - Create GitHub release: gh release create ${tagName} --title "Release ${tagName}"`);
+        if (skipPublish) {
+            console.log(`  - Publish to npm: ${PKG_MANAGER} -r publish --access public --no-git-checks`);
+        }
+        console.log(`  - Verify packages: npm view @lumenflow/cli version`);
+    }
+}
+// Export for testing
+export { main };
+// Guard main() for testability
+if (import.meta.main) {
+    runCLI(main);
+}

package/dist/spawn-list.js

@@ -15,7 +15,7 @@
  */
 import { createWUParser, WU_OPTIONS } from '@lumenflow/core/dist/arg-parser.js';
 import { die } from '@lumenflow/core/dist/error-handler.js';
-import { PATTERNS } from '@lumenflow/core/dist/wu-constants.js';
+import { PATTERNS, LUMENFLOW_PATHS, DIRECTORIES } from '@lumenflow/core/dist/wu-constants.js';
 /** Local EMOJI constants for spawn-list output */
 const EMOJI = {
     WARNING: '⚠️',
@@ -40,8 +40,8 @@ import { SpawnStatus } from '@lumenflow/core/dist/spawn-registry-schema.js';
 const LOG_PREFIX = '[spawn:list]';
 /** Default paths for spawn registry and WU files */
 const DEFAULT_PATHS = Object.freeze({
-    REGISTRY_DIR: '.beacon/state',
-    WU_DIR: 'docs/04-operations/tasks/wu',
+    REGISTRY_DIR: LUMENFLOW_PATHS.STATE_DIR,
+    WU_DIR: DIRECTORIES.WU_DIR,
 });
 /** Initiative ID pattern */
 const INIT_PATTERN = /^INIT-\d+$/;

package/dist/wu-block.js

@@ -190,7 +190,7 @@ async function main() {
                 // Update backlog.md in micro-worktree (WU-1574: regenerate from state store)
                 await regenerateBacklogFromState(microBacklogPath);
                 // Append block event to WUStateStore (WU-1573)
-                const stateDir = path.join(worktreePath, '.beacon', 'state');
+                const stateDir = path.join(worktreePath, '.lumenflow', 'state');
                 const store = new WUStateStore(stateDir);
                 await store.load();
                 await store.block(id, args.reason || 'No reason provided');
@@ -200,7 +200,7 @@ async function main() {
                         WU_PATHS.WU(id),
                         WU_PATHS.STATUS(),
                         WU_PATHS.BACKLOG(),
-                        '.beacon/state/wu-events.jsonl',
+                        '.lumenflow/state/wu-events.jsonl',
                     ],
                 };
             },

package/dist/wu-claim.js

@@ -351,7 +351,7 @@ async function appendClaimEventOnly(stateDir, id, title, lane) {
 export function getWorktreeCommitFiles(wuId) {
     return [
         `docs/04-operations/tasks/wu/${wuId}.yaml`,
-        '.beacon/state/wu-events.jsonl', // WU-1740: Event store is source of truth
+        '.lumenflow/state/wu-events.jsonl', // WU-1740: Event store is source of truth
         // WU-1746: Explicitly NOT including:
         // - docs/04-operations/tasks/backlog.md
         // - docs/04-operations/tasks/status.md
@@ -407,7 +407,12 @@ async function applyCanonicalClaimUpdate(ctx, sessionId) {
     let updatedTitle = '';
     const filesToCommit = args.noAuto && stagedChanges.length > 0
         ? stagedChanges.map((change) => change.filePath).filter(Boolean)
-        : [WU_PATHS.WU(id), WU_PATHS.STATUS(), WU_PATHS.BACKLOG(), '.beacon/state/wu-events.jsonl'];
+        : [
+            WU_PATHS.WU(id),
+            WU_PATHS.STATUS(),
+            WU_PATHS.BACKLOG(),
+            '.lumenflow/state/wu-events.jsonl',
+        ];
     console.log(`${PREFIX} Updating canonical claim state (push-only)...`);
     await withMicroWorktree({
         operation: MICRO_WORKTREE_OPERATIONS.WU_CLAIM,
@@ -560,8 +565,8 @@ async function handleOrphanCheck(lane, id) {
                     files: [
                         WU_PATHS.BACKLOG(),
                         WU_PATHS.STATUS(),
-                        `.beacon/stamps/${orphanId}.done`,
-                        '.beacon/state/wu-events.jsonl',
+                        `.lumenflow/stamps/${orphanId}.done`,
+                        '.lumenflow/state/wu-events.jsonl',
                     ],
                 };
             },

package/dist/wu-create.js

@@ -236,7 +236,7 @@ function buildWUContent({ id, lane, title, priority, type, created, opts, }) {
         acceptance,
         code_paths,
         tests,
-        artifacts: [`.beacon/stamps/${id}.done`],
+        artifacts: [`.lumenflow/stamps/${id}.done`],
         dependencies: [],
         risks: [],
         notes: '',

package/dist/wu-done.js

@@ -7,7 +7,7 @@
  * 2) Pre-flight validation: run ALL pre-commit hooks before merge (prevents partial completion)
  * 3) cd into worktree
  * 4) Auto-update WU YAML/backlog/status to Done in worktree (unless --no-auto)
- * 5) Create `.beacon/stamps/WU-{id}.done` in worktree
+ * 5) Create `.lumenflow/stamps/WU-{id}.done` in worktree
  * 6) Validate staged files against whitelist
  * 7) Commit metadata changes in worktree (on lane branch)
  * 8) cd back to main
@@ -15,7 +15,7 @@
  * 10) Push to `main`
  * 11) Remove the associated worktree (unless --no-remove)
  * 12) Optionally delete the lane branch (with --delete-branch)
- * 13) Emit telemetry to .beacon/flow.log
+ * 13) Emit telemetry to .lumenflow/flow.log
  *
  * Canonical sequence (Branch-Only mode - LEGACY):
  * 1) Run gates on lane branch (in main checkout)
@@ -94,7 +94,7 @@ const MEMORY_CHECKPOINT_NOTES = {
 };
 const MEMORY_SIGNAL_WINDOW_MS = 60 * 60 * 1000; // 1 hour for recent signals
 // Path constant for wu-events.jsonl (used in multiple places)
-const WU_EVENTS_PATH = '.beacon/state/wu-events.jsonl';
+const WU_EVENTS_PATH = '.lumenflow/state/wu-events.jsonl';
 /**
  * WU-1804: Preflight validation for claim metadata before gates.
  *
@@ -118,7 +118,7 @@ async function validateClaimMetadataBeforeGates(id, worktreePath, yamlStatus) {
     }
     // Check 2: State store must show WU as in_progress
     const resolvedWorktreePath = path.resolve(worktreePath);
-    const stateDir = path.join(resolvedWorktreePath, '.beacon', 'state');
+    const stateDir = path.join(resolvedWorktreePath, '.lumenflow', 'state');
     const eventsPath = path.join(resolvedWorktreePath, WU_EVENTS_PATH);
     try {
         const store = new WUStateStore(stateDir);
@@ -247,7 +247,7 @@ export function buildGatesCommand(options) {
 }
 async function assertWorktreeWUInProgressInStateStore(id, worktreePath) {
     const resolvedWorktreePath = path.resolve(worktreePath);
-    const stateDir = path.join(resolvedWorktreePath, '.beacon', 'state');
+    const stateDir = path.join(resolvedWorktreePath, '.lumenflow', 'state');
     const eventsPath = path.join(resolvedWorktreePath, WU_EVENTS_PATH);
     const store = new WUStateStore(stateDir);
     try {
@@ -367,12 +367,12 @@ async function checkInboxForRecentSignals(id, baseDir = process.cwd()) {
  * - Any error during update
  *
  * @param {string} id - WU ID being completed
- * @param {string} baseDir - Base directory containing .beacon/state/
+ * @param {string} baseDir - Base directory containing .lumenflow/state/
  * @returns {Promise<void>}
  */
 export async function updateSpawnRegistryOnCompletion(id, baseDir = process.cwd()) {
     try {
-        const store = new SpawnRegistryStore(path.join(baseDir, '.beacon', 'state'));
+        const store = new SpawnRegistryStore(path.join(baseDir, '.lumenflow', 'state'));
         await store.load();
         const spawnEntry = store.getByTarget(id);
         // Graceful skip if no spawn entry found (legacy WU)
@@ -684,7 +684,7 @@ async function ensureMainUpToDate() {
 /**
  * Tripwire check: Scan commands log for violations (WU-630 detective layer)
  *
- * Scans .beacon/commands.log for destructive git commands executed during
+ * Scans .lumenflow/commands.log for destructive git commands executed during
  * this agent session. If violations are found, aborts wu:done and displays
  * remediation guidance.
  *
@@ -768,7 +768,7 @@ async function ensureNoAutoStagedOrNoop(paths) {
     return { noop: false };
 }
 export function emitTelemetry(event) {
-    const logPath = path.join('.beacon', 'flow.log');
+    const logPath = path.join('.lumenflow', 'flow.log');
     const logDir = path.dirname(logPath);
     if (!existsSync(logDir))
         mkdirSync(logDir, { recursive: true });
@@ -776,7 +776,7 @@ export function emitTelemetry(event) {
     appendFileSync(logPath, `${line}\n`, { encoding: FILE_SYSTEM.UTF8 });
 }
 async function auditSkipGates(id, reason, fixWU, worktreePath) {
-    const auditPath = path.join('.beacon', 'skip-gates-audit.log');
+    const auditPath = path.join('.lumenflow', 'skip-gates-audit.log');
     const auditDir = path.dirname(auditPath);
     if (!existsSync(auditDir))
         mkdirSync(auditDir, { recursive: true });
@@ -801,7 +801,7 @@ async function auditSkipGates(id, reason, fixWU, worktreePath) {
  * Audit trail for --skip-cos-gates (COS v1.3 §7)
  */
 async function auditSkipCosGates(id, reason) {
-    const auditPath = path.join('.beacon', 'skip-cos-gates-audit.log');
+    const auditPath = path.join('.lumenflow', 'skip-cos-gates-audit.log');
     const auditDir = path.dirname(auditPath);
     if (!existsSync(auditDir))
         mkdirSync(auditDir, { recursive: true });
@@ -953,8 +953,8 @@ async function validateStagedFiles(id, isDocsOnly = false) {
         // Whitelist exact matches
         if (whitelist.includes(file))
             return false;
-        // Whitelist .beacon/stamps/** pattern
-        if (file.startsWith('.beacon/stamps/'))
+        // Whitelist .lumenflow/stamps/** pattern
+        if (file.startsWith('.lumenflow/stamps/'))
             return false;
         // WU-1072: Whitelist apps/docs/**/*.mdx for auto-generated docs from turbo docs:generate
         if (file.startsWith('apps/docs/') && file.endsWith('.mdx'))
@@ -967,7 +967,7 @@ async function validateStagedFiles(id, isDocsOnly = false) {
             console.warn(`${LOG_PREFIX.DONE} Warning: other WU YAMLs are staged; proceeding and committing only current WU files.`);
         }
         else {
-            die(`Unexpected files staged (only current WU YAML, status.md, backlog.md, .beacon/stamps/<id>.done allowed):\n  ${unexpected.join(`${STRING_LITERALS.NEWLINE}  `)}`);
+            die(`Unexpected files staged (only current WU YAML, status.md, backlog.md, .lumenflow/stamps/<id>.done allowed):\n  ${unexpected.join(`${STRING_LITERALS.NEWLINE}  `)}`);
         }
     }
 }
@@ -1349,7 +1349,7 @@ async function checkOwnership(id, doc, worktreePath, overrideOwner = false, over
  * @param {object} auditEntry - Audit entry to log
  */
 function auditOwnershipOverride(auditEntry) {
-    const auditPath = path.join('.beacon', 'ownership-override-audit.log');
+    const auditPath = path.join('.lumenflow', 'ownership-override-audit.log');
     const auditDir = path.dirname(auditPath);
     if (!existsSync(auditDir))
         mkdirSync(auditDir, { recursive: true });
@@ -2166,13 +2166,13 @@ export function printDocValidationNudge(id, changedDocPaths) {
  * WU-1763: Load discoveries for a WU from memory store.
  * Non-blocking - returns empty array on errors.
  *
- * @param {string} baseDir - Base directory containing .beacon/memory/
+ * @param {string} baseDir - Base directory containing .lumenflow/memory/
  * @param {string} wuId - WU ID to load discoveries for
  * @returns {Promise<{count: number, ids: string[]}>} Discovery count and IDs
  */
 async function loadDiscoveriesForWU(baseDir, wuId) {
     try {
-        const memory = await loadMemory(path.join(baseDir, '.beacon/memory'));
+        const memory = await loadMemory(path.join(baseDir, '.lumenflow/memory'));
         const wuNodes = memory.byWu.get(wuId) || [];
         const discoveries = wuNodes.filter((node) => node.type === 'discovery');
         return {

package/dist/wu-repair.js

@@ -161,12 +161,12 @@ function validateModeRequirements(options) {
  * Run state file repair mode (WU-2240)
  *
  * @param {object} options - CLI options
- * @param {string} [options.path] - Path to state file (defaults to .beacon/state/wu-events.jsonl)
+ * @param {string} [options.path] - Path to state file (defaults to .lumenflow/state/wu-events.jsonl)
  * @returns {Promise<{success: boolean, exitCode: number}>}
  */
 async function runStateRepairMode(options) {
-    // Default path is .beacon/state/wu-events.jsonl relative to cwd
-    const defaultPath = path.join(process.cwd(), '.beacon', 'state', WU_EVENTS_FILE_NAME);
+    // Default path is .lumenflow/state/wu-events.jsonl relative to cwd
+    const defaultPath = path.join(process.cwd(), '.lumenflow', 'state', WU_EVENTS_FILE_NAME);
     const filePath = options.path || defaultPath;
     console.log(`${PREFIX} Repairing state file: ${filePath}`);
     try {

package/dist/wu-spawn.js

@@ -635,7 +635,7 @@ git rev-parse --show-toplevel
 
 ### Stamp Creation
 
-When creating \`.beacon/\` stamps or other artifacts:
+When creating \`.lumenflow/\` stamps or other artifacts:
 
 1. **ALWAYS** create stamps in the **worktree**, not main
 2. Use \`git rev-parse --show-toplevel\` to get the correct base path
@@ -644,11 +644,11 @@ When creating \`.beacon/\` stamps or other artifacts:
 \`\`\`bash
 # CORRECT: Create stamp in worktree
 WORKTREE_ROOT=$(git rev-parse --show-toplevel)
-mkdir -p "$WORKTREE_ROOT/.beacon/agent-runs"
-touch "$WORKTREE_ROOT/.beacon/agent-runs/beacon-guardian.stamp"
+mkdir -p "$WORKTREE_ROOT/.lumenflow/agent-runs"
+touch "$WORKTREE_ROOT/.lumenflow/agent-runs/beacon-guardian.stamp"
 
 # WRONG: Hardcoded path to main
-# touch /path/to/main/.beacon/agent-runs/beacon-guardian.stamp
+# touch /path/to/main/.lumenflow/agent-runs/beacon-guardian.stamp
 \`\`\`
 
 ### Why This Matters
@@ -774,7 +774,7 @@ cd worktrees/${laneSlug}-${id.toLowerCase()}
 Then implement following all standards above.
 
 **CRITICAL:** Never use \`git worktree add\` directly. Always use \`pnpm wu:claim\` to ensure:
-- Event tracking in .beacon/state/wu-events.jsonl
+- Event tracking in .lumenflow/state/wu-events.jsonl
 - Lane lock acquisition (WIP=1 enforcement)
 - Session tracking for context recovery`;
 }
@@ -1233,7 +1233,7 @@ async function main() {
             parentWuId: args.parentWu,
             targetWuId: id,
             lane: doc.lane || 'Unknown',
-            baseDir: '.beacon/state',
+            baseDir: '.lumenflow/state',
         });
         const registryMessage = formatSpawnRecordedMessage(registryResult.spawnId, registryResult.error);
         console.log(`\n${registryMessage}`);

package/dist/wu-unblock.js

@@ -187,7 +187,7 @@ async function main() {
                 appendNote(microDoc, noteLine);
                 writeWU(microWUPath, microDoc);
                 // WU-1574: Update state store first, then regenerate backlog.md from state
-                const stateDir = path.join(worktreePath, '.beacon', 'state');
+                const stateDir = path.join(worktreePath, '.lumenflow', 'state');
                 const store = new WUStateStore(stateDir);
                 await store.load();
                 await store.unblock(id);
@@ -206,7 +206,7 @@ async function main() {
                         WU_PATHS.WU(id),
                         WU_PATHS.STATUS(),
                         WU_PATHS.BACKLOG(),
-                        '.beacon/state/wu-events.jsonl',
+                        '.lumenflow/state/wu-events.jsonl',
                     ],
                 };
             },