@lumenflow/cli 1.3.4 → 1.3.6

package/dist/mem-summarize.js

@@ -23,7 +23,7 @@ import fs from 'node:fs/promises';
 import path from 'node:path';
 import { summarizeWu } from '@lumenflow/memory/dist/mem-summarize-core.js';
 import { createWUParser } from '@lumenflow/core/dist/arg-parser.js';
-import { EXIT_CODES } from '@lumenflow/core/dist/wu-constants.js';
+import { EXIT_CODES, LUMENFLOW_PATHS } from '@lumenflow/core/dist/wu-constants.js';
 /**
  * Log prefix for mem:summarize output
  */
@@ -32,10 +32,6 @@ const LOG_PREFIX = '[mem:summarize]';
  * Tool name for audit logging
  */
 const TOOL_NAME = 'mem:summarize';
-/**
- * Audit log file path
- */
-const AUDIT_LOG_PATH = '.beacon/telemetry/tools.ndjson';
 /**
  * CLI argument options specific to mem:summarize
  */
@@ -74,7 +70,7 @@ const CLI_OPTIONS = {
  */
 async function writeAuditLog(baseDir, entry) {
     try {
-        const logPath = path.join(baseDir, AUDIT_LOG_PATH);
+        const logPath = path.join(baseDir, LUMENFLOW_PATHS.AUDIT_LOG);
         const logDir = path.dirname(logPath);
         // eslint-disable-next-line security/detect-non-literal-fs-filename -- CLI tool creates known directory
         await fs.mkdir(logDir, { recursive: true });

package/dist/mem-triage.js

@@ -23,7 +23,7 @@ import fs from 'node:fs/promises';
 import path from 'node:path';
 import { listOpenDiscoveries, promoteDiscovery, archiveDiscovery, } from '@lumenflow/memory/dist/mem-triage-core.js';
 import { createWUParser } from '@lumenflow/core/dist/arg-parser.js';
-import { EXIT_CODES } from '@lumenflow/core/dist/wu-constants.js';
+import { EXIT_CODES, LUMENFLOW_PATHS } from '@lumenflow/core/dist/wu-constants.js';
 /**
  * Log prefix for mem:triage output
  */
@@ -32,10 +32,6 @@ const LOG_PREFIX = '[mem:triage]';
  * Tool name for audit logging
  */
 const TOOL_NAME = 'mem:triage';
-/**
- * Audit log file path
- */
-const AUDIT_LOG_PATH = '.beacon/telemetry/tools.ndjson';
 /**
  * CLI argument options specific to mem:triage
  */
@@ -109,7 +105,7 @@ const CLI_OPTIONS = {
  */
 async function writeAuditLog(baseDir, entry) {
     try {
-        const logPath = path.join(baseDir, AUDIT_LOG_PATH);
+        const logPath = path.join(baseDir, LUMENFLOW_PATHS.AUDIT_LOG);
         const logDir = path.dirname(logPath);
         await fs.mkdir(logDir, { recursive: true });
         const line = `${JSON.stringify(entry)}\n`;

package/dist/metrics-snapshot.js

@@ -27,11 +27,11 @@ import { die } from '@lumenflow/core/dist/error-handler.js';
 /** Log prefix for console output */
 const LOG_PREFIX = '[metrics:snapshot]';
 /** Default snapshot output path */
-const DEFAULT_OUTPUT = '.beacon/snapshots/metrics-latest.json';
+const DEFAULT_OUTPUT = '.lumenflow/snapshots/metrics-latest.json';
 /** WU directory relative to repo root */
 const WU_DIR = 'docs/04-operations/tasks/wu';
 /** Skip-gates audit file path */
-const SKIP_GATES_PATH = '.beacon/skip-gates-audit.ndjson';
+const SKIP_GATES_PATH = '.lumenflow/skip-gates-audit.ndjson';
 /** Snapshot type options */
 const SNAPSHOT_TYPES = ['all', 'dora', 'lanes', 'flow'];
 /**

package/dist/orchestrate-init-status.js

@@ -11,16 +11,15 @@
 import { Command } from 'commander';
 import { existsSync, readdirSync } from 'node:fs';
 import { loadInitiativeWUs, calculateProgress, formatProgress } from '@lumenflow/initiatives';
-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';
 const LOG_PREFIX = '[orchestrate:init-status]';
-const STAMPS_DIR = '.beacon/stamps';
 function getCompletedWUs(wuIds) {
     const completed = new Set();
-    if (!existsSync(STAMPS_DIR)) {
+    if (!existsSync(LUMENFLOW_PATHS.STAMPS_DIR)) {
         return completed;
     }
-    const files = readdirSync(STAMPS_DIR);
+    const files = readdirSync(LUMENFLOW_PATHS.STAMPS_DIR);
     for (const wuId of wuIds) {
         if (files.includes(`${wuId}.done`)) {
             completed.add(wuId);

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,416 @@
+#!/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, unlinkSync, } from 'node:fs';
+import { readFile, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+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';
+/** Pattern to detect npm auth token in .npmrc files */
+const NPMRC_AUTH_TOKEN_PATTERN = /_authToken=/;
+/** Changeset pre.json filename */
+const CHANGESET_PRE_JSON = 'pre.json';
+/** Changeset directory name */
+const CHANGESET_DIR = '.changeset';
+/** Environment variable to force bypass hooks */
+const LUMENFLOW_FORCE_ENV = 'LUMENFLOW_FORCE';
+/** Environment variable to provide reason for force bypass */
+const LUMENFLOW_FORCE_REASON_ENV = 'LUMENFLOW_FORCE_REASON';
+/**
+ * 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
+ *
+ * Checks for auth in this order:
+ * 1. NPM_TOKEN environment variable
+ * 2. NODE_AUTH_TOKEN environment variable
+ * 3. Auth token in specified .npmrc file (or ~/.npmrc by default)
+ *
+ * @param npmrcPath - Optional path to .npmrc file (defaults to ~/.npmrc)
+ * @returns true if any auth method is found
+ */
+export function hasNpmAuth(npmrcPath) {
+    // Check environment variables first
+    if (process.env[NPM_TOKEN_ENV] || process.env[NODE_AUTH_TOKEN_ENV]) {
+        return true;
+    }
+    // Check .npmrc file
+    const npmrcFile = npmrcPath ?? join(homedir(), '.npmrc');
+    if (existsSync(npmrcFile)) {
+        try {
+            const content = readFileSync(npmrcFile, { encoding: FILE_SYSTEM.UTF8 });
+            // Look for authToken lines (e.g., //registry.npmjs.org/:_authToken=...)
+            return NPMRC_AUTH_TOKEN_PATTERN.test(content);
+        }
+        catch {
+            // If we can't read the file, assume no auth
+            return false;
+        }
+    }
+    return false;
+}
+/**
+ * Check if the project is in changeset pre-release mode
+ *
+ * Changeset pre mode is indicated by the presence of .changeset/pre.json
+ *
+ * @param baseDir - Base directory to check (defaults to cwd)
+ * @returns true if in pre-release mode
+ */
+export function isInChangesetPreMode(baseDir = process.cwd()) {
+    const preJsonPath = join(baseDir, CHANGESET_DIR, CHANGESET_PRE_JSON);
+    return existsSync(preJsonPath);
+}
+/**
+ * Exit changeset pre-release mode by removing .changeset/pre.json
+ *
+ * This is safe to call even if not in pre mode (no-op if file doesn't exist)
+ *
+ * @param baseDir - Base directory to operate in (defaults to cwd)
+ */
+export function exitChangesetPreMode(baseDir = process.cwd()) {
+    const preJsonPath = join(baseDir, CHANGESET_DIR, CHANGESET_PRE_JSON);
+    if (existsSync(preJsonPath)) {
+        unlinkSync(preJsonPath);
+    }
+}
+/**
+ * Push a git tag to origin, bypassing pre-push hooks via LUMENFLOW_FORCE
+ *
+ * This is necessary because the release script runs in a micro-worktree context
+ * and pre-push hooks may block tag pushes. The force is logged and requires
+ * a reason for audit purposes.
+ *
+ * @param git - SimpleGit instance
+ * @param tagName - Name of the tag to push
+ * @param reason - Reason for bypassing hooks (for audit log)
+ */
+export async function pushTagWithForce(git, tagName, reason = 'release: tag push from micro-worktree') {
+    // Set environment variables to bypass hooks
+    const originalForce = process.env[LUMENFLOW_FORCE_ENV];
+    const originalReason = process.env[LUMENFLOW_FORCE_REASON_ENV];
+    try {
+        process.env[LUMENFLOW_FORCE_ENV] = '1';
+        process.env[LUMENFLOW_FORCE_REASON_ENV] = reason;
+        await git.push(REMOTES.ORIGIN, tagName);
+    }
+    finally {
+        // Restore original environment
+        if (originalForce === undefined) {
+            delete process.env[LUMENFLOW_FORCE_ENV];
+        }
+        else {
+            process.env[LUMENFLOW_FORCE_ENV] = originalForce;
+        }
+        if (originalReason === undefined) {
+            delete process.env[LUMENFLOW_FORCE_REASON_ENV];
+        }
+        else {
+            process.env[LUMENFLOW_FORCE_REASON_ENV] = originalReason;
+        }
+    }
+}
+/**
+ * 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 }) => {
+                // Check and exit changeset pre mode if active
+                if (isInChangesetPreMode(worktreePath)) {
+                    console.log(`${LOG_PREFIX} Detected changeset pre-release mode, exiting...`);
+                    exitChangesetPreMode(worktreePath);
+                    console.log(`${LOG_PREFIX} ✅ Exited changeset pre mode`);
+                }
+                // 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));
+                // If we exited pre mode, include the deleted pre.json in files to commit
+                // (the deletion will be staged automatically by git add -A behavior)
+                const changesetPrePath = join(CHANGESET_DIR, CHANGESET_PRE_JSON);
+                const filesToCommit = [...relativePaths];
+                // Note: Deletion of pre.json is handled by git detecting the missing file
+                console.log(`${LOG_PREFIX} ✅ Versions updated to ${version}`);
+                return {
+                    commitMessage: buildCommitMessage(version),
+                    files: filesToCommit,
+                };
+            },
+        });
+        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 pushTagWithForce(git, tagName, 'release: pushing version tag');
+        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: '',