@lumenflow/cli 3.1.1 → 3.1.3

package/dist/state-doctor.js

@@ -30,20 +30,28 @@
 import fs from 'node:fs/promises';
 import path from 'node:path';
 import fg from 'fast-glob';
-import { parse as parseYaml } from 'yaml';
+import { parse as parseYaml, stringify as stringifyYaml } from 'yaml';
 import { diagnoseState, ISSUE_TYPES, ISSUE_SEVERITY, } from '@lumenflow/core/state-doctor-core';
 import { createWUParser } from '@lumenflow/core/arg-parser';
-import { EXIT_CODES, LUMENFLOW_PATHS } from '@lumenflow/core/wu-constants';
-import { getConfig, getResolvedPaths } from '@lumenflow/core/config';
+import { EXIT_CODES, LUMENFLOW_PATHS, WU_STATUS } from '@lumenflow/core/wu-constants';
+import { getConfig, getResolvedPaths, getConfigFilePresence, WORKSPACE_CONFIG_FILE_NAME, } from '@lumenflow/core/config';
 import { existsSync } from 'node:fs';
 import { createStamp } from '@lumenflow/core/stamp-utils';
+import { withMicroWorktree } from '@lumenflow/core/micro-worktree';
 import { createStateDoctorFixDeps } from './state-doctor-fix.js';
 import { runCLI } from './cli-entry-point.js';
 import { resolveStateDoctorStampIds } from './state-doctor-stamps.js';
+import { deriveInitiativeLifecycleStatus } from './initiative-status.js';
 /**
  * Log prefix for state:doctor output
  */
 const LOG_PREFIX = '[state:doctor]';
+const WORKSPACE_INIT_COMMAND = 'pnpm workspace-init --yes';
+const INITIATIVE_FILE_GLOB = 'INIT-*.yaml';
+const WU_FILE_GLOB = 'WU-*.yaml';
+const STATUS_RECONCILIATION_OPERATION_ID = 'reconcile-initiative-status';
+const STATUS_RECONCILIATION_COMMIT_MESSAGE = 'fix(state-doctor): reconcile stale initiative lifecycle statuses';
+const INITIATIVE_STATUS_RECONCILIATION_SUGGESTION = 'Run with --fix to reconcile initiative status';
 // WU-1539/WU-1548: Use centralized LUMENFLOW_PATHS.MEMORY_SIGNALS and LUMENFLOW_PATHS.WU_EVENTS
 /**
  * Tool name for audit logging
@@ -89,6 +97,161 @@ const CLI_OPTIONS = {
         description: 'Base directory (defaults to current directory)',
     },
 };
+function normalizeLifecycleStatus(value) {
+    return typeof value === 'string' ? value.trim().toLowerCase() : '';
+}
+function toInitiativePhases(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    return value
+        .filter((phase) => phase != null && typeof phase === 'object')
+        .flatMap((phase) => {
+        if (typeof phase.id !== 'number') {
+            return [];
+        }
+        const status = typeof phase.status === 'string' ? phase.status : undefined;
+        return [{ id: phase.id, status }];
+    });
+}
+function createInitiativeStatusMismatchIssue(mismatch) {
+    return {
+        type: ISSUE_TYPES.STATUS_MISMATCH,
+        severity: ISSUE_SEVERITY.WARNING,
+        wuId: mismatch.initiativeId,
+        description: `Initiative ${mismatch.initiativeId} metadata status is '${mismatch.currentStatus}' but linked WUs derive '${mismatch.derivedStatus}'`,
+        suggestion: INITIATIVE_STATUS_RECONCILIATION_SUGGESTION,
+        canAutoFix: true,
+        statusMismatch: {
+            yamlStatus: mismatch.currentStatus,
+            derivedStatus: mismatch.derivedStatus,
+        },
+    };
+}
+export async function collectInitiativeLifecycleStatusMismatches(baseDir) {
+    const config = getConfig({ projectRoot: baseDir, strictWorkspace: true });
+    const initiativesDir = path.join(baseDir, config.directories.initiativesDir);
+    const wuDir = path.join(baseDir, config.directories.wuDir);
+    const [initiativeFiles, wuFiles] = await Promise.all([
+        fg(INITIATIVE_FILE_GLOB, { cwd: initiativesDir }),
+        fg(WU_FILE_GLOB, { cwd: wuDir }),
+    ]);
+    if (initiativeFiles.length === 0) {
+        return [];
+    }
+    const initiatives = [];
+    const initiativeIdByReference = new Map();
+    const progressByInitiativeId = new Map();
+    for (const file of initiativeFiles) {
+        const relativePath = path.join(config.directories.initiativesDir, file);
+        const fullPath = path.join(initiativesDir, file);
+        try {
+            const content = await fs.readFile(fullPath, 'utf-8');
+            const doc = parseYaml(content);
+            const initiativeId = typeof doc.id === 'string' && doc.id.length > 0 ? doc.id : '';
+            if (!initiativeId) {
+                continue;
+            }
+            const slug = typeof doc.slug === 'string' ? doc.slug : '';
+            const status = normalizeLifecycleStatus(doc.status);
+            const phases = toInitiativePhases(doc.phases);
+            initiatives.push({
+                id: initiativeId,
+                slug,
+                status,
+                phases,
+                relativePath,
+            });
+            initiativeIdByReference.set(initiativeId, initiativeId);
+            if (slug.length > 0) {
+                initiativeIdByReference.set(slug, initiativeId);
+            }
+            progressByInitiativeId.set(initiativeId, { done: 0, total: 0 });
+        }
+        catch {
+            // Skip malformed initiative YAML files during diagnosis.
+        }
+    }
+    for (const file of wuFiles) {
+        const fullPath = path.join(wuDir, file);
+        try {
+            const content = await fs.readFile(fullPath, 'utf-8');
+            const doc = parseYaml(content);
+            const initiativeRef = typeof doc.initiative === 'string' ? doc.initiative : '';
+            if (!initiativeRef) {
+                continue;
+            }
+            const initiativeId = initiativeIdByReference.get(initiativeRef);
+            if (!initiativeId) {
+                continue;
+            }
+            const current = progressByInitiativeId.get(initiativeId) || { done: 0, total: 0 };
+            current.total += 1;
+            if (normalizeLifecycleStatus(doc.status) === WU_STATUS.DONE) {
+                current.done += 1;
+            }
+            progressByInitiativeId.set(initiativeId, current);
+        }
+        catch {
+            // Skip malformed WU YAML files during diagnosis.
+        }
+    }
+    const mismatches = [];
+    for (const initiative of initiatives) {
+        if (![WU_STATUS.IN_PROGRESS, WU_STATUS.DONE].includes(initiative.status)) {
+            continue;
+        }
+        const progress = progressByInitiativeId.get(initiative.id);
+        const derivedStatus = deriveInitiativeLifecycleStatus(initiative.status, initiative.phases, progress);
+        if (derivedStatus !== initiative.status) {
+            mismatches.push({
+                initiativeId: initiative.id,
+                relativePath: initiative.relativePath,
+                currentStatus: initiative.status,
+                derivedStatus,
+            });
+        }
+    }
+    return mismatches;
+}
+export async function applyInitiativeLifecycleStatusFixes(baseDir, mismatches) {
+    if (mismatches.length === 0) {
+        return;
+    }
+    const uniqueMismatches = Array.from(new Map(mismatches.map((mismatch) => [mismatch.relativePath, mismatch])).values());
+    await withMicroWorktree({
+        operation: TOOL_NAME,
+        id: STATUS_RECONCILIATION_OPERATION_ID,
+        logPrefix: LOG_PREFIX,
+        pushOnly: true,
+        execute: async ({ worktreePath }) => {
+            const modifiedFiles = [];
+            for (const mismatch of uniqueMismatches) {
+                const initiativePath = path.join(worktreePath, mismatch.relativePath);
+                const content = await fs.readFile(initiativePath, 'utf-8');
+                const doc = parseYaml(content);
+                doc.status = mismatch.derivedStatus;
+                await fs.writeFile(initiativePath, stringifyYaml(doc), 'utf-8');
+                modifiedFiles.push(mismatch.relativePath);
+            }
+            return {
+                commitMessage: STATUS_RECONCILIATION_COMMIT_MESSAGE,
+                files: modifiedFiles,
+            };
+        },
+    });
+}
+function appendInitiativeStatusMismatchIssues(result, mismatches) {
+    if (mismatches.length === 0) {
+        return [];
+    }
+    const issues = mismatches.map((mismatch) => createInitiativeStatusMismatchIssue(mismatch));
+    result.issues.push(...issues);
+    result.summary.statusMismatches += issues.length;
+    result.summary.totalIssues += issues.length;
+    result.healthy = false;
+    return issues;
+}
 /**
  * Write audit log entry for tool execution
  */
@@ -126,7 +289,7 @@ function parseArguments() {
  * Create dependencies for state doctor from filesystem
  */
 async function createDeps(baseDir) {
-    const config = getConfig({ projectRoot: baseDir });
+    const config = getConfig({ projectRoot: baseDir, strictWorkspace: true });
     return {
         /**
          * List all WU YAML files
@@ -289,6 +452,19 @@ async function createDeps(baseDir) {
         },
     };
 }
+/**
+ * Enforce canonical workspace config before running state-doctor checks.
+ *
+ * @param baseDir - Target repository directory
+ * @throws Error when workspace.yaml is missing
+ */
+function assertCanonicalWorkspace(baseDir) {
+    const { workspaceConfigExists } = getConfigFilePresence(baseDir);
+    if (workspaceConfigExists) {
+        return;
+    }
+    throw new Error(`${LOG_PREFIX} Missing ${WORKSPACE_CONFIG_FILE_NAME}. Run \`${WORKSPACE_INIT_COMMAND}\`.`);
+}
 /**
  * Get emoji for issue severity
  */
@@ -433,7 +609,7 @@ function buildAuditOutput(result) {
 function warnMissingPaths(baseDir, quiet) {
     if (quiet)
         return;
-    const paths = getResolvedPaths({ projectRoot: baseDir });
+    const paths = getResolvedPaths({ projectRoot: baseDir, strictWorkspace: true });
     const missing = [];
     if (!existsSync(paths.wuDir)) {
         missing.push(`WU directory: ${paths.wuDir}`);
@@ -449,22 +625,24 @@ function warnMissingPaths(baseDir, quiet) {
         for (const p of missing) {
             console.warn(`  - ${p}`);
         }
-        console.warn('  Tip: Run `pnpm setup` or check .lumenflow.config.yaml');
+        console.warn(`  Tip: Run \`${WORKSPACE_INIT_COMMAND}\` and verify ${WORKSPACE_CONFIG_FILE_NAME}`);
     }
 }
 /**
  * Main CLI entry point
  */
-async function main() {
+export async function main() {
     const args = parseArguments();
     const baseDir = args.baseDir || process.cwd();
     const startedAt = new Date().toISOString();
     const startTime = Date.now();
-    // WU-1301: Warn about missing configured paths
-    warnMissingPaths(baseDir, args.quiet ?? false);
     let result = null;
     let error = null;
     try {
+        // Hard-cut enforcement: require canonical workspace configuration.
+        assertCanonicalWorkspace(baseDir);
+        // WU-1301: Warn about missing configured paths
+        warnMissingPaths(baseDir, args.quiet ?? false);
         // Create base deps for read operations
         const baseDeps = await createDeps(baseDir);
         // WU-1230: When --fix is enabled, use micro-worktree isolation for all
@@ -480,6 +658,32 @@ async function main() {
             fix: args.fix,
             dryRun: args.dryRun,
         });
+        const initiativeMismatches = await collectInitiativeLifecycleStatusMismatches(baseDir);
+        const initiativeIssues = appendInitiativeStatusMismatchIssues(result, initiativeMismatches);
+        if (initiativeIssues.length > 0) {
+            if (args.fix && args.dryRun) {
+                result.dryRun = true;
+                const existingWouldFix = result.wouldFix || [];
+                result.wouldFix = [...existingWouldFix, ...initiativeIssues];
+            }
+            else if (args.fix) {
+                try {
+                    await applyInitiativeLifecycleStatusFixes(baseDir, initiativeMismatches);
+                    result.fixed.push(...initiativeIssues);
+                }
+                catch (fixErr) {
+                    const message = fixErr instanceof Error ? fixErr.message : String(fixErr);
+                    for (const issue of initiativeIssues) {
+                        result.fixErrors.push({
+                            type: issue.type,
+                            wuId: issue.wuId,
+                            signalId: issue.signalId,
+                            error: message,
+                        });
+                    }
+                }
+            }
+        }
     }
     catch (err) {
         error = err.message;

package/dist/task-claim.js

@@ -57,7 +57,7 @@ const TASK_CLAIM_OPTIONS = {
     domainData: {
         name: 'domainData',
         flags: '--domain-data <json>',
-        description: 'Optional JSON object payload for domain-specific metadata',
+        description: 'Optional JSON object payload for task-scoped metadata',
     },
     workspaceRoot: {
         name: 'workspaceRoot',

package/dist/validate.js

@@ -30,7 +30,7 @@ export { validateSingleWU, validateAllWUs };
 /**
  * Main CLI entry point
  */
-async function main() {
+export async function main() {
     const args = process.argv.slice(2);
     // Parse arguments
     let wuId;

package/dist/workspace-init.js

@@ -17,11 +17,41 @@
 import * as readline from 'node:readline';
 import * as path from 'node:path';
 import YAML from 'yaml';
-import { createWUParser } from '@lumenflow/core';
 import { createFile } from './init-scaffolding.js';
 import { runCLI } from './cli-entry-point.js';
 export const LOG_PREFIX = '[workspace:init]';
-const WORKSPACE_FILENAME = 'workspace.yaml';
+export const WORKSPACE_FILENAME = 'workspace.yaml';
+export const DEFAULT_WORKSPACE_ID = 'default';
+export const DEFAULT_WORKSPACE_NAME = 'My Project';
+export const DEFAULT_PROJECT_NAME = 'my-project';
+export const DEFAULT_LANE_TITLE = 'Default';
+export const DEFAULT_NAMESPACE = DEFAULT_WORKSPACE_ID;
+export const CANONICAL_BOOTSTRAP_COMMAND = 'npx lumenflow';
+const LEGACY_WORKSPACE_INIT_ENTRYPOINT = 'workspace-init';
+const LEGACY_ENTRYPOINT_MARKER = 'legacy';
+const LEGACY_ENTRYPOINT_MESSAGE_PREFIX = `${LOG_PREFIX} ${LEGACY_ENTRYPOINT_MARKER} entrypoint`;
+export const DEFAULT_DENY_OVERLAYS = ['~/.ssh', '~/.aws', '~/.gnupg', '.env'];
+export const DEFAULT_DENY_OVERLAYS_PROMPT = DEFAULT_DENY_OVERLAYS.join(', ');
+export const SANDBOX_NETWORK_PROFILE = {
+    OFF: 'off',
+    FULL: 'full',
+};
+export const DEFAULT_SANDBOX_NETWORK_PROFILE = SANDBOX_NETWORK_PROFILE.OFF;
+export const CLOUD_CONNECT_RESPONSE = {
+    YES: 'yes',
+    NO: 'no',
+    SHORT_YES: 'y',
+    BOOLEAN_TRUE: 'true',
+};
+const CLOUD_CONNECT_TRUTHY = new Set([
+    CLOUD_CONNECT_RESPONSE.YES,
+    CLOUD_CONNECT_RESPONSE.SHORT_YES,
+    CLOUD_CONNECT_RESPONSE.BOOLEAN_TRUE,
+]);
+const EMPTY_SOFTWARE_DELIVERY_CONFIG = Object.freeze({});
+function createEmptySoftwareDeliveryConfig() {
+    return { ...EMPTY_SOFTWARE_DELIVERY_CONFIG };
+}
 /**
  * AC1: 5 interactive questions for workspace configuration
  */
@@ -29,29 +59,33 @@ export const WORKSPACE_QUESTIONS = [
     {
         name: 'projectName',
         prompt: 'Project name',
-        defaultValue: 'my-project',
+        defaultValue: DEFAULT_PROJECT_NAME,
     },
     {
         name: 'lanes',
         prompt: 'Work lanes (comma-separated, e.g., Backend, Frontend, DevOps)',
-        defaultValue: 'Default',
+        defaultValue: DEFAULT_LANE_TITLE,
     },
     {
         name: 'sandboxProfile',
         prompt: 'Sandbox network profile (off | full)',
-        defaultValue: 'off',
+        defaultValue: DEFAULT_SANDBOX_NETWORK_PROFILE,
     },
     {
         name: 'deniedPaths',
         prompt: 'Denied paths (comma-separated, e.g., ~/.ssh, ~/.aws, .env)',
-        defaultValue: '~/.ssh, ~/.aws, ~/.gnupg, .env',
+        defaultValue: DEFAULT_DENY_OVERLAYS_PROMPT,
     },
     {
         name: 'cloudConnect',
         prompt: 'Enable cloud agent support? (yes | no)',
-        defaultValue: 'no',
+        defaultValue: CLOUD_CONNECT_RESPONSE.NO,
     },
 ];
+export function buildLegacyWorkspaceInitGuidance(entrypoint = LEGACY_WORKSPACE_INIT_ENTRYPOINT) {
+    return (`${LEGACY_ENTRYPOINT_MESSAGE_PREFIX} "${entrypoint}" is retired. ` +
+        `Use "${CANONICAL_BOOTSTRAP_COMMAND}" for bootstrap-all onboarding.`);
+}
 /**
  * Parse raw string answers from interactive prompts into typed config inputs.
  */
@@ -66,10 +100,10 @@ export function parseAnswers(answers) {
             .map((p) => p.trim())
             .filter(Boolean)
         : [];
-    const cloudConnect = answers.cloudConnect.toLowerCase() === 'yes' ||
-        answers.cloudConnect.toLowerCase() === 'y' ||
-        answers.cloudConnect.toLowerCase() === 'true';
-    const sandboxProfile = answers.sandboxProfile === 'full' ? 'full' : 'off';
+    const cloudConnect = CLOUD_CONNECT_TRUTHY.has(answers.cloudConnect.toLowerCase());
+    const sandboxProfile = answers.sandboxProfile === SANDBOX_NETWORK_PROFILE.FULL
+        ? SANDBOX_NETWORK_PROFILE.FULL
+        : SANDBOX_NETWORK_PROFILE.OFF;
     return {
         projectName: answers.projectName,
         lanes,
@@ -94,24 +128,25 @@ function toKebabCase(title) {
  */
 export function getDefaultWorkspaceConfig() {
     return {
-        id: 'default',
-        name: 'My Project',
+        id: DEFAULT_WORKSPACE_ID,
+        name: DEFAULT_WORKSPACE_NAME,
         packs: [],
         lanes: [
             {
-                id: 'default',
-                title: 'Default',
+                id: DEFAULT_WORKSPACE_ID,
+                title: DEFAULT_LANE_TITLE,
                 allowed_scopes: [],
             },
         ],
         policies: {},
         security: {
             allowed_scopes: [],
-            network_default: 'off',
-            deny_overlays: ['~/.ssh', '~/.aws', '~/.gnupg', '.env'],
+            network_default: DEFAULT_SANDBOX_NETWORK_PROFILE,
+            deny_overlays: [...DEFAULT_DENY_OVERLAYS],
         },
-        memory_namespace: 'default',
-        event_namespace: 'default',
+        software_delivery: createEmptySoftwareDeliveryConfig(),
+        memory_namespace: DEFAULT_NAMESPACE,
+        event_namespace: DEFAULT_NAMESPACE,
     };
 }
 /**
@@ -134,6 +169,7 @@ export function buildWorkspaceConfig(input) {
             network_default: input.sandboxProfile,
             deny_overlays: input.deniedPaths,
         },
+        software_delivery: createEmptySoftwareDeliveryConfig(),
         memory_namespace: toKebabCase(input.projectName),
         event_namespace: toKebabCase(input.projectName),
     };
@@ -172,7 +208,7 @@ export function generateWorkspaceYaml(config) {
     lines.push('security:');
     lines.push('  # Workspace-level scope restrictions');
     lines.push(`  allowed_scopes: ${YAML.stringify(config.security.allowed_scopes).trim()}`);
-    lines.push('  # Network access default for sandbox (off = no network, full = unrestricted)');
+    lines.push(`  # Network access default for sandbox (${SANDBOX_NETWORK_PROFILE.OFF} = no network, ${SANDBOX_NETWORK_PROFILE.FULL} = unrestricted)`);
     lines.push(`  network_default: ${config.security.network_default}`);
     lines.push('  # Paths denied to agent sandbox via deny overlays');
     lines.push('  deny_overlays:');
@@ -186,6 +222,9 @@ export function generateWorkspaceYaml(config) {
         }
     }
     lines.push('');
+    lines.push('# Software delivery config extensions (required workspace v2 block)');
+    lines.push(`software_delivery: ${YAML.stringify(config.software_delivery).trim()}`);
+    lines.push('');
     lines.push('# Memory namespace for session tracking and context recovery');
     lines.push(`memory_namespace: ${YAML.stringify(config.memory_namespace).trim()}`);
     lines.push('');
@@ -270,51 +309,12 @@ export async function runInteractive(targetDir, force = false) {
     }
 }
 // --- CLI entry point ---
-const WORKSPACE_INIT_OPTIONS = {
-    yes: {
-        name: 'yes',
-        flags: '--yes, -y',
-        description: 'Accept all defaults non-interactively',
-    },
-    output: {
-        name: 'output',
-        flags: '--output, -o <dir>',
-        description: 'Output directory (default: current directory)',
-    },
-    force: {
-        name: 'force',
-        flags: '--force, -f',
-        description: 'Overwrite existing workspace.yaml',
-    },
-};
 /**
  * CLI main entry point for workspace:init
  */
 export async function main() {
-    const opts = createWUParser({
-        name: 'workspace-init',
-        description: 'Initialize a LumenFlow workspace configuration (workspace.yaml)',
-        options: [
-            WORKSPACE_INIT_OPTIONS.yes,
-            WORKSPACE_INIT_OPTIONS.output,
-            WORKSPACE_INIT_OPTIONS.force,
-        ],
-    });
-    const targetDir = opts.output ?? process.cwd();
-    const force = Boolean(opts.force);
-    const useDefaults = Boolean(opts.yes);
-    if (useDefaults) {
-        const result = await runNonInteractive(targetDir, force);
-        if (result.created.length > 0) {
-            console.log(`${LOG_PREFIX} Created ${WORKSPACE_FILENAME} with default settings`);
-        }
-        else if (result.skipped.length > 0) {
-            console.log(`${LOG_PREFIX} ${WORKSPACE_FILENAME} already exists. Use --force to overwrite.`);
-        }
-    }
-    else {
-        await runInteractive(targetDir, force);
-    }
+    const invokedEntryPoint = path.basename(process.argv[1] ?? LEGACY_WORKSPACE_INIT_ENTRYPOINT, '.js');
+    console.warn(buildLegacyWorkspaceInitGuidance(invokedEntryPoint));
 }
 // Run if executed directly
 if (import.meta.main) {

package/dist/wu-block.js

@@ -178,7 +178,7 @@ async function handleWorktreeRemoval(args, doc) {
         console.warn(`${LOG_PREFIX.BLOCK} No worktree path specified; skipping removal`);
     }
 }
-async function main() {
+export async function main() {
     const args = createWUParser({
         name: 'wu-block',
         description: 'Block a work unit and move it from in-progress to blocked status',

package/dist/wu-brief.js

@@ -26,7 +26,7 @@ const BRIEF_LOG_PREFIX = '[wu:brief]';
 /**
  * Main entry point for wu:brief (canonical command)
  */
-async function main() {
+export async function main() {
     await runBriefLogic({
         parserConfig: {
             name: 'wu-brief',

package/dist/wu-claim.js

@@ -127,7 +127,7 @@ export async function maybeLaunchClaimSandboxSession(input, deps = {}) {
 // Main orchestrator
 // ============================================================================
 // eslint-disable-next-line sonarjs/cognitive-complexity -- main() orchestrates multi-step claim workflow
-async function main() {
+export async function main() {
     const args = createWUParser({
         name: 'wu-claim',
         description: 'Claim a work unit by creating a worktree/branch and updating status',

package/dist/wu-cleanup.js

@@ -180,7 +180,7 @@ function hasStampFile(wuId) {
     const stampPath = path.join(process.cwd(), WU_PATHS.STAMP(wuId));
     return existsSync(stampPath);
 }
-async function main() {
+export async function main() {
     const args = createWUParser({
         name: 'wu-cleanup',
         description: 'Clean up worktree and branch after PR merge (PR-based completion workflow)',

package/dist/wu-create.js

@@ -124,7 +124,7 @@ export function warnIfBetterLaneExists(providedLane, codePathsArray, title, desc
  * Resolve lane lifecycle classification for wu:create without mutating config.
  *
  * WU-1751: wu:create must not persist lifecycle migration side effects to
- * .lumenflow.config.yaml on main.
+ * workspace.yaml on main.
  */
 export function resolveLaneLifecycleForWuCreate(projectRoot) {
     return ensureLaneLifecycleForProject(projectRoot, { persist: false });
@@ -182,7 +182,7 @@ async function getDefaultAssignedTo() {
         return '';
     }
 }
-async function main() {
+export async function main() {
     const args = createWUParser({
         name: 'wu-create',
         description: 'Create a new Work Unit with micro-worktree isolation (race-safe)',
@@ -267,7 +267,7 @@ async function main() {
             `  - Single colon with EXACTLY one space after (e.g., "Parent: Subdomain")\n` +
             `  - No spaces before colon\n` +
             `  - No multiple colons\n\n` +
-            `See .lumenflow.config.yaml for valid parent lanes.`);
+            `See workspace.yaml software_delivery.lanes.definitions for valid parent lanes.`);
     }
     // WU-2330: Warn if a more specific sub-lane matches code_paths or description
     warnIfBetterLaneExists(args.lane, args.codePaths, args.title, args.description);

package/dist/wu-delegate.js

@@ -8,7 +8,7 @@
  */
 import { runBriefLogic } from './wu-spawn.js';
 import { runCLI } from './cli-entry-point.js';
-async function main() {
+export async function main() {
     await runBriefLogic({
         mode: 'delegate',
         parserConfig: {

package/dist/wu-deps.js

@@ -18,7 +18,7 @@ import { buildDependencyGraphAsync, renderASCII, renderMermaid, validateGraph, }
 import { OUTPUT_FORMATS } from '@lumenflow/initiatives/constants';
 import { PATTERNS } from '@lumenflow/core/wu-constants';
 import { getConfig } from '@lumenflow/core/config';
-async function main() {
+export async function main() {
     const args = createWUParser({
         name: 'wu-deps',
         description: 'Visualize WU dependency graph',