@lumenflow/core 2.1.2 → 2.2.1

package/dist/system-map-validator.js

@@ -11,6 +11,9 @@
  *
  * @module system-map-validator
  */
+import { existsSync, readFileSync } from 'node:fs';
+import fg from 'fast-glob';
+import { parseYAML } from './wu-yaml.js';
 /**
  * Canonical list of valid audience tags as defined in SYSTEM-MAP.yaml header
  * @type {string[]}
@@ -270,3 +273,50 @@ export async function validateSystemMap(systemMap, deps) {
         classificationErrors,
     };
 }
+const DEFAULT_SYSTEM_MAP_PATH = 'SYSTEM-MAP.yaml';
+function emitErrors(label, errors) {
+    if (!errors || errors.length === 0)
+        return;
+    console.error(`\n${label}:`);
+    for (const error of errors) {
+        console.error(`  - ${error}`);
+    }
+}
+async function runCLI() {
+    const systemMapPath = process.env.SYSTEM_MAP_PATH || DEFAULT_SYSTEM_MAP_PATH;
+    if (!existsSync(systemMapPath)) {
+        console.warn(`[system-map] ${systemMapPath} not found; skipping validation.`);
+        process.exit(0);
+    }
+    let systemMap;
+    try {
+        const raw = readFileSync(systemMapPath, 'utf-8');
+        systemMap = parseYAML(raw);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.error(`[system-map] Failed to read or parse ${systemMapPath}: ${message}`);
+        process.exit(1);
+    }
+    const result = await validateSystemMap(systemMap, {
+        exists: (path) => existsSync(path),
+        glob: (pattern) => fg(pattern, { dot: false }),
+    });
+    if (!result.valid) {
+        console.error('\n[system-map] Validation failed');
+        emitErrors('Missing paths', result.pathErrors);
+        emitErrors('Orphan docs', result.orphanDocs);
+        emitErrors('Invalid audiences', result.audienceErrors);
+        emitErrors('Invalid quick queries', result.queryErrors);
+        emitErrors('Classification routing violations', result.classificationErrors);
+        process.exit(1);
+    }
+    console.log('[system-map] Validation passed');
+    process.exit(0);
+}
+if (import.meta.main) {
+    runCLI().catch((error) => {
+        console.error('[system-map] Validation failed:', error);
+        process.exit(1);
+    });
+}

package/dist/wu-constants.d.ts

@@ -1186,6 +1186,8 @@ export declare const AUDIT_ARGS: {
  * Centralized paths to validation scripts.
  */
 export declare const SCRIPT_PATHS: {
+    /** Gates runner */
+    GATES: string;
     /** WU YAML validation */
     VALIDATE: string;
     /** Prompt registry validation */

package/dist/wu-constants.js

@@ -12,6 +12,8 @@
  * @see {@link tools/lib/wu-schema.mjs} - PLACEHOLDER_SENTINEL (already centralized)
  */
 import path from 'node:path';
+import { existsSync } from 'node:fs';
+import { createRequire } from 'node:module';
 import { kebabCase } from 'change-case';
 /**
  * Git branch names
@@ -1000,16 +1002,63 @@ export const GATE_COMMANDS = {
     /** WU-2062: Triggers tiered test execution based on risk */
     TIERED_TEST: 'tiered-test',
 };
+const require = createRequire(import.meta.url);
+const NOOP_NODE_COMMAND = 'node -e "process.exit(0)"';
+function resolveNodeModulePath(modulePath) {
+    try {
+        return require.resolve(modulePath);
+    }
+    catch {
+        return null;
+    }
+}
+function resolveRepoPath(relativePath, requireExists = false) {
+    const candidate = path.join(process.cwd(), relativePath);
+    if (requireExists && !existsSync(candidate)) {
+        return null;
+    }
+    return candidate;
+}
+function buildNodeCommand({ modulePath, repoPath, allowMissing = false, repoPathRequiresExistence = false, }) {
+    const resolved = modulePath ? resolveNodeModulePath(modulePath) : null;
+    if (resolved) {
+        return `node ${resolved}`;
+    }
+    const fallback = repoPath ? resolveRepoPath(repoPath, repoPathRequiresExistence) : null;
+    if (fallback) {
+        return `node ${fallback}`;
+    }
+    if (allowMissing) {
+        return NOOP_NODE_COMMAND;
+    }
+    if (repoPath) {
+        return `node ${resolveRepoPath(repoPath)}`;
+    }
+    if (modulePath) {
+        return `node ${modulePath}`;
+    }
+    return NOOP_NODE_COMMAND;
+}
 /**
  * Tool paths for scripts
  *
  * Centralized paths to tool scripts.
  */
 export const TOOL_PATHS = {
-    VALIDATE_BACKLOG_SYNC: 'node tools/validate-backlog-sync.js',
-    SUPABASE_DOCS_LINTER: 'node packages/linters/supabase-docs-linter.js',
+    VALIDATE_BACKLOG_SYNC: buildNodeCommand({
+        modulePath: '@lumenflow/cli/dist/validate-backlog-sync.js',
+        repoPath: 'packages/@lumenflow/cli/dist/validate-backlog-sync.js',
+    }),
+    SUPABASE_DOCS_LINTER: buildNodeCommand({
+        repoPath: 'packages/linters/supabase-docs-linter.js',
+        allowMissing: true,
+        repoPathRequiresExistence: true,
+    }),
     /** WU-2315: System map validator script */
-    SYSTEM_MAP_VALIDATE: 'node tools/system-map-validate.js',
+    SYSTEM_MAP_VALIDATE: buildNodeCommand({
+        modulePath: '@lumenflow/core/dist/system-map-validator.js',
+        repoPath: 'packages/@lumenflow/core/dist/system-map-validator.js',
+    }),
 };
 /**
  * CLI mode flags
@@ -1229,8 +1278,16 @@ export const AUDIT_ARGS = {
  * Centralized paths to validation scripts.
  */
 export const SCRIPT_PATHS = {
+    /** Gates runner */
+    GATES: buildNodeCommand({
+        modulePath: '@lumenflow/cli/dist/gates.js',
+        repoPath: 'packages/@lumenflow/cli/dist/gates.js',
+    }),
     /** WU YAML validation */
-    VALIDATE: 'tools/validate.js',
+    VALIDATE: buildNodeCommand({
+        modulePath: '@lumenflow/cli/dist/validate.js',
+        repoPath: 'packages/@lumenflow/cli/dist/validate.js',
+    }),
     /** Prompt registry validation */
     VALIDATE_PROMPT_REGISTRY: 'tools/validate-prompt-registry.js',
 };

package/dist/wu-done-concurrent-merge.d.ts

@@ -0,0 +1,102 @@
+/**
+ * WU-1145: Concurrent backlog merge utilities
+ *
+ * This module provides utilities for merging state stores from worktree
+ * and main branches to prevent loss of concurrent WU completions.
+ *
+ * Problem: When wu:done regenerates backlog.md, it only uses the worktree's
+ * state store, losing any WUs that were completed on main since the worktree
+ * was created.
+ *
+ * Solution: Before regenerating backlog.md, merge events from both state
+ * stores using event deduplication by identity (type, wuId, timestamp).
+ */
+import { WUStateStore } from './wu-state-store.js';
+/**
+ * Fetch wu-events.jsonl content from origin/main using git show.
+ *
+ * This allows us to read the state from main without switching branches
+ * or having access to the main checkout directory.
+ *
+ * @returns Events content from origin/main, or null if not available
+ */
+export declare function fetchMainEventsContent(): Promise<string | null>;
+/**
+ * Merge state stores from worktree and main.
+ *
+ * This creates a new WUStateStore instance that contains the merged
+ * state from both sources, preserving all concurrent modifications.
+ *
+ * @param worktreeStateDir - Path to worktree's .lumenflow/state directory
+ * @param mainStateDir - Path to main's .lumenflow/state directory
+ * @returns A WUStateStore with merged state
+ */
+export declare function mergeStateStores(worktreeStateDir: string, mainStateDir: string): Promise<WUStateStore>;
+/**
+ * Compute backlog content with merged state from worktree and main.
+ *
+ * This is a drop-in replacement for computeBacklogContent that handles
+ * concurrent modifications by merging state stores before generation.
+ *
+ * @param backlogPath - Path to backlog.md in the worktree
+ * @param wuId - WU ID being completed
+ * @param title - WU title
+ * @param mainStateDir - Path to main's .lumenflow/state directory
+ * @returns Merged backlog.md content
+ */
+export declare function computeBacklogContentWithMerge(backlogPath: string, wuId: string, title: string, mainStateDir: string): Promise<string>;
+/**
+ * Get the merged events content for wu-events.jsonl
+ *
+ * This returns the content that should be written to wu-events.jsonl
+ * after merging worktree and main state stores.
+ *
+ * @param worktreeStateDir - Path to worktree's .lumenflow/state directory
+ * @param mainStateDir - Path to main's .lumenflow/state directory
+ * @param wuId - WU ID being completed (to add complete event)
+ * @returns JSONL content for the merged events file
+ */
+export declare function getMergedEventsContent(worktreeStateDir: string, mainStateDir: string, wuId: string): Promise<string>;
+/**
+ * Merge worktree state with origin/main state using git show.
+ *
+ * This function:
+ * 1. Fetches the wu-events.jsonl content from origin/main using git show
+ * 2. Parses events from both worktree and main
+ * 3. Merges them with deduplication
+ * 4. Returns a store with the merged state
+ *
+ * This is the integration point for wu:done to preserve concurrent changes.
+ *
+ * @param worktreeStateDir - Path to worktree's .lumenflow/state directory
+ * @returns A WUStateStore with merged state, or just worktree state if main unavailable
+ */
+export declare function mergeWithMainState(worktreeStateDir: string): Promise<WUStateStore>;
+/**
+ * Compute backlog content with merged state from origin/main.
+ *
+ * This is the main integration function for wu:done. It:
+ * 1. Loads the worktree's state
+ * 2. Fetches and merges state from origin/main
+ * 3. Applies the complete event for the WU being done
+ * 4. Generates backlog from the merged state
+ *
+ * @param backlogPath - Path to backlog.md in the worktree
+ * @param wuId - WU ID being completed
+ * @returns Merged backlog.md content
+ */
+export declare function computeBacklogContentWithMainMerge(backlogPath: string, wuId: string): Promise<string>;
+/**
+ * Compute wu-events.jsonl content with merged state from origin/main.
+ *
+ * Returns the JSONL content that should be written to wu-events.jsonl,
+ * containing merged events from both worktree and main, plus the completion event.
+ *
+ * @param backlogPath - Path to backlog.md in the worktree
+ * @param wuId - WU ID being completed
+ * @returns Object with events path and merged content, or null if no update needed
+ */
+export declare function computeWUEventsContentWithMainMerge(backlogPath: string, wuId: string): Promise<{
+    eventsPath: string;
+    content: string;
+} | null>;

package/dist/wu-done-concurrent-merge.js

@@ -0,0 +1,330 @@
+/**
+ * WU-1145: Concurrent backlog merge utilities
+ *
+ * This module provides utilities for merging state stores from worktree
+ * and main branches to prevent loss of concurrent WU completions.
+ *
+ * Problem: When wu:done regenerates backlog.md, it only uses the worktree's
+ * state store, losing any WUs that were completed on main since the worktree
+ * was created.
+ *
+ * Solution: Before regenerating backlog.md, merge events from both state
+ * stores using event deduplication by identity (type, wuId, timestamp).
+ */
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { WUStateStore, WU_EVENTS_FILE_NAME } from './wu-state-store.js';
+import { validateWUEvent } from './wu-state-schema.js';
+import { generateBacklog } from './backlog-generator.js';
+import { getStateStoreDirFromBacklog } from './wu-paths.js';
+import { getGitForCwd } from './git-adapter.js';
+import { REMOTES, BRANCHES, BEACON_PATHS } from './wu-constants.js';
+/**
+ * Creates a unique key for an event to detect duplicates.
+ * Events are considered identical if they have the same type, wuId, and timestamp.
+ */
+function getEventKey(event) {
+    return `${event.type}:${event.wuId}:${event.timestamp}`;
+}
+/**
+ * Fetch wu-events.jsonl content from origin/main using git show.
+ *
+ * This allows us to read the state from main without switching branches
+ * or having access to the main checkout directory.
+ *
+ * @returns Events content from origin/main, or null if not available
+ */
+export async function fetchMainEventsContent() {
+    try {
+        const git = getGitForCwd();
+        // First, fetch to ensure we have the latest main
+        try {
+            await git.fetch(REMOTES.ORIGIN, BRANCHES.MAIN);
+        }
+        catch {
+            // If fetch fails (e.g., offline), continue with cached version
+            console.warn('[wu-done] Warning: Could not fetch latest main, using cached version');
+        }
+        // Try to read wu-events.jsonl from origin/main
+        const eventsPath = `${BEACON_PATHS.STATE_DIR}/${WU_EVENTS_FILE_NAME}`;
+        const content = await git.raw(['show', `${REMOTES.ORIGIN}/${BRANCHES.MAIN}:${eventsPath}`]);
+        return content;
+    }
+    catch (error) {
+        // File may not exist on main (e.g., new repo or first WU)
+        // Or we may not be in a git repo
+        return null;
+    }
+}
+/**
+ * Parse wu-events.jsonl content into validated events
+ */
+function parseEventsFile(content, sourceLabel) {
+    const events = [];
+    const lines = content
+        .split('\n')
+        .map((line) => line.trim())
+        .filter(Boolean);
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        let parsed;
+        try {
+            parsed = JSON.parse(line);
+        }
+        catch (error) {
+            console.warn(`[wu-done] Warning: Malformed JSON in ${sourceLabel} line ${i + 1}, skipping`);
+            continue;
+        }
+        const validation = validateWUEvent(parsed);
+        if (!validation.success) {
+            console.warn(`[wu-done] Warning: Invalid event in ${sourceLabel} line ${i + 1}, skipping`);
+            continue;
+        }
+        events.push(validation.data);
+    }
+    return events;
+}
+/**
+ * Load events from a state directory
+ */
+function loadEventsFromDir(stateDir, label) {
+    const eventsPath = join(stateDir, WU_EVENTS_FILE_NAME);
+    if (!existsSync(eventsPath)) {
+        return [];
+    }
+    const content = readFileSync(eventsPath, { encoding: 'utf-8' });
+    return parseEventsFile(content, label);
+}
+/**
+ * Merge events from two sources, preserving order and deduplicating.
+ *
+ * The merge strategy:
+ * 1. Start with all events from main (the "base" timeline)
+ * 2. Add any events from worktree that aren't in main
+ *
+ * This ensures:
+ * - Concurrent completions on main are preserved
+ * - The worktree's claim/in_progress events are included
+ * - No duplicate events
+ */
+function mergeEvents(mainEvents, worktreeEvents) {
+    const seen = new Set();
+    const merged = [];
+    // First, add all main events
+    for (const event of mainEvents) {
+        const key = getEventKey(event);
+        if (!seen.has(key)) {
+            seen.add(key);
+            merged.push(event);
+        }
+    }
+    // Then add worktree events that aren't in main
+    for (const event of worktreeEvents) {
+        const key = getEventKey(event);
+        if (!seen.has(key)) {
+            seen.add(key);
+            merged.push(event);
+        }
+    }
+    // Sort by timestamp to ensure chronological order
+    merged.sort((a, b) => {
+        const timeA = new Date(a.timestamp).getTime();
+        const timeB = new Date(b.timestamp).getTime();
+        return timeA - timeB;
+    });
+    return merged;
+}
+/**
+ * Merge state stores from worktree and main.
+ *
+ * This creates a new WUStateStore instance that contains the merged
+ * state from both sources, preserving all concurrent modifications.
+ *
+ * @param worktreeStateDir - Path to worktree's .lumenflow/state directory
+ * @param mainStateDir - Path to main's .lumenflow/state directory
+ * @returns A WUStateStore with merged state
+ */
+export async function mergeStateStores(worktreeStateDir, mainStateDir) {
+    // Load events from both sources
+    const worktreeEvents = loadEventsFromDir(worktreeStateDir, 'worktree');
+    const mainEvents = loadEventsFromDir(mainStateDir, 'main');
+    // Merge events
+    const mergedEvents = mergeEvents(mainEvents, worktreeEvents);
+    // Create a new store and replay merged events
+    const store = new WUStateStore(worktreeStateDir);
+    for (const event of mergedEvents) {
+        store.applyEvent(event);
+    }
+    return store;
+}
+/**
+ * Compute backlog content with merged state from worktree and main.
+ *
+ * This is a drop-in replacement for computeBacklogContent that handles
+ * concurrent modifications by merging state stores before generation.
+ *
+ * @param backlogPath - Path to backlog.md in the worktree
+ * @param wuId - WU ID being completed
+ * @param title - WU title
+ * @param mainStateDir - Path to main's .lumenflow/state directory
+ * @returns Merged backlog.md content
+ */
+export async function computeBacklogContentWithMerge(backlogPath, wuId, title, mainStateDir) {
+    const worktreeStateDir = getStateStoreDirFromBacklog(backlogPath);
+    // Merge state stores
+    const mergedStore = await mergeStateStores(worktreeStateDir, mainStateDir);
+    // Check if the WU is already done in the merged state
+    const currentState = mergedStore.getWUState(wuId);
+    if (!currentState) {
+        throw new Error(`WU ${wuId} not found in merged state store`);
+    }
+    // If not already done, create and apply the complete event
+    if (currentState.status !== 'done') {
+        const completeEvent = mergedStore.createCompleteEvent(wuId);
+        mergedStore.applyEvent(completeEvent);
+    }
+    // Generate backlog from merged state
+    return generateBacklog(mergedStore);
+}
+/**
+ * Get the merged events content for wu-events.jsonl
+ *
+ * This returns the content that should be written to wu-events.jsonl
+ * after merging worktree and main state stores.
+ *
+ * @param worktreeStateDir - Path to worktree's .lumenflow/state directory
+ * @param mainStateDir - Path to main's .lumenflow/state directory
+ * @param wuId - WU ID being completed (to add complete event)
+ * @returns JSONL content for the merged events file
+ */
+export async function getMergedEventsContent(worktreeStateDir, mainStateDir, wuId) {
+    // Load events from both sources
+    const worktreeEvents = loadEventsFromDir(worktreeStateDir, 'worktree');
+    const mainEvents = loadEventsFromDir(mainStateDir, 'main');
+    // Merge events
+    const mergedEvents = mergeEvents(mainEvents, worktreeEvents);
+    // Check if we need to add a complete event
+    const lastEventForWU = [...mergedEvents].reverse().find((e) => e.wuId === wuId);
+    if (!lastEventForWU || lastEventForWU.type !== 'complete') {
+        // Create a temporary store to generate the complete event
+        const tempStore = new WUStateStore(worktreeStateDir);
+        for (const event of mergedEvents) {
+            tempStore.applyEvent(event);
+        }
+        const currentState = tempStore.getWUState(wuId);
+        if (currentState && currentState.status === 'in_progress') {
+            const completeEvent = tempStore.createCompleteEvent(wuId);
+            mergedEvents.push(completeEvent);
+        }
+    }
+    // Convert to JSONL
+    return mergedEvents.map((event) => JSON.stringify(event)).join('\n') + '\n';
+}
+/**
+ * Merge worktree state with origin/main state using git show.
+ *
+ * This function:
+ * 1. Fetches the wu-events.jsonl content from origin/main using git show
+ * 2. Parses events from both worktree and main
+ * 3. Merges them with deduplication
+ * 4. Returns a store with the merged state
+ *
+ * This is the integration point for wu:done to preserve concurrent changes.
+ *
+ * @param worktreeStateDir - Path to worktree's .lumenflow/state directory
+ * @returns A WUStateStore with merged state, or just worktree state if main unavailable
+ */
+export async function mergeWithMainState(worktreeStateDir) {
+    // Load worktree events
+    const worktreeEvents = loadEventsFromDir(worktreeStateDir, 'worktree');
+    // Try to fetch main events via git show
+    const mainContent = await fetchMainEventsContent();
+    const mainEvents = mainContent ? parseEventsFile(mainContent, 'origin/main') : [];
+    if (mainEvents.length > 0) {
+        console.log(`[wu-done] Merging state: ${worktreeEvents.length} worktree events + ${mainEvents.length} main events`);
+    }
+    // Merge events
+    const mergedEvents = mergeEvents(mainEvents, worktreeEvents);
+    // Create a new store and replay merged events
+    const store = new WUStateStore(worktreeStateDir);
+    for (const event of mergedEvents) {
+        store.applyEvent(event);
+    }
+    return store;
+}
+/**
+ * Compute backlog content with merged state from origin/main.
+ *
+ * This is the main integration function for wu:done. It:
+ * 1. Loads the worktree's state
+ * 2. Fetches and merges state from origin/main
+ * 3. Applies the complete event for the WU being done
+ * 4. Generates backlog from the merged state
+ *
+ * @param backlogPath - Path to backlog.md in the worktree
+ * @param wuId - WU ID being completed
+ * @returns Merged backlog.md content
+ */
+export async function computeBacklogContentWithMainMerge(backlogPath, wuId) {
+    const worktreeStateDir = getStateStoreDirFromBacklog(backlogPath);
+    // Merge with main state
+    const mergedStore = await mergeWithMainState(worktreeStateDir);
+    // Check if the WU exists in the merged state
+    const currentState = mergedStore.getWUState(wuId);
+    if (!currentState) {
+        throw new Error(`WU ${wuId} not found in merged state store. ` +
+            `This may indicate the WU was never properly claimed.`);
+    }
+    // If not already done, create and apply the complete event
+    if (currentState.status !== 'done') {
+        if (currentState.status !== 'in_progress') {
+            throw new Error(`WU ${wuId} is in status "${currentState.status}", expected "in_progress"`);
+        }
+        const completeEvent = mergedStore.createCompleteEvent(wuId);
+        mergedStore.applyEvent(completeEvent);
+    }
+    // Generate backlog from merged state
+    return generateBacklog(mergedStore);
+}
+/**
+ * Compute wu-events.jsonl content with merged state from origin/main.
+ *
+ * Returns the JSONL content that should be written to wu-events.jsonl,
+ * containing merged events from both worktree and main, plus the completion event.
+ *
+ * @param backlogPath - Path to backlog.md in the worktree
+ * @param wuId - WU ID being completed
+ * @returns Object with events path and merged content, or null if no update needed
+ */
+export async function computeWUEventsContentWithMainMerge(backlogPath, wuId) {
+    const worktreeStateDir = getStateStoreDirFromBacklog(backlogPath);
+    // Load worktree events
+    const worktreeEvents = loadEventsFromDir(worktreeStateDir, 'worktree');
+    // Try to fetch main events via git show
+    const mainContent = await fetchMainEventsContent();
+    const mainEvents = mainContent ? parseEventsFile(mainContent, 'origin/main') : [];
+    // Merge events
+    const mergedEvents = mergeEvents(mainEvents, worktreeEvents);
+    // Check if WU is already done
+    const tempStore = new WUStateStore(worktreeStateDir);
+    for (const event of mergedEvents) {
+        tempStore.applyEvent(event);
+    }
+    const currentState = tempStore.getWUState(wuId);
+    if (!currentState) {
+        throw new Error(`WU ${wuId} not found in merged state store`);
+    }
+    if (currentState.status === 'done') {
+        // Already done, no update needed
+        return null;
+    }
+    if (currentState.status !== 'in_progress') {
+        throw new Error(`WU ${wuId} is in status "${currentState.status}", expected "in_progress"`);
+    }
+    // Add complete event
+    const completeEvent = tempStore.createCompleteEvent(wuId);
+    mergedEvents.push(completeEvent);
+    const eventsPath = join(worktreeStateDir, WU_EVENTS_FILE_NAME);
+    const content = mergedEvents.map((event) => JSON.stringify(event)).join('\n') + '\n';
+    return { eventsPath, content };
+}

package/dist/wu-done-docs-generate.d.ts

@@ -42,6 +42,13 @@ export declare function stageDocOutputs(): Promise<void>;
  * @returns void
  */
 export declare function runDocsGenerate(repoRoot: string): void;
+/**
+ * Format generated doc output files with prettier.
+ *
+ * @param repoRoot - Repository root directory for running prettier
+ * @returns void
+ */
+export declare function formatDocOutputs(repoRoot: string): void;
 /**
  * Result of the docs regeneration check.
  */

package/dist/wu-done-docs-generate.js

@@ -9,7 +9,7 @@
  */
 import { execSync } from 'node:child_process';
 import { getGitForCwd } from './git-adapter.js';
-import { STDIO } from './wu-constants.js';
+import { STDIO, PKG_MANAGER, SCRIPTS, PRETTIER_FLAGS } from './wu-constants.js';
 /**
  * Pathspecs for files that affect generated documentation.
  * When any of these files change, docs:generate should be run.
@@ -80,6 +80,21 @@ export function runDocsGenerate(repoRoot) {
         encoding: 'utf-8',
     });
 }
+/**
+ * Format generated doc output files with prettier.
+ *
+ * @param repoRoot - Repository root directory for running prettier
+ * @returns void
+ */
+export function formatDocOutputs(repoRoot) {
+    const files = DOC_OUTPUT_FILES.map((file) => `"${file}"`).join(' ');
+    const prettierCmd = `${PKG_MANAGER} ${SCRIPTS.PRETTIER} ${PRETTIER_FLAGS.WRITE} ${files}`;
+    execSync(prettierCmd, {
+        cwd: repoRoot,
+        stdio: STDIO.INHERIT,
+        encoding: 'utf-8',
+    });
+}
 /**
  * Detect doc-source changes and regenerate docs if needed.
  * This is the main integration point for wu:done.
@@ -101,6 +116,8 @@ export async function maybeRegenerateAndStageDocs(options) {
     console.log('[wu:done] Doc-source changes detected, running turbo docs:generate...');
     // Run turbo docs:generate (Turbo handles caching and dependencies)
     runDocsGenerate(repoRoot);
+    // Format the generated doc outputs before staging
+    formatDocOutputs(repoRoot);
     // Stage the doc output files
     await stageDocOutputs();
     console.log('[wu:done] Documentation regenerated and staged');

package/dist/wu-done-preflight.js

@@ -2,9 +2,8 @@
  * Preflight validation helpers for wu:done.
  */
 import { execSync as execSyncImport } from 'node:child_process';
-import { existsSync } from 'node:fs';
 import { validatePreflight } from './wu-preflight-validators.js';
-import { LOG_PREFIX, EMOJI, STDIO } from './wu-constants.js';
+import { LOG_PREFIX, EMOJI, STDIO, SCRIPT_PATHS } from './wu-constants.js';
 /**
  * WU-1781: Build preflight error message with actionable guidance
  */
@@ -115,7 +114,7 @@ export function runPreflightTasksValidation(id, options = {}) {
     console.log(`\n${LOG_PREFIX.DONE} 🔍 Preflight: running tasks:validate...`);
     try {
         // Run tasks:validate with WU_ID context (single-WU validation mode)
-        execSyncFn('node tools/validate.js', {
+        execSyncFn(SCRIPT_PATHS.VALIDATE, {
             stdio: STDIO.PIPE,
             encoding: 'utf-8',
             env: { ...process.env, WU_ID: id },
@@ -165,14 +164,8 @@ export function validateAllPreCommitHooks(id, worktreePath = null, options = {})
         if (worktreePath) {
             execOptions.cwd = worktreePath;
         }
-        // WU-1086: Check for .mjs extension first, fall back to .js for backwards compatibility
-        const basePath = worktreePath || '.';
-        const mjsPath = `${basePath}/tools/gates-pre-commit.mjs`;
-        const gateScript = existsSync(mjsPath)
-            ? 'tools/gates-pre-commit.mjs'
-            : 'tools/gates-pre-commit.js';
-        // Run the gates-pre-commit script that contains all validation gates
-        execSyncFn(`node ${gateScript}`, execOptions);
+        // WU-1139: Run CLI gates directly (removes stub scripts)
+        execSyncFn(SCRIPT_PATHS.GATES, execOptions);
         console.log(`${LOG_PREFIX.DONE} ${EMOJI.SUCCESS} All pre-commit hooks passed`);
         return { valid: true, errors: [] };
     }