@lumenflow/cli 3.1.2 → 3.1.3

package/dist/orchestrate-monitor.js

@@ -25,8 +25,10 @@ import { Command } from 'commander';
 import { existsSync, readdirSync, readFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { EXIT_CODES, LUMENFLOW_PATHS, DelegationRegistryStore, analyzeDelegations, detectStuckDelegations, checkZombieLocks, generateSuggestions, formatMonitorOutput, formatRecoveryResults, runRecovery, processDelegationFailureSignals, formatSignalHandlerOutput, DEFAULT_THRESHOLD_MINUTES, calculateBackoff, } from '@lumenflow/core';
+import { ProcessExitError } from '@lumenflow/core/error-handler';
 import chalk from 'chalk';
 import ms, {} from 'ms';
+import { runCLI } from './cli-entry-point.js';
 // ============================================================================
 // WU-1242: Watch Mode Constants
 // ============================================================================
@@ -187,8 +189,9 @@ async function runDelegationMonitoring(opts) {
     const baseDir = process.cwd();
     const thresholdMinutes = parseInt(opts.threshold, 10);
     if (isNaN(thresholdMinutes) || thresholdMinutes <= 0) {
-        console.error(chalk.red(`${LOG_PREFIX} Invalid threshold: ${opts.threshold}`));
-        process.exit(EXIT_CODES.FAILURE);
+        const message = `${LOG_PREFIX} Invalid threshold: ${opts.threshold}`;
+        console.error(chalk.red(message));
+        throw new ProcessExitError(message, EXIT_CODES.FAILURE);
     }
     console.log(chalk.cyan(`${LOG_PREFIX} Analyzing delegation health...`));
     console.log(chalk.gray(`  Threshold: ${thresholdMinutes} minutes`));
@@ -209,7 +212,7 @@ async function runDelegationMonitoring(opts) {
         console.log(formatSignalHandlerOutput(signalResult));
     }
     if (result.stuckDelegations.length > 0 || result.zombieLocks.length > 0) {
-        process.exit(EXIT_CODES.ERROR);
+        throw new ProcessExitError(`${LOG_PREFIX} Delegation monitor detected stuck delegations or zombie locks.`, EXIT_CODES.ERROR);
     }
 }
 /**
@@ -378,8 +381,9 @@ async function runWatchMode(opts) {
     const baseDir = process.cwd();
     const thresholdMinutes = parseInt(opts.threshold, 10);
     if (isNaN(thresholdMinutes) || thresholdMinutes <= 0) {
-        console.error(chalk.red(`${LOG_PREFIX} Invalid threshold: ${opts.threshold}`));
-        process.exit(EXIT_CODES.FAILURE);
+        const message = `${LOG_PREFIX} Invalid threshold: ${opts.threshold}`;
+        console.error(chalk.red(message));
+        throw new ProcessExitError(message, EXIT_CODES.FAILURE);
     }
     const watchOptions = parseWatchOptions(opts);
     console.log(chalk.cyan(`${LOG_PREFIX} Starting continuous patrol mode...`));
@@ -403,7 +407,7 @@ async function runWatchMode(opts) {
     // Handle graceful shutdown
     const shutdown = () => {
         runner.stop();
-        process.exit(0);
+        process.exitCode = EXIT_CODES.SUCCESS;
     };
     process.on('SIGINT', shutdown);
     process.on('SIGTERM', shutdown);
@@ -438,10 +442,18 @@ const program = new Command()
         await runDelegationMonitoring(opts);
     }
     catch (err) {
+        if (err instanceof ProcessExitError) {
+            throw err;
+        }
         const message = err instanceof Error ? err.message : String(err);
         console.error(chalk.red(`${LOG_PREFIX} Error: ${message}`));
-        process.exit(EXIT_CODES.ERROR);
+        throw new ProcessExitError(message, EXIT_CODES.ERROR);
     }
 });
-program.parse();
+export async function main() {
+    await program.parseAsync(process.argv);
+}
+if (import.meta.main) {
+    void runCLI(main);
+}
 //# sourceMappingURL=orchestrate-monitor.js.map

package/dist/pack-scaffold.js

@@ -112,7 +112,7 @@ LumenFlow domain pack - version ${version}
 
 ## Overview
 
-This pack provides domain-specific tools and policies for the LumenFlow kernel.
+This pack provides pack-specific tools and policies for the LumenFlow kernel.
 
 ## Structure
 

package/dist/plan-create.js

@@ -139,7 +139,7 @@ export function getCommitMessage(id, title) {
     const idLower = id.toLowerCase();
     return `docs: create plan for ${idLower} - ${title}`;
 }
-async function main() {
+export async function main() {
     const args = createWUParser({
         name: 'plan-create',
         description: 'Create a new plan file in repo plansDir',
@@ -195,6 +195,4 @@ import { runCLI } from './cli-entry-point.js';
 if (import.meta.main) {
     void runCLI(main);
 }
-// Export for testing
-export { main };
 //# sourceMappingURL=plan-create.js.map

package/dist/plan-edit.js

@@ -164,7 +164,7 @@ export function getCommitMessage(id, section) {
     const idLower = id.toLowerCase();
     return `docs: update ${section} section in ${idLower} plan`;
 }
-async function main() {
+export async function main() {
     const SECTION_OPTION = {
         name: 'section',
         flags: '--section <name>',
@@ -257,6 +257,4 @@ import { runCLI } from './cli-entry-point.js';
 if (import.meta.main) {
     void runCLI(main);
 }
-// Export for testing
-export { main };
 //# sourceMappingURL=plan-edit.js.map

package/dist/plan-link.js

@@ -200,7 +200,7 @@ export function getCommitMessage(id, planUri) {
     const filename = planUri.replace(PLAN_URI_SCHEME, '');
     return `docs: link plan ${filename} to ${idLower}`;
 }
-async function main() {
+export async function main() {
     const PLAN_OPTION = {
         name: 'plan',
         flags: '--plan <uri>',
@@ -269,6 +269,4 @@ import { runCLI } from './cli-entry-point.js';
 if (import.meta.main) {
     void runCLI(main);
 }
-// Export for testing
-export { main };
 //# sourceMappingURL=plan-link.js.map

package/dist/plan-promote.js

@@ -154,7 +154,7 @@ export function getCommitMessage(id) {
     const idLower = id.toLowerCase();
     return `docs: promote ${idLower} plan to approved`;
 }
-async function main() {
+export async function main() {
     const FORCE_OPTION = {
         name: 'force',
         flags: '-f, --force',
@@ -227,6 +227,4 @@ import { runCLI } from './cli-entry-point.js';
 if (import.meta.main) {
     void runCLI(main);
 }
-// Export for testing
-export { main };
 //# sourceMappingURL=plan-promote.js.map

package/dist/release.js

@@ -317,7 +317,7 @@ export async function pushTagWithForce(git, tagName, reason = 'release: tag push
  * Main release function
  * WU-1085: Renamed --version to --release-version to avoid conflict with CLI --version flag
  */
-async function main() {
+export async function main() {
     const program = new Command()
         .name('lumenflow-release')
         .description('Release @lumenflow/* packages to npm with version bump, tag, and publish')
@@ -468,8 +468,6 @@ async function main() {
         console.log(`  - Verify packages: npm view @lumenflow/cli version`);
     }
 }
-// Export for testing
-export { main };
 // Guard main() for testability
 if (import.meta.main) {
     void runCLI(main);

package/dist/signal-cleanup.js

@@ -29,6 +29,7 @@ import { cleanupSignals } from '@lumenflow/memory/signal-cleanup-core';
 import { createWUParser } from '@lumenflow/core/arg-parser';
 import { EXIT_CODES, LUMENFLOW_PATHS, PROTECTED_WU_STATUSES } from '@lumenflow/core/wu-constants';
 import { getConfig } from '@lumenflow/core/config';
+import { formatBytes } from './constants.js';
 import { runCLI } from './cli-entry-point.js';
 /**
  * Log prefix for signal:cleanup output
@@ -38,10 +39,7 @@ const LOG_PREFIX = '[signal:cleanup]';
  * Tool name for audit logging
  */
 const TOOL_NAME = 'signal:cleanup';
-/**
- * Bytes per KB for formatting
- */
-const BYTES_PER_KB = 1024;
+// WU-2044: BYTES_PER_KB imported from ./constants.js
 /**
  * CLI argument options specific to signal:cleanup
  */
@@ -100,19 +98,7 @@ async function writeAuditLog(baseDir, entry) {
         // Audit logging is non-fatal - silently ignore errors
     }
 }
-/**
- * Format bytes as human-readable string
- *
- * @param bytes - Number of bytes
- * @returns Formatted string (e.g., "1.5 KB")
- */
-function formatBytes(bytes) {
-    if (bytes < BYTES_PER_KB) {
-        return `${bytes} B`;
-    }
-    const kb = (bytes / BYTES_PER_KB).toFixed(1);
-    return `${kb} KB`;
-}
+// WU-2044: formatBytes imported from ./constants.js
 /**
  * Format compaction ratio as percentage
  *
@@ -227,7 +213,7 @@ function printResult(result, quiet) {
 /**
  * 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();

package/dist/state-bootstrap.js

@@ -18,7 +18,8 @@ import path from 'node:path';
 import { parse as parseYaml } from 'yaml';
 import { readFileSync } from 'node:fs';
 import { WU_PATHS } from '@lumenflow/core/wu-paths';
-import { CLI_FLAGS, EXIT_CODES, EMOJI, STRING_LITERALS } from '@lumenflow/core/wu-constants';
+import { CLI_FLAGS, EXIT_CODES, EMOJI, STRING_LITERALS, WU_STATUS, } from '@lumenflow/core/wu-constants';
+import { WU_EVENT_TYPE } from '@lumenflow/core/wu-state-schema';
 /** Log prefix for consistent output */
 const LOG_PREFIX = '[state-bootstrap]';
 /**
@@ -99,36 +100,38 @@ function toTimestamp(dateStr, fallback) {
 export function inferEventsFromWu(wu) {
     const events = [];
     // Ready WUs have no events (not yet in the lifecycle)
-    if (wu.status === 'ready' || wu.status === 'backlog' || wu.status === 'todo') {
+    if (wu.status === WU_STATUS.READY ||
+        wu.status === WU_STATUS.BACKLOG ||
+        wu.status === WU_STATUS.TODO) {
         return events;
     }
     // All other states start with a claim event
     const claimTimestamp = toTimestamp(wu.claimed_at, wu.created);
     events.push({
-        type: 'claim',
+        type: WU_EVENT_TYPE.CLAIM,
         wuId: wu.id,
         lane: wu.lane,
         title: wu.title,
         timestamp: claimTimestamp,
     });
     // Handle completed/done status
-    if (wu.status === 'done' || wu.status === 'completed') {
+    if (wu.status === WU_STATUS.DONE || wu.status === WU_STATUS.COMPLETED) {
         const completeTimestamp = toTimestamp(wu.completed_at, wu.created);
         events.push({
-            type: 'complete',
+            type: WU_EVENT_TYPE.COMPLETE,
             wuId: wu.id,
             timestamp: completeTimestamp,
         });
         return events;
     }
     // Handle blocked status
-    if (wu.status === 'blocked') {
+    if (wu.status === WU_STATUS.BLOCKED) {
         // Block event timestamp should be after claim
         // We don't have exact block time, so use claim time + 1 second
         const claimDate = new Date(claimTimestamp);
         claimDate.setSeconds(claimDate.getSeconds() + 1);
         events.push({
-            type: 'block',
+            type: WU_EVENT_TYPE.BLOCK,
             wuId: wu.id,
             timestamp: claimDate.toISOString(),
             reason: 'Bootstrapped from WU YAML (original reason unknown)',
@@ -266,7 +269,7 @@ Supported WU statuses:
 /**
  * Main function
  */
-async function main() {
+export async function main() {
     const args = parseStateBootstrapArgs(process.argv);
     if (args.help) {
         printHelp();

package/dist/state-cleanup.js

@@ -12,7 +12,7 @@
  * Cleanup order: signals -> memory -> events (dependency order)
  *
  * Features:
- * - Respects config from .lumenflow.config.yaml
+ * - Respects config from workspace.yaml
  * - Supports --dry-run for preview
  * - Supports --signals-only, --memory-only, --events-only for selective cleanup
  * - Non-fatal: warns on errors but continues with other cleanups
@@ -40,6 +40,7 @@ import { EXIT_CODES, LUMENFLOW_PATHS, PROTECTED_WU_STATUSES } from '@lumenflow/c
 import { getConfig } from '@lumenflow/core/config';
 import fg from 'fast-glob';
 import { parse as parseYaml } from 'yaml';
+import { formatBytes } from './constants.js';
 import { runCLI } from './cli-entry-point.js';
 /**
  * Log prefix for state:cleanup output
@@ -49,10 +50,7 @@ const LOG_PREFIX = '[state:cleanup]';
  * Tool name for audit logging
  */
 const TOOL_NAME = 'state:cleanup';
-/**
- * Bytes per KB for formatting
- */
-const BYTES_PER_KB = 1024;
+// WU-2044: BYTES_PER_KB imported from ./constants.js
 /**
  * Labels for output formatting
  */
@@ -117,19 +115,7 @@ async function writeAuditLog(baseDir, entry) {
         // Audit logging is non-fatal - silently ignore errors
     }
 }
-/**
- * Format bytes as human-readable string
- *
- * @param bytes - Number of bytes
- * @returns Formatted string (e.g., "1.5 KB")
- */
-function formatBytes(bytes) {
-    if (bytes < BYTES_PER_KB) {
-        return `${bytes} B`;
-    }
-    const kb = (bytes / BYTES_PER_KB).toFixed(1);
-    return `${kb} KB`;
-}
+// WU-2044: formatBytes imported from ./constants.js
 /**
  * Get active WU IDs (in_progress or blocked) by scanning WU YAML files.
  *
@@ -264,7 +250,7 @@ function printResult(result, quiet) {
 /**
  * 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();

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;