@lumenflow/initiatives 2.2.2 → 2.3.2

package/dist/index.d.ts

@@ -6,5 +6,6 @@ export * from './initiative-constants.js';
 export * from './initiative-orchestrator.js';
 export * from './initiative-paths.js';
 export * from './initiative-schema.js';
+export * from './initiative-validation.js';
 export * from './initiative-validator.js';
 export * from './initiative-yaml.js';

package/dist/index.js

@@ -6,5 +6,6 @@ export * from './initiative-constants.js';
 export * from './initiative-orchestrator.js';
 export * from './initiative-paths.js';
 export * from './initiative-schema.js';
+export * from './initiative-validation.js';
 export * from './initiative-validator.js';
 export * from './initiative-yaml.js';

package/dist/initiative-constants.d.ts

@@ -1,7 +1,7 @@
 /**
  * Centralized constants for Initiative management scripts.
  *
- * Mirrors wu-constants.mjs pattern. Single source of truth for all
+ * Mirrors wu-constants.ts pattern. Single source of truth for all
  * initiative-related magic strings, patterns, and enums.
  *
  * @example

package/dist/initiative-constants.js

@@ -1,7 +1,7 @@
 /**
  * Centralized constants for Initiative management scripts.
  *
- * Mirrors wu-constants.mjs pattern. Single source of truth for all
+ * Mirrors wu-constants.ts pattern. Single source of truth for all
  * initiative-related magic strings, patterns, and enums.
  *
  * @example

package/dist/initiative-orchestrator.d.ts

@@ -15,9 +15,9 @@
  * - Wave manifest files for idempotent resumption
  * - Compact output for token discipline
  *
- * @see {@link tools/orchestrate-initiative.mjs} - CLI entry point
- * @see {@link tools/lib/initiative-yaml.mjs} - Initiative loading
- * @see {@link tools/lib/dependency-graph.mjs} - Dependency graph utilities
+ * @see {@link packages/@lumenflow/cli/src/orchestrate-initiative.ts} - CLI entry point
+ * @see {@link packages/@lumenflow/cli/src/lib/initiative-yaml.ts} - Initiative loading
+ * @see {@link packages/@lumenflow/cli/src/lib/dependency-graph.ts} - Dependency graph utilities
  */
 import type { InitiativeDoc, WUEntry } from './initiative-yaml.js';
 /**
@@ -146,6 +146,52 @@ export declare const CHECKPOINT_AUTO_THRESHOLDS: {
     /** Auto-enable checkpoint mode if wave count exceeds this (>2 = 3+) */
     WAVE_COUNT: number;
 };
+/**
+ * WU-1200: Get the status string used in wave manifests for WUs.
+ *
+ * Returns 'queued' instead of 'spawned' to prevent confusion.
+ * A WU is 'queued' in the manifest when the spawn prompt is output,
+ * but it's not actually 'spawned' until an agent claims it.
+ *
+ * @returns {string} The manifest WU status ('queued')
+ */
+export declare function getManifestWUStatus(): string;
+/**
+ * WU-1200: Check if a WU has actually been spawned (agent launched).
+ *
+ * This checks the WU YAML status, not the wave manifest. A WU is considered
+ * "actually spawned" only if:
+ * - Its YAML status is 'in_progress' (agent has claimed it)
+ * - OR its YAML status is 'done' (agent has completed it)
+ *
+ * Wave manifests can have stale 'spawned' statuses from previous runs where
+ * the prompt was output but no agent was ever invoked. This function provides
+ * the authoritative check based on YAML status.
+ *
+ * @param {string} wuId - WU ID (e.g., 'WU-001')
+ * @returns {boolean} True if the WU is actually in progress or done
+ */
+export declare function isWUActuallySpawned(wuId: string): boolean;
+/**
+ * WU-1200: Get spawn candidates with YAML status verification.
+ *
+ * Filters WUs to find candidates that can be spawned, checking YAML status
+ * instead of relying solely on wave manifests. This prevents stale manifests
+ * from blocking new orchestration runs.
+ *
+ * A WU is a spawn candidate if:
+ * - Its YAML status is 'ready' (not in_progress, done, blocked, etc.)
+ * - It's in the provided WU list (part of the initiative)
+ *
+ * This function ignores wave manifest status because:
+ * - Manifests can be stale (prompt output but agent never launched)
+ * - YAML status is the authoritative source of truth
+ *
+ * @param {string} _initId - Initiative ID (for logging/context, not used for filtering)
+ * @param {Array<{id: string, doc: object}>} wus - WUs to filter
+ * @returns {Array<{id: string, doc: object}>} WUs that can be spawned
+ */
+export declare function getSpawnCandidatesWithYAMLCheck(_initId: string, wus: WUEntry[]): WUEntry[];
 /**
  * Load initiative and its WUs.
  *
@@ -185,6 +231,13 @@ export declare function loadMultipleInitiatives(initRefs: string[]): WUEntry[];
  * @throws {Error} If circular dependencies detected
  */
 export declare function buildExecutionPlan(wus: WUEntry[]): ExecutionPlan;
+/**
+ * Build execution plan from WUs asynchronously.
+ *
+ * @param {Array<{id: string, doc: object}>} wus - WUs to plan
+ * @returns {Promise<ExecutionPlan>}
+ */
+export declare function buildExecutionPlanAsync(wus: WUEntry[]): Promise<ExecutionPlan>;
 /**
  * WU-1828: Determine if checkpoint mode should be auto-enabled based on initiative size.
  *
@@ -199,6 +252,13 @@ export declare function buildExecutionPlan(wus: WUEntry[]): ExecutionPlan;
  * @returns {{autoEnabled: boolean, reason: string, pendingCount: number, waveCount: number}}
  */
 export declare function shouldAutoEnableCheckpoint(wus: WUEntry[]): AutoCheckpointResult;
+/**
+ * WU-1828: Determine if checkpoint mode should be auto-enabled based on initiative size asynchronously.
+ *
+ * @param {Array<{id: string, doc: object}>} wus - WUs to analyse
+ * @returns {Promise<{autoEnabled: boolean, reason: string, pendingCount: number, waveCount: number}>}
+ */
+export declare function shouldAutoEnableCheckpointAsync(wus: WUEntry[]): Promise<AutoCheckpointResult>;
 /**
  * WU-1828: Resolve checkpoint mode from CLI flags and auto-detection.
  * WU-2430: Updated to suppress auto-detection in dry-run mode.
@@ -214,6 +274,14 @@ export declare function shouldAutoEnableCheckpoint(wus: WUEntry[]): AutoCheckpoi
  * @returns {{enabled: boolean, source: 'explicit'|'override'|'auto'|'dryrun', reason?: string}}
  */
 export declare function resolveCheckpointMode(options: CheckpointOptions, wus: WUEntry[]): CheckpointModeResult;
+/**
+ * WU-1828: Resolve checkpoint mode from CLI flags and auto-detection asynchronously.
+ *
+ * @param {{checkpointPerWave?: boolean, noCheckpoint?: boolean, dryRun?: boolean}} options - CLI options
+ * @param {Array<{id: string, doc: object}>} wus - WUs for auto-detection
+ * @returns {Promise<{enabled: boolean, source: 'explicit'|'override'|'auto'|'dryrun', reason?: string}>}
+ */
+export declare function resolveCheckpointModeAsync(options: CheckpointOptions, wus: WUEntry[]): Promise<CheckpointModeResult>;
 /**
  * Get bottleneck WUs from a set of WUs based on how many downstream WUs they block.
  * A bottleneck is a WU that blocks multiple other WUs.
@@ -256,11 +324,12 @@ export declare function calculateProgress(wus: WUEntry[]): ProgressStats;
 export declare function formatProgress(progress: ProgressStats): string;
 /**
  * WU-2040: Filter WUs by dependency stamp status.
+ * WU-1251: Now checks both blocked_by AND dependencies arrays.
  *
- * A WU is only spawnable if ALL its blocked_by dependencies have stamps.
+ * A WU is only spawnable if ALL its dependencies have stamps.
  * This implements the wait-for-completion pattern per Anthropic multi-agent research.
  *
- * @param {Array<{id: string, doc: {blocked_by?: string[], lane: string, status: string}}>} candidates - WU candidates
+ * @param {Array<{id: string, doc: {blocked_by?: string[], dependencies?: string[], lane: string, status: string}}>} candidates - WU candidates
  * @returns {{spawnable: Array<object>, blocked: Array<object>, blockingDeps: string[], waitingMessage: string}}
  */
 export declare function filterByDependencyStamps(candidates: WUEntry[]): DependencyFilterResult;

package/dist/initiative-orchestrator.js

@@ -15,14 +15,34 @@
  * - Wave manifest files for idempotent resumption
  * - Compact output for token discipline
  *
- * @see {@link tools/orchestrate-initiative.mjs} - CLI entry point
- * @see {@link tools/lib/initiative-yaml.mjs} - Initiative loading
- * @see {@link tools/lib/dependency-graph.mjs} - Dependency graph utilities
+ * @see {@link packages/@lumenflow/cli/src/orchestrate-initiative.ts} - CLI entry point
+ * @see {@link packages/@lumenflow/cli/src/lib/initiative-yaml.ts} - Initiative loading
+ * @see {@link packages/@lumenflow/cli/src/lib/dependency-graph.ts} - Dependency graph utilities
  */
 import { existsSync, mkdirSync, writeFileSync, readFileSync, readdirSync } from 'node:fs';
 import { join } from 'node:path';
 import { findInitiative, getInitiativeWUs } from './initiative-yaml.js';
-import { buildDependencyGraph, validateGraph } from '@lumenflow/core/lib/dependency-graph.js';
+import { buildDependencyGraph, buildDependencyGraphAsync, validateGraph, } from '@lumenflow/core/lib/dependency-graph.js';
+/**
+ * WU-1251: Helper to get all dependencies from a WU doc.
+ *
+ * Combines both `blocked_by` and `dependencies` arrays for dependency resolution.
+ * The WU YAML schema supports both:
+ * - `blocked_by`: Legacy/explicit blockers
+ * - `dependencies`: Semantic dependencies on other WUs
+ *
+ * Both arrays represent the same concept: WUs that must complete before this WU can start.
+ *
+ * @param {object} doc - WU document
+ * @returns {string[]} Combined list of all dependency WU IDs (deduplicated)
+ */
+function getAllDependencies(doc) {
+    const blockedBy = doc.blocked_by ?? [];
+    const dependencies = doc.dependencies ?? [];
+    // Combine and deduplicate
+    const allDeps = new Set([...blockedBy, ...dependencies]);
+    return Array.from(allDeps);
+}
 import { createError, ErrorCodes } from '@lumenflow/core/lib/error-handler.js';
 import { WU_STATUS, STRING_LITERALS } from '@lumenflow/core/lib/wu-constants.js';
 import { WU_PATHS } from '@lumenflow/core/lib/wu-paths.js';
@@ -72,6 +92,88 @@ export const CHECKPOINT_AUTO_THRESHOLDS = {
     /** Auto-enable checkpoint mode if wave count exceeds this (>2 = 3+) */
     WAVE_COUNT: 2,
 };
+/**
+ * WU-1200: Wave manifest WU status constant.
+ *
+ * Changed from 'spawned' to 'queued' to prevent confusion.
+ * 'spawned' implies an agent was launched, but the manifest is written
+ * BEFORE an agent is actually invoked (when the prompt is output, not when
+ * the user copies and executes it).
+ *
+ * Using 'queued' makes it clear the WU is ready to be spawned but not yet running.
+ */
+const MANIFEST_WU_STATUS = 'queued';
+/**
+ * WU-1200: Get the status string used in wave manifests for WUs.
+ *
+ * Returns 'queued' instead of 'spawned' to prevent confusion.
+ * A WU is 'queued' in the manifest when the spawn prompt is output,
+ * but it's not actually 'spawned' until an agent claims it.
+ *
+ * @returns {string} The manifest WU status ('queued')
+ */
+export function getManifestWUStatus() {
+    return MANIFEST_WU_STATUS;
+}
+/**
+ * WU-1200: Check if a WU has actually been spawned (agent launched).
+ *
+ * This checks the WU YAML status, not the wave manifest. A WU is considered
+ * "actually spawned" only if:
+ * - Its YAML status is 'in_progress' (agent has claimed it)
+ * - OR its YAML status is 'done' (agent has completed it)
+ *
+ * Wave manifests can have stale 'spawned' statuses from previous runs where
+ * the prompt was output but no agent was ever invoked. This function provides
+ * the authoritative check based on YAML status.
+ *
+ * @param {string} wuId - WU ID (e.g., 'WU-001')
+ * @returns {boolean} True if the WU is actually in progress or done
+ */
+export function isWUActuallySpawned(wuId) {
+    const wuPath = WU_PATHS.WU(wuId);
+    if (!existsSync(wuPath)) {
+        // WU file not found - can't determine status, assume not spawned
+        return false;
+    }
+    try {
+        const text = readFileSync(wuPath, 'utf8');
+        const doc = parseYAML(text);
+        const status = doc.status ?? 'unknown';
+        // WU is "actually spawned" if status indicates active or completed work
+        return status === WU_STATUS.IN_PROGRESS || status === WU_STATUS.DONE;
+    }
+    catch {
+        // Error reading/parsing WU file - assume not spawned
+        return false;
+    }
+}
+/**
+ * WU-1200: Get spawn candidates with YAML status verification.
+ *
+ * Filters WUs to find candidates that can be spawned, checking YAML status
+ * instead of relying solely on wave manifests. This prevents stale manifests
+ * from blocking new orchestration runs.
+ *
+ * A WU is a spawn candidate if:
+ * - Its YAML status is 'ready' (not in_progress, done, blocked, etc.)
+ * - It's in the provided WU list (part of the initiative)
+ *
+ * This function ignores wave manifest status because:
+ * - Manifests can be stale (prompt output but agent never launched)
+ * - YAML status is the authoritative source of truth
+ *
+ * @param {string} _initId - Initiative ID (for logging/context, not used for filtering)
+ * @param {Array<{id: string, doc: object}>} wus - WUs to filter
+ * @returns {Array<{id: string, doc: object}>} WUs that can be spawned
+ */
+export function getSpawnCandidatesWithYAMLCheck(_initId, wus) {
+    // Filter to only 'ready' status WUs based on YAML, not manifest
+    return wus.filter((wu) => {
+        const status = wu.doc.status ?? 'unknown';
+        return status === WU_STATUS.READY;
+    });
+}
 /**
  * Load initiative and its WUs.
  *
@@ -190,7 +292,8 @@ export function buildExecutionPlan(wus) {
         reasonSet.add(reason);
     };
     for (const wu of readyWUs) {
-        const blockers = wu.doc.blocked_by ?? [];
+        // WU-1251: Use getAllDependencies to combine blocked_by and dependencies arrays
+        const blockers = getAllDependencies(wu.doc);
         const externalBlockers = blockers.filter((blockerId) => !allWuIds.has(blockerId));
         const internalBlockers = blockers.filter((blockerId) => allWuIds.has(blockerId));
         if (externalBlockers.length > 0) {
@@ -225,7 +328,8 @@ export function buildExecutionPlan(wus) {
             if (deferredIds.has(wu.id)) {
                 continue;
             }
-            const blockers = wu.doc.blocked_by || [];
+            // WU-1251: Use getAllDependencies to combine blocked_by and dependencies arrays
+            const blockers = getAllDependencies(wu.doc);
             const deferredInternal = blockers.filter((blockerId) => allWuIds.has(blockerId) && deferredIds.has(blockerId));
             if (deferredInternal.length > 0) {
                 const details = deferredInternal.map((blockerId) => {
@@ -262,7 +366,8 @@ export function buildExecutionPlan(wus) {
     const completed = new Set(skipped); // Treat done WUs as completed for dependency resolution
     // Also treat stamped external deps as completed
     for (const wu of wus) {
-        const blockers = wu.doc.blocked_by || [];
+        // WU-1251: Use getAllDependencies to combine blocked_by and dependencies arrays
+        const blockers = getAllDependencies(wu.doc);
         for (const blockerId of blockers) {
             if (!allWuIds.has(blockerId) && hasStamp(blockerId)) {
                 completed.add(blockerId);
@@ -275,7 +380,193 @@ export function buildExecutionPlan(wus) {
         const deferredToNextWave = []; // WUs that could run but lane is occupied
         for (const id of remaining) {
             const wu = schedulableMap.get(id);
-            const blockers = wu.doc.blocked_by || [];
+            // WU-1251: Use getAllDependencies to combine blocked_by and dependencies arrays
+            const blockers = getAllDependencies(wu.doc);
+            // Check if all blockers are either done or completed in previous waves
+            const allBlockersDone = blockers.every((blockerId) => completed.has(blockerId));
+            if (allBlockersDone) {
+                // WU-1618: Check if lane is already occupied in this wave
+                const lane = wu.doc.lane;
+                if (lanesInWave.has(lane)) {
+                    // Defer to next wave (lane conflict)
+                    deferredToNextWave.push(wu);
+                }
+                else {
+                    wave.push(wu);
+                    lanesInWave.add(lane);
+                }
+            }
+        }
+        // Deadlock detection: if no WUs can be scheduled but remaining exist
+        // WU-1618: Account for deferred WUs (they can run in next wave, not stuck)
+        if (wave.length === 0 && remaining.size > 0 && deferredToNextWave.length === 0) {
+            const stuckIds = Array.from(remaining);
+            throw createError(ErrorCodes.VALIDATION_ERROR, `Circular or unresolvable dependencies detected. Stuck WUs: ${stuckIds.join(', ')}`, { stuckIds });
+        }
+        // Add wave and mark WUs as completed
+        waves.push(wave);
+        for (const wu of wave) {
+            remaining.delete(wu.id);
+            completed.add(wu.id);
+        }
+    }
+    return { waves, skipped, skippedWithReasons, deferred };
+}
+/**
+ * Build execution plan from WUs asynchronously.
+ *
+ * @param {Array<{id: string, doc: object}>} wus - WUs to plan
+ * @returns {Promise<ExecutionPlan>}
+ */
+export async function buildExecutionPlanAsync(wus) {
+    // WU-2430: Enhanced categorisation of WUs
+    const skipped = []; // IDs of done WUs (backwards compat)
+    const skippedWithReasons = []; // WU-2430: Non-ready WUs with reasons
+    const deferred = []; // WU-2430: Ready WUs waiting on external blockers
+    const doneStatuses = new Set([WU_STATUS.DONE, WU_STATUS.COMPLETED]);
+    // Categorise WUs by status
+    for (const wu of wus) {
+        const status = wu.doc.status ?? 'unknown';
+        if (doneStatuses.has(status)) {
+            skipped.push(wu.id);
+        }
+        else if (status !== WU_STATUS.READY) {
+            skippedWithReasons.push({ id: wu.id, reason: `status: ${status}` });
+        }
+    }
+    // WU-2430: Only ready WUs are candidates for execution
+    const readyWUs = wus.filter((wu) => wu.doc.status === WU_STATUS.READY);
+    if (readyWUs.length === 0) {
+        return { waves: [], skipped, skippedWithReasons, deferred };
+    }
+    // Build a map for quick lookup
+    const wuMap = new Map(readyWUs.map((wu) => [wu.id, wu]));
+    const wuIds = new Set(wuMap.keys());
+    const allWuMap = new Map(wus.map((wu) => [wu.id, wu]));
+    const allWuIds = new Set(allWuMap.keys());
+    // Build dependency graph for validation (check cycles)
+    const graph = await buildDependencyGraphAsync();
+    const { cycles } = validateGraph(graph);
+    // Filter cycles to only those involving our WUs
+    const relevantCycles = cycles.filter((cycle) => cycle.some((id) => wuIds.has(id)));
+    if (relevantCycles.length > 0) {
+        const cycleStr = relevantCycles.map((c) => c.join(' → ')).join('; ');
+        throw createError(ErrorCodes.VALIDATION_ERROR, `Circular dependencies detected: ${cycleStr}`, {
+            cycles: relevantCycles,
+        });
+    }
+    // WU-2430: Check for external blockers without stamps
+    // A WU with blocked_by dependencies that are NOT in the initiative
+    // and do NOT have stamps should be deferred
+    const deferredIds = new Set();
+    const deferredReasons = new Map();
+    const deferredBlockers = new Map();
+    const addDeferredEntry = (wuId, blockers, reason) => {
+        deferredIds.add(wuId);
+        if (!deferredReasons.has(wuId)) {
+            deferredReasons.set(wuId, new Set());
+        }
+        if (!deferredBlockers.has(wuId)) {
+            deferredBlockers.set(wuId, new Set());
+        }
+        const reasonSet = deferredReasons.get(wuId);
+        const blockerSet = deferredBlockers.get(wuId);
+        for (const blockerId of blockers) {
+            blockerSet.add(blockerId);
+        }
+        reasonSet.add(reason);
+    };
+    for (const wu of readyWUs) {
+        // WU-1251: Use getAllDependencies to combine blocked_by and dependencies arrays
+        const blockers = getAllDependencies(wu.doc);
+        const externalBlockers = blockers.filter((blockerId) => !allWuIds.has(blockerId));
+        const internalBlockers = blockers.filter((blockerId) => allWuIds.has(blockerId));
+        if (externalBlockers.length > 0) {
+            // Check if any external blockers lack stamps
+            const unstampedBlockers = externalBlockers.filter((blockerId) => !hasStamp(blockerId));
+            if (unstampedBlockers.length > 0) {
+                addDeferredEntry(wu.id, unstampedBlockers, `waiting for external: ${unstampedBlockers.join(', ')}`);
+            }
+        }
+        if (internalBlockers.length > 0) {
+            const nonReadyInternal = internalBlockers.filter((blockerId) => {
+                const blocker = allWuMap.get(blockerId);
+                const status = blocker?.doc?.status ?? 'unknown';
+                if (status === WU_STATUS.READY) {
+                    return false;
+                }
+                return !doneStatuses.has(status);
+            });
+            if (nonReadyInternal.length > 0) {
+                const details = nonReadyInternal.map((blockerId) => {
+                    const status = allWuMap.get(blockerId)?.doc?.status ?? 'unknown';
+                    return `${blockerId} (status: ${status})`;
+                });
+                addDeferredEntry(wu.id, nonReadyInternal, `waiting for internal: ${details.join(', ')}`);
+            }
+        }
+    }
+    let hasNewDeferral = true;
+    while (hasNewDeferral) {
+        hasNewDeferral = false;
+        for (const wu of readyWUs) {
+            if (deferredIds.has(wu.id)) {
+                continue;
+            }
+            // WU-1251: Use getAllDependencies to combine blocked_by and dependencies arrays
+            const blockers = getAllDependencies(wu.doc);
+            const deferredInternal = blockers.filter((blockerId) => allWuIds.has(blockerId) && deferredIds.has(blockerId));
+            if (deferredInternal.length > 0) {
+                const details = deferredInternal.map((blockerId) => {
+                    const status = allWuMap.get(blockerId)?.doc?.status ?? 'unknown';
+                    return `${blockerId} (status: ${status})`;
+                });
+                addDeferredEntry(wu.id, deferredInternal, `waiting for internal: ${details.join(', ')}`);
+                hasNewDeferral = true;
+            }
+        }
+    }
+    for (const wu of readyWUs) {
+        if (deferredIds.has(wu.id)) {
+            const blockerSet = deferredBlockers.get(wu.id) || new Set();
+            const reasonSet = deferredReasons.get(wu.id) || new Set();
+            deferred.push({
+                id: wu.id,
+                blockedBy: Array.from(blockerSet),
+                reason: reasonSet.size > 0 ? Array.from(reasonSet).join('; ') : 'waiting for dependencies',
+            });
+        }
+    }
+    // Remove deferred WUs from candidates
+    const schedulableWUs = readyWUs.filter((wu) => !deferredIds.has(wu.id));
+    const schedulableMap = new Map(schedulableWUs.map((wu) => [wu.id, wu]));
+    const schedulableIds = new Set(schedulableMap.keys());
+    if (schedulableIds.size === 0) {
+        return { waves: [], skipped, skippedWithReasons, deferred };
+    }
+    // Build waves using Kahn's algorithm (topological sort by levels)
+    // WU-1618: Also enforce lane WIP=1 constraint (no two WUs with same lane in same wave)
+    const waves = [];
+    const remaining = new Set(schedulableIds);
+    const completed = new Set(skipped); // Treat done WUs as completed for dependency resolution
+    // Also treat stamped external deps as completed
+    for (const wu of wus) {
+        // WU-1251: Use getAllDependencies to combine blocked_by and dependencies arrays
+        const blockers = getAllDependencies(wu.doc);
+        for (const blockerId of blockers) {
+            if (!allWuIds.has(blockerId) && hasStamp(blockerId)) {
+                completed.add(blockerId);
+            }
+        }
+    }
+    while (remaining.size > 0) {
+        const wave = [];
+        const lanesInWave = new Set(); // WU-1618: Track lanes used in this wave
+        const deferredToNextWave = []; // WUs that could run but lane is occupied
+        for (const id of remaining) {
+            const wu = schedulableMap.get(id);
+            // WU-1251: Use getAllDependencies to combine blocked_by and dependencies arrays
+            const blockers = getAllDependencies(wu.doc);
             // Check if all blockers are either done or completed in previous waves
             const allBlockersDone = blockers.every((blockerId) => completed.has(blockerId));
             if (allBlockersDone) {
@@ -360,6 +651,53 @@ export function shouldAutoEnableCheckpoint(wus) {
         waveCount,
     };
 }
+/**
+ * WU-1828: Determine if checkpoint mode should be auto-enabled based on initiative size asynchronously.
+ *
+ * @param {Array<{id: string, doc: object}>} wus - WUs to analyse
+ * @returns {Promise<{autoEnabled: boolean, reason: string, pendingCount: number, waveCount: number}>}
+ */
+export async function shouldAutoEnableCheckpointAsync(wus) {
+    // Count only pending WUs (not done)
+    const pendingWUs = wus.filter((wu) => wu.doc.status !== WU_STATUS.DONE);
+    const pendingCount = pendingWUs.length;
+    // Check WU count threshold first (faster check)
+    if (pendingCount > CHECKPOINT_AUTO_THRESHOLDS.WU_COUNT) {
+        return {
+            autoEnabled: true,
+            reason: `${pendingCount} pending WUs exceeds threshold (>${CHECKPOINT_AUTO_THRESHOLDS.WU_COUNT})`,
+            pendingCount,
+            waveCount: -1, // Not computed (early return)
+        };
+    }
+    // Only compute waves if WU count didn't trigger
+    if (pendingCount === 0) {
+        return {
+            autoEnabled: false,
+            reason: 'No pending WUs',
+            pendingCount: 0,
+            waveCount: 0,
+        };
+    }
+    // Build execution plan to count waves
+    const plan = await buildExecutionPlanAsync(wus);
+    const waveCount = plan.waves.length;
+    // Check wave count threshold
+    if (waveCount > CHECKPOINT_AUTO_THRESHOLDS.WAVE_COUNT) {
+        return {
+            autoEnabled: true,
+            reason: `${waveCount} waves exceeds threshold (>${CHECKPOINT_AUTO_THRESHOLDS.WAVE_COUNT})`,
+            pendingCount,
+            waveCount,
+        };
+    }
+    return {
+        autoEnabled: false,
+        reason: `${pendingCount} pending WUs and ${waveCount} waves within thresholds`,
+        pendingCount,
+        waveCount,
+    };
+}
 /**
  * WU-1828: Resolve checkpoint mode from CLI flags and auto-detection.
  * WU-2430: Updated to suppress auto-detection in dry-run mode.
@@ -408,6 +746,47 @@ export function resolveCheckpointMode(options, wus) {
         reason: autoResult.reason,
     };
 }
+/**
+ * WU-1828: Resolve checkpoint mode from CLI flags and auto-detection asynchronously.
+ *
+ * @param {{checkpointPerWave?: boolean, noCheckpoint?: boolean, dryRun?: boolean}} options - CLI options
+ * @param {Array<{id: string, doc: object}>} wus - WUs for auto-detection
+ * @returns {Promise<{enabled: boolean, source: 'explicit'|'override'|'auto'|'dryrun', reason?: string}>}
+ */
+export async function resolveCheckpointModeAsync(options, wus) {
+    const { checkpointPerWave = false, noCheckpoint = false, dryRun = false } = options;
+    // Explicit enable via -c flag
+    if (checkpointPerWave) {
+        return {
+            enabled: true,
+            source: 'explicit',
+            reason: 'Enabled via -c/--checkpoint-per-wave flag',
+        };
+    }
+    // Explicit disable via --no-checkpoint flag
+    if (noCheckpoint) {
+        return {
+            enabled: false,
+            source: 'override',
+            reason: 'Disabled via --no-checkpoint flag',
+        };
+    }
+    // WU-2430: Dry-run suppresses auto-detection (preview should use polling mode)
+    if (dryRun) {
+        return {
+            enabled: false,
+            source: 'dryrun',
+            reason: 'Disabled in dry-run mode (preview uses polling mode)',
+        };
+    }
+    // Auto-detection
+    const autoResult = await shouldAutoEnableCheckpointAsync(wus);
+    return {
+        enabled: autoResult.autoEnabled,
+        source: 'auto',
+        reason: autoResult.reason,
+    };
+}
 /**
  * Get bottleneck WUs from a set of WUs based on how many downstream WUs they block.
  * A bottleneck is a WU that blocks multiple other WUs.
@@ -425,7 +804,8 @@ export function getBottleneckWUs(wus, limit = 5) {
     }
     // Count how many WUs each WU blocks
     for (const wu of wus) {
-        const blockers = wu.doc.blocked_by || [];
+        // WU-1251: Use getAllDependencies to combine blocked_by and dependencies arrays
+        const blockers = getAllDependencies(wu.doc);
         for (const blockerId of blockers) {
             if (blocksCounts.has(blockerId)) {
                 blocksCounts.set(blockerId, blocksCounts.get(blockerId) + 1);
@@ -505,7 +885,8 @@ export function formatExecutionPlan(initiative, plan) {
         const wave = plan.waves[i];
         lines.push(`Wave ${i} (${wave.length} WU${wave.length !== 1 ? 's' : ''} in parallel):`);
         for (const wu of wave) {
-            const blockers = wu.doc.blocked_by || [];
+            // WU-1251: Use getAllDependencies to combine blocked_by and dependencies arrays
+            const blockers = getAllDependencies(wu.doc);
             const blockerStr = blockers.length > 0 ? ` [blocked by: ${blockers.join(', ')}]` : '';
             // Mark bottleneck WUs (WU-1596)
             const isBottleneck = bottleneckWUs.some((b) => b.id === wu.id);
@@ -610,11 +991,12 @@ function hasStamp(wuId) {
 }
 /**
  * WU-2040: Filter WUs by dependency stamp status.
+ * WU-1251: Now checks both blocked_by AND dependencies arrays.
  *
- * A WU is only spawnable if ALL its blocked_by dependencies have stamps.
+ * A WU is only spawnable if ALL its dependencies have stamps.
  * This implements the wait-for-completion pattern per Anthropic multi-agent research.
  *
- * @param {Array<{id: string, doc: {blocked_by?: string[], lane: string, status: string}}>} candidates - WU candidates
+ * @param {Array<{id: string, doc: {blocked_by?: string[], dependencies?: string[], lane: string, status: string}}>} candidates - WU candidates
  * @returns {{spawnable: Array<object>, blocked: Array<object>, blockingDeps: string[], waitingMessage: string}}
  */
 export function filterByDependencyStamps(candidates) {
@@ -622,7 +1004,8 @@ export function filterByDependencyStamps(candidates) {
     const blocked = [];
     const blockingDeps = new Set();
     for (const wu of candidates) {
-        const deps = wu.doc.blocked_by || [];
+        // WU-1251: Use getAllDependencies to combine blocked_by and dependencies arrays
+        const deps = getAllDependencies(wu.doc);
         // Check if ALL dependencies have stamps
         const unmetDeps = deps.filter((depId) => !hasStamp(depId));
         if (unmetDeps.length === 0) {
@@ -684,7 +1067,7 @@ function getExistingWaveManifests(initId) {
  * @param {string} initId - Initiative ID
  * @returns {Set<string>} Set of WU IDs already in manifests
  */
-function getSpawnedWUIds(initId) {
+function _getSpawnedWUIds(initId) {
     const manifests = getExistingWaveManifests(initId);
     const spawnedIds = new Set();
     for (const manifest of manifests) {
@@ -753,25 +1136,29 @@ export function buildCheckpointWave(initRef, options = {}) {
     }
     const initId = initData.id;
     const wus = getInitiativeWUs(initRef);
-    // Get already spawned WU IDs from previous manifests
-    const spawnedIds = getSpawnedWUIds(initId);
+    // WU-1200: Check YAML status, not just wave manifests
+    // Wave manifests can be stale (prompt output but agent never launched)
+    // YAML status is the authoritative source of truth
     // Filter to spawn candidates:
-    // 1. status: ready only
+    // 1. status: ready only (from YAML - authoritative)
     // 2. No stamp exists (idempotency)
-    // 3. Not already in a previous manifest
+    // 3. WU is not actually spawned (YAML status not in_progress/done)
+    //
+    // Note: We no longer rely on wave manifests for exclusion because:
+    // - Manifests can be stale (AC3: Stale wave manifests don't block new runs)
+    // - YAML status is updated when an agent actually claims the WU
     const readyCandidates = wus.filter((wu) => {
-        // Only ready WUs
+        // Only ready WUs (YAML status - authoritative)
         if (wu.doc.status !== WU_STATUS.READY) {
             return false;
         }
-        // Skip if stamp exists (highest precedence)
+        // Skip if stamp exists (highest precedence - WU is complete)
         if (hasStamp(wu.id)) {
             return false;
         }
-        // Skip if already in previous manifest
-        if (spawnedIds.has(wu.id)) {
-            return false;
-        }
+        // WU-1200: Check YAML status, not manifest status
+        // If YAML says 'ready', the WU hasn't been claimed yet, so it's spawnable
+        // (even if a stale manifest says it was 'spawned')
         return true;
     });
     // If no ready candidates, all work is done
@@ -805,6 +1192,8 @@ export function buildCheckpointWave(initRef, options = {}) {
     // Determine wave number
     const waveNum = getNextWaveNumber(initId);
     // Build manifest
+    // WU-1200: Use 'queued' status instead of 'spawned' to prevent confusion
+    // 'queued' indicates the WU is ready to spawn, not that an agent was launched
     const manifest = {
         initiative: initId,
         wave: waveNum,
@@ -812,7 +1201,7 @@ export function buildCheckpointWave(initRef, options = {}) {
         wus: selectedWUs.map((wu) => ({
             id: wu.id,
             lane: wu.doc.lane,
-            status: 'spawned',
+            status: MANIFEST_WU_STATUS,
         })),
         lane_validation: 'pass',
         done_criteria: 'All stamps exist in .lumenflow/stamps/',

package/dist/initiative-paths.d.ts

@@ -1,7 +1,7 @@
 /**
  * Centralized path constants for Initiative management scripts.
  *
- * Mirrors wu-paths.mjs pattern. Single source of truth for all
+ * Mirrors wu-paths.ts pattern. Single source of truth for all
  * initiative-related file paths.
  *
  * @example

package/dist/initiative-paths.js

@@ -2,7 +2,7 @@ import path from 'node:path';
 /**
  * Centralized path constants for Initiative management scripts.
  *
- * Mirrors wu-paths.mjs pattern. Single source of truth for all
+ * Mirrors wu-paths.ts pattern. Single source of truth for all
  * initiative-related file paths.
  *
  * @example

package/dist/initiative-schema.d.ts

@@ -4,8 +4,8 @@
  * Zod schema for runtime validation of Initiative YAML structure.
  * Part of the Initiative System Phase 1 - Schema & Validation Foundation.
  *
- * @see {@link tools/validate.mjs} - Consumer (CI validation)
- * @see {@link tools/lib/initiative-validator.mjs} - Consumer (dependency graph validation)
+ * @see {@link packages/@lumenflow/cli/src/validate.ts} - Consumer (CI validation)
+ * @see {@link packages/@lumenflow/cli/src/lib/initiative-validator.ts} - Consumer (dependency graph validation)
  * @see {@link docs/04-operations/tasks/initiatives/} - Initiative YAML files
  */
 import { z } from 'zod';

package/dist/initiative-schema.js

@@ -4,8 +4,8 @@
  * Zod schema for runtime validation of Initiative YAML structure.
  * Part of the Initiative System Phase 1 - Schema & Validation Foundation.
  *
- * @see {@link tools/validate.mjs} - Consumer (CI validation)
- * @see {@link tools/lib/initiative-validator.mjs} - Consumer (dependency graph validation)
+ * @see {@link packages/@lumenflow/cli/src/validate.ts} - Consumer (CI validation)
+ * @see {@link packages/@lumenflow/cli/src/lib/initiative-validator.ts} - Consumer (dependency graph validation)
  * @see {@link docs/04-operations/tasks/initiatives/} - Initiative YAML files
  */
 import { z } from 'zod';

package/dist/initiative-validation.d.ts

@@ -0,0 +1,129 @@
+/**
+ * Initiative Completeness Validation (WU-1211)
+ *
+ * Validates initiative completeness and determines when
+ * initiative status should auto-progress.
+ *
+ * Used by:
+ * - initiative:create (warns if description not provided)
+ * - wu:create --initiative (warns if initiative has no phases)
+ * - wu:claim (auto-progresses initiative status)
+ * - state:doctor (reports incomplete initiatives)
+ */
+/**
+ * Result of initiative completeness validation
+ */
+export interface InitiativeCompletenessResult {
+    /** Whether the initiative is valid (always true - issues are warnings not errors) */
+    valid: boolean;
+    /** Warning messages for incomplete fields */
+    warnings: string[];
+}
+/**
+ * Result of checking if initiative has phases defined
+ */
+export interface InitiativePhaseCheck {
+    /** Whether the initiative has at least one phase */
+    hasPhases: boolean;
+    /** Warning message if no phases (null if phases exist) */
+    warning: string | null;
+}
+/**
+ * Result of checking if initiative status should progress
+ */
+export interface InitiativeProgressCheck {
+    /** Whether the initiative status should progress */
+    shouldProgress: boolean;
+    /** The new status if shouldProgress is true */
+    newStatus: string | null;
+}
+/**
+ * Initiative document interface for validation
+ */
+interface InitiativeDoc {
+    id?: string;
+    slug?: string;
+    title?: string;
+    description?: string;
+    status?: string;
+    phases?: Array<{
+        id: number;
+        title?: string;
+        status?: string;
+    }>;
+    success_metrics?: string[];
+    [key: string]: unknown;
+}
+/**
+ * WU document interface for validation
+ */
+interface WUDoc {
+    id?: string;
+    status?: string;
+    initiative?: string;
+    [key: string]: unknown;
+}
+/**
+ * Validates initiative completeness and returns warnings for missing fields.
+ *
+ * This is soft validation - missing fields generate warnings, not errors.
+ * The initiative is still considered valid but incomplete.
+ *
+ * @param initiative - Initiative document to validate
+ * @returns Validation result with warnings for incomplete fields
+ *
+ * @example
+ * const result = validateInitiativeCompleteness(initiative);
+ * if (result.warnings.length > 0) {
+ *   console.warn('Initiative is incomplete:', result.warnings);
+ * }
+ */
+export declare function validateInitiativeCompleteness(initiative: InitiativeDoc): InitiativeCompletenessResult;
+/**
+ * Checks if an initiative has phases defined.
+ *
+ * Used by wu:create --initiative to warn when linking WUs to
+ * initiatives without phases.
+ *
+ * @param initiative - Initiative document to check
+ * @returns Check result with warning if no phases
+ *
+ * @example
+ * const result = checkInitiativePhases(initiative);
+ * if (!result.hasPhases) {
+ *   console.warn(result.warning);
+ * }
+ */
+export declare function checkInitiativePhases(initiative: InitiativeDoc): InitiativePhaseCheck;
+/**
+ * Determines if an initiative status should progress based on WU activity.
+ *
+ * Auto-progression rules:
+ * - draft -> in_progress: when first WU is claimed (status: in_progress)
+ * - open -> in_progress: when first WU is claimed (status: in_progress)
+ *
+ * Terminal statuses (done, archived) never progress.
+ *
+ * @param initiative - Initiative document to check
+ * @param wus - Array of WUs (all WUs, filtering is done internally)
+ * @returns Check result with new status if progression is needed
+ *
+ * @example
+ * const result = shouldProgressInitiativeStatus(initiative, allWUs);
+ * if (result.shouldProgress) {
+ *   initiative.status = result.newStatus;
+ *   // Save initiative
+ * }
+ */
+export declare function shouldProgressInitiativeStatus(initiative: InitiativeDoc, wus: WUDoc[]): InitiativeProgressCheck;
+/**
+ * Finds incomplete initiatives for state:doctor reporting.
+ *
+ * @param initiatives - Array of initiative documents
+ * @returns Array of incomplete initiative reports
+ */
+export declare function findIncompleteInitiatives(initiatives: InitiativeDoc[]): Array<{
+    id: string;
+    warnings: string[];
+}>;
+export {};

package/dist/initiative-validation.js

@@ -0,0 +1,140 @@
+/**
+ * Initiative Completeness Validation (WU-1211)
+ *
+ * Validates initiative completeness and determines when
+ * initiative status should auto-progress.
+ *
+ * Used by:
+ * - initiative:create (warns if description not provided)
+ * - wu:create --initiative (warns if initiative has no phases)
+ * - wu:claim (auto-progresses initiative status)
+ * - state:doctor (reports incomplete initiatives)
+ */
+/** Initiative statuses that can transition to in_progress */
+const PROGRESSABLE_STATUSES = ['draft', 'open'];
+/** WU statuses that indicate active work */
+const ACTIVE_WU_STATUSES = ['in_progress'];
+/**
+ * Validates initiative completeness and returns warnings for missing fields.
+ *
+ * This is soft validation - missing fields generate warnings, not errors.
+ * The initiative is still considered valid but incomplete.
+ *
+ * @param initiative - Initiative document to validate
+ * @returns Validation result with warnings for incomplete fields
+ *
+ * @example
+ * const result = validateInitiativeCompleteness(initiative);
+ * if (result.warnings.length > 0) {
+ *   console.warn('Initiative is incomplete:', result.warnings);
+ * }
+ */
+export function validateInitiativeCompleteness(initiative) {
+    const warnings = [];
+    const id = initiative.id || 'unknown';
+    // Check description
+    if (!initiative.description || initiative.description.trim() === '') {
+        warnings.push(`[${id}] Initiative has no description. Add a description to explain its purpose.`);
+    }
+    // Check phases
+    if (!initiative.phases || initiative.phases.length === 0) {
+        warnings.push(`[${id}] Initiative has no phases defined. Add phases to break down the work.`);
+    }
+    // Check success_metrics
+    if (!initiative.success_metrics || initiative.success_metrics.length === 0) {
+        warnings.push(`[${id}] Initiative has no success_metrics defined. Add metrics to measure completion.`);
+    }
+    return {
+        valid: true, // Always valid - issues are warnings not errors
+        warnings,
+    };
+}
+/**
+ * Checks if an initiative has phases defined.
+ *
+ * Used by wu:create --initiative to warn when linking WUs to
+ * initiatives without phases.
+ *
+ * @param initiative - Initiative document to check
+ * @returns Check result with warning if no phases
+ *
+ * @example
+ * const result = checkInitiativePhases(initiative);
+ * if (!result.hasPhases) {
+ *   console.warn(result.warning);
+ * }
+ */
+export function checkInitiativePhases(initiative) {
+    const hasPhases = Array.isArray(initiative.phases) && initiative.phases.length > 0;
+    const id = initiative.id || 'unknown';
+    return {
+        hasPhases,
+        warning: hasPhases
+            ? null
+            : `Initiative ${id} has no phases defined. Consider adding phases before linking WUs.`,
+    };
+}
+/**
+ * Determines if an initiative status should progress based on WU activity.
+ *
+ * Auto-progression rules:
+ * - draft -> in_progress: when first WU is claimed (status: in_progress)
+ * - open -> in_progress: when first WU is claimed (status: in_progress)
+ *
+ * Terminal statuses (done, archived) never progress.
+ *
+ * @param initiative - Initiative document to check
+ * @param wus - Array of WUs (all WUs, filtering is done internally)
+ * @returns Check result with new status if progression is needed
+ *
+ * @example
+ * const result = shouldProgressInitiativeStatus(initiative, allWUs);
+ * if (result.shouldProgress) {
+ *   initiative.status = result.newStatus;
+ *   // Save initiative
+ * }
+ */
+export function shouldProgressInitiativeStatus(initiative, wus) {
+    const currentStatus = initiative.status || 'draft';
+    const initiativeId = initiative.id;
+    // Terminal statuses cannot progress
+    if (!PROGRESSABLE_STATUSES.includes(currentStatus)) {
+        return {
+            shouldProgress: false,
+            newStatus: null,
+        };
+    }
+    // Filter WUs belonging to this initiative
+    const initiativeWUs = wus.filter((wu) => wu.initiative === initiativeId);
+    // Check if any WU is actively being worked on
+    const hasActiveWU = initiativeWUs.some((wu) => ACTIVE_WU_STATUSES.includes(wu.status || ''));
+    if (hasActiveWU) {
+        return {
+            shouldProgress: true,
+            newStatus: 'in_progress',
+        };
+    }
+    return {
+        shouldProgress: false,
+        newStatus: null,
+    };
+}
+/**
+ * Finds incomplete initiatives for state:doctor reporting.
+ *
+ * @param initiatives - Array of initiative documents
+ * @returns Array of incomplete initiative reports
+ */
+export function findIncompleteInitiatives(initiatives) {
+    const incompleteList = [];
+    for (const init of initiatives) {
+        const result = validateInitiativeCompleteness(init);
+        if (result.warnings.length > 0) {
+            incompleteList.push({
+                id: init.id || 'unknown',
+                warnings: result.warnings,
+            });
+        }
+    }
+    return incompleteList;
+}

package/dist/initiative-validator.d.ts

@@ -8,8 +8,8 @@
  * WU-2319: Added bidirectional validation for WU<->Initiative references.
  * WU-1088: detectCycles moved to @lumenflow/core to break circular dependency.
  *
- * @see {@link tools/validate.mjs} - Consumer (CI validation)
- * @see {@link tools/lib/initiative-schema.mjs} - Initiative schema
+ * @see {@link packages/@lumenflow/cli/src/validate.ts} - Consumer (CI validation)
+ * @see {@link packages/@lumenflow/cli/src/lib/initiative-schema.ts} - Initiative schema
  */
 import { detectCycles, type WUObject, type CycleResult } from '@lumenflow/core';
 export { detectCycles, type WUObject, type CycleResult };

package/dist/initiative-validator.js

@@ -8,8 +8,8 @@
  * WU-2319: Added bidirectional validation for WU<->Initiative references.
  * WU-1088: detectCycles moved to @lumenflow/core to break circular dependency.
  *
- * @see {@link tools/validate.mjs} - Consumer (CI validation)
- * @see {@link tools/lib/initiative-schema.mjs} - Initiative schema
+ * @see {@link packages/@lumenflow/cli/src/validate.ts} - Consumer (CI validation)
+ * @see {@link packages/@lumenflow/cli/src/lib/initiative-schema.ts} - Initiative schema
  */
 // WU-1088: Import detectCycles from @lumenflow/core to break circular dependency
 import { detectCycles } from '@lumenflow/core';

package/dist/initiative-yaml.d.ts

@@ -43,7 +43,7 @@ export interface InitiativeEntry {
 /**
  * Initiative YAML I/O module.
  *
- * Mirrors wu-yaml.mjs pattern. Provides validated read/write operations
+ * Mirrors wu-yaml.ts pattern. Provides validated read/write operations
  * for Initiative YAML files.
  *
  * @example

package/dist/initiative-yaml.js

@@ -11,7 +11,7 @@ import { WU_PATHS } from '@lumenflow/core/dist/wu-paths.js';
 /**
  * Initiative YAML I/O module.
  *
- * Mirrors wu-yaml.mjs pattern. Provides validated read/write operations
+ * Mirrors wu-yaml.ts pattern. Provides validated read/write operations
  * for Initiative YAML files.
  *
  * @example

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lumenflow/initiatives",
-  "version": "2.2.2",
+  "version": "2.3.2",
   "description": "Initiative tracking for LumenFlow workflow framework - multi-phase project coordination",
   "keywords": [
     "lumenflow",
@@ -41,7 +41,7 @@
   "dependencies": {
     "yaml": "^2.8.2",
     "zod": "^4.3.5",
-    "@lumenflow/core": "2.2.2"
+    "@lumenflow/core": "2.3.2"
   },
   "devDependencies": {
     "@vitest/coverage-v8": "^4.0.17",