@lumenflow/core 1.0.0

package/dist/wu-validation.js

@@ -0,0 +1,243 @@
+/**
+ * WU Exposure Validation (WU-1999, WU-2022)
+ *
+ * WU-1999: Validates exposure field and UI pairing for wu:done.
+ *          Provides warnings (not errors) to guide completion without blocking.
+ *
+ * WU-2022: Adds BLOCKING validation for feature accessibility.
+ *          When exposure=ui, ensures the feature is actually accessible via navigation.
+ *
+ * Part of INIT-031 Phase 4: Prevent backend-without-UI pattern.
+ *
+ * @see {@link tools/wu-done.mjs} - Consumer
+ * @see {@link tools/lib/wu-schema.mjs} - WU schema with exposure field
+ * @see {@link tools/lib/wu-constants.mjs} - WU_EXPOSURE values
+ */
+import { WU_EXPOSURE } from './wu-constants.js';
+/**
+ * UI verification keywords to search for in acceptance criteria.
+ * Case-insensitive patterns that indicate the acceptance criteria
+ * mentions UI verification.
+ */
+const UI_VERIFICATION_KEYWORDS = [
+    'ui',
+    'frontend',
+    'component',
+    'widget',
+    'page',
+    'displays',
+    'shows',
+    'renders',
+    'user sees',
+    'visible',
+    'screen',
+    'interface',
+];
+/**
+ * Warning message templates with remediation guidance.
+ * All messages include the WU ID for context.
+ */
+export const EXPOSURE_WARNING_MESSAGES = {
+    /**
+     * Warning when exposure field is missing entirely.
+     * @param {string} wuId - The WU identifier
+     * @returns {string} Warning message with remediation
+     */
+    MISSING_EXPOSURE: (wuId) => `${wuId}: exposure field is missing. ` +
+        `Add 'exposure: ui|api|backend-only|documentation' to the WU YAML. ` +
+        `This helps ensure user-facing features have corresponding UI coverage.`,
+    /**
+     * Warning when API exposure lacks UI pairing WUs.
+     * @param {string} wuId - The WU identifier
+     * @returns {string} Warning message with remediation
+     */
+    MISSING_UI_PAIRING: (wuId) => `${wuId}: exposure=api but ui_pairing_wus not specified. ` +
+        `Add 'ui_pairing_wus: [WU-XXX]' listing UI WUs that consume this API, ` +
+        `or set exposure to 'backend-only' if no UI is planned.`,
+    /**
+     * Warning when API exposure lacks UI verification in acceptance criteria.
+     * @param {string} wuId - The WU identifier
+     * @returns {string} Warning message with remediation
+     */
+    MISSING_UI_VERIFICATION: (wuId) => `${wuId}: exposure=api but acceptance criteria lacks UI verification mention. ` +
+        `Consider adding a criterion like 'UI displays the data correctly' to ensure end-to-end coverage.`,
+    /**
+     * Recommendation for user_journey when exposure is UI.
+     * @param {string} wuId - The WU identifier
+     * @returns {string} Warning message with remediation
+     */
+    MISSING_USER_JOURNEY: (wuId) => `${wuId}: exposure=ui but user_journey field not present. ` +
+        `Adding 'user_journey: "<description>"' is recommended to document the user flow.`,
+};
+/**
+ * Check if acceptance criteria mentions UI verification.
+ *
+ * Searches acceptance criteria (array or nested object) for keywords
+ * that indicate UI verification is mentioned.
+ *
+ * @param {string[]|Record<string, string[]>} acceptance - Acceptance criteria
+ * @returns {boolean} True if UI verification is mentioned
+ */
+function hasUIVerificationInAcceptance(acceptance) {
+    // Flatten acceptance to array of strings
+    let criteria = [];
+    if (Array.isArray(acceptance)) {
+        criteria = acceptance;
+    }
+    else if (typeof acceptance === 'object' && acceptance !== null) {
+        // Nested object format: { category: [items] }
+        criteria = Object.values(acceptance).flat();
+    }
+    // Search for UI-related keywords (case-insensitive)
+    const lowerCriteria = criteria.map((c) => (typeof c === 'string' ? c.toLowerCase() : ''));
+    return lowerCriteria.some((criterion) => UI_VERIFICATION_KEYWORDS.some((keyword) => criterion.includes(keyword.toLowerCase())));
+}
+export function validateExposure(wu, options = {}) {
+    const warnings = [];
+    // Early return if skip flag is set
+    if (options.skipExposureCheck) {
+        return { valid: true, warnings: [] };
+    }
+    const wuId = wu.id || 'WU-???';
+    const exposure = wu.exposure;
+    // Check 1: exposure field presence
+    if (!exposure) {
+        warnings.push(EXPOSURE_WARNING_MESSAGES.MISSING_EXPOSURE(wuId));
+        // Can't check further without exposure
+        return { valid: true, warnings };
+    }
+    // Check 2 & 3: API exposure checks
+    if (exposure === WU_EXPOSURE.API) {
+        // Check for ui_pairing_wus
+        const uiPairingWus = wu.ui_pairing_wus;
+        if (!uiPairingWus || uiPairingWus.length === 0) {
+            warnings.push(EXPOSURE_WARNING_MESSAGES.MISSING_UI_PAIRING(wuId));
+        }
+        // Check acceptance criteria for UI verification mention
+        const acceptance = wu.acceptance;
+        if (acceptance && !hasUIVerificationInAcceptance(acceptance)) {
+            warnings.push(EXPOSURE_WARNING_MESSAGES.MISSING_UI_VERIFICATION(wuId));
+        }
+    }
+    // Check 4: UI exposure checks
+    if (exposure === WU_EXPOSURE.UI) {
+        // Recommend user_journey if not present
+        if (!wu.user_journey) {
+            warnings.push(EXPOSURE_WARNING_MESSAGES.MISSING_USER_JOURNEY(wuId));
+        }
+    }
+    // backend-only and documentation exposures: no additional checks
+    return { valid: true, warnings };
+}
+// =============================================================================
+// WU-2022: Feature Accessibility Validation (BLOCKING)
+// =============================================================================
+/**
+ * Navigation keywords to search for in tests.manual.
+ * Case-insensitive patterns that indicate manual navigation testing.
+ */
+const NAVIGATION_KEYWORDS = [
+    'navigate',
+    'navigation',
+    'accessible',
+    'access',
+    'visible',
+    'reachable',
+    'go to',
+    'visit',
+    'open',
+    'click',
+    'link',
+    'route',
+    'url',
+    'path',
+    '/space',
+    '/dashboard',
+    '/settings',
+];
+/**
+ * Pattern to detect Next.js page files in code_paths.
+ * Matches: app/.../page.tsx, pages/.../index.tsx, pages/.../*.tsx
+ */
+const PAGE_FILE_PATTERNS = [
+    /app\/.*\/page\.tsx$/,
+    /app\/.*\/page\.ts$/,
+    /pages\/.*\.tsx$/,
+    /pages\/.*\.ts$/,
+];
+/**
+ * Error message templates for accessibility validation (WU-2022).
+ * These are BLOCKING errors, not warnings.
+ */
+export const ACCESSIBILITY_ERROR_MESSAGES = {
+    /**
+     * Error when UI exposure lacks navigation accessibility proof.
+     * @param {string} wuId - The WU identifier
+     * @returns {string} Error message with remediation guidance
+     */
+    UI_NOT_ACCESSIBLE: (wuId) => `${wuId}: exposure=ui but feature accessibility not verified. ` +
+        `Add one of the following:\n` +
+        `  1. navigation_path: '/your-route' - specify the route where feature is accessible\n` +
+        `  2. code_paths: [..., 'apps/web/src/app/.../page.tsx'] - include a page file\n` +
+        `  3. tests.manual: ['Navigate to /path and verify feature is accessible'] - add navigation test\n\n` +
+        `This prevents "orphaned code" - features that exist but users cannot access. ` +
+        `Use --skip-accessibility-check to bypass (not recommended).`,
+};
+/**
+ * Check if code_paths includes a page file (Next.js page).
+ *
+ * @param {string[]} codePaths - Array of code paths
+ * @returns {boolean} True if any code path matches a page file pattern
+ */
+function hasPageFileInCodePaths(codePaths) {
+    if (!codePaths || !Array.isArray(codePaths)) {
+        return false;
+    }
+    return codePaths.some((codePath) => PAGE_FILE_PATTERNS.some((pattern) => pattern.test(codePath)));
+}
+/**
+ * Check if tests.manual includes navigation verification.
+ *
+ * @param {object} tests - Tests object from WU YAML
+ * @returns {boolean} True if manual tests mention navigation
+ */
+function hasNavigationInManualTests(tests) {
+    if (!tests || typeof tests !== 'object') {
+        return false;
+    }
+    const manualTests = tests.manual;
+    if (!manualTests || !Array.isArray(manualTests)) {
+        return false;
+    }
+    const lowerTests = manualTests.map((t) => (typeof t === 'string' ? t.toLowerCase() : ''));
+    return lowerTests.some((test) => NAVIGATION_KEYWORDS.some((keyword) => test.includes(keyword.toLowerCase())));
+}
+export function validateFeatureAccessibility(wu, options = {}) {
+    const errors = [];
+    // Early return if skip flag is set
+    if (options.skipAccessibilityCheck) {
+        return { valid: true, errors: [] };
+    }
+    const exposure = wu.exposure;
+    // Skip validation for non-UI exposures
+    if (!exposure || exposure !== WU_EXPOSURE.UI) {
+        return { valid: true, errors: [] };
+    }
+    // For exposure=ui, verify accessibility via one of three methods
+    const wuId = wu.id || 'WU-???';
+    // Method 1: navigation_path is specified
+    if (wu.navigation_path && wu.navigation_path.trim().length > 0) {
+        return { valid: true, errors: [] };
+    }
+    // Method 2: code_paths includes a page file
+    if (hasPageFileInCodePaths(wu.code_paths)) {
+        return { valid: true, errors: [] };
+    }
+    // Method 3: tests.manual includes navigation verification
+    if (hasNavigationInManualTests(wu.tests)) {
+        return { valid: true, errors: [] };
+    }
+    // No accessibility proof found - this is a blocking error
+    errors.push(ACCESSIBILITY_ERROR_MESSAGES.UI_NOT_ACCESSIBLE(wuId));
+    return { valid: false, errors };
+}

package/dist/wu-validator.d.ts

@@ -0,0 +1,62 @@
+#!/usr/bin/env node
+/**
+ * WU Validator - Enforces code quality rules from Definition of Done
+ *
+ * Validates WU completion requirements:
+ * - No TODO/FIXME/HACK/XXX comments in production code
+ * - No Mock/Stub/Fake classes in production code
+ * - Excludes test files from scans
+ * - Excludes markdown files from TODO scans (documentation prose)
+ *
+ * Used by wu:done before creating stamp.
+ */
+/**
+ * Check if a file path is a test file
+ * @param {string} filePath - Path to check
+ * @returns {boolean} True if file is a test file
+ */
+export declare function isTestFile(filePath: any): boolean;
+/**
+ * Check if a file path is a markdown file
+ * @param {string} filePath - Path to check
+ * @returns {boolean} True if file is a markdown file
+ */
+export declare function isMarkdownFile(filePath: any): boolean;
+/**
+ * Scan a file for TODO/FIXME/HACK/XXX comments
+ * @param {string} filePath - Path to file to scan
+ * @returns {{found: boolean, matches: Array<{line: number, text: string, pattern: string}>}}
+ */
+export declare function scanFileForTODOs(filePath: any): {
+    found: boolean;
+    matches: any[];
+};
+/**
+ * Scan a file for Mock/Stub/Fake class/function names
+ * @param {string} filePath - Path to file to scan
+ * @returns {{found: boolean, matches: Array<{line: number, text: string, type: string}>}}
+ */
+export declare function scanFileForMocks(filePath: any): {
+    found: boolean;
+    matches: any[];
+};
+/**
+ * Options for validating WU code paths
+ */
+export interface ValidateWUCodePathsOptions {
+    /** Allow TODO comments (with warning) */
+    allowTodos?: boolean;
+    /** Optional worktree path to validate files from */
+    worktreePath?: string | null;
+}
+/**
+ * Validate all code paths for a WU
+ * @param {Array<string>} codePaths - Array of file/directory paths from WU YAML
+ * @param {ValidateWUCodePathsOptions} options - Validation options
+ * @returns {{valid: boolean, errors: Array<string>, warnings: Array<string>}}
+ */
+export declare function validateWUCodePaths(codePaths: any, options?: ValidateWUCodePathsOptions): {
+    valid: boolean;
+    errors: any[];
+    warnings: any[];
+};

package/dist/wu-validator.js

@@ -0,0 +1,325 @@
+#!/usr/bin/env node
+/**
+ * WU Validator - Enforces code quality rules from Definition of Done
+ *
+ * Validates WU completion requirements:
+ * - No TODO/FIXME/HACK/XXX comments in production code
+ * - No Mock/Stub/Fake classes in production code
+ * - Excludes test files from scans
+ * - Excludes markdown files from TODO scans (documentation prose)
+ *
+ * Used by wu:done before creating stamp.
+ */
+import { readFileSync, existsSync } from 'node:fs';
+import path from 'node:path';
+import { execSync } from 'node:child_process';
+import { STDIO } from './wu-constants.js';
+/**
+ * Check if a file path is a test file
+ * @param {string} filePath - Path to check
+ * @returns {boolean} True if file is a test file
+ */
+export function isTestFile(filePath) {
+    const normalized = filePath.replace(/\\/g, '/');
+    // Test file patterns
+    const testPatterns = [
+        /\.test\.(ts|tsx|js|jsx|mjs)$/,
+        /\.spec\.(ts|tsx|js|jsx|mjs)$/,
+        /__tests__\//,
+        /\.test-utils\./,
+        /\.mock\./,
+    ];
+    return testPatterns.some((pattern) => pattern.test(normalized));
+}
+/**
+ * Check if a file path is a markdown file
+ * @param {string} filePath - Path to check
+ * @returns {boolean} True if file is a markdown file
+ */
+export function isMarkdownFile(filePath) {
+    const normalized = filePath.replace(/\\/g, '/');
+    return /\.md$/i.test(normalized);
+}
+/**
+ * Scan a file for TODO/FIXME/HACK/XXX comments
+ * @param {string} filePath - Path to file to scan
+ * @returns {{found: boolean, matches: Array<{line: number, text: string, pattern: string}>}}
+ */
+export function scanFileForTODOs(filePath) {
+    if (!existsSync(filePath)) {
+        return { found: false, matches: [] };
+    }
+    // Skip test files
+    if (isTestFile(filePath)) {
+        return { found: false, matches: [] };
+    }
+    // Skip markdown files (documentation prose often mentions TODO in workflow explanations)
+    if (isMarkdownFile(filePath)) {
+        return { found: false, matches: [] };
+    }
+    try {
+        const content = readFileSync(filePath, { encoding: 'utf-8' });
+        const lines = content.split(/\r?\n/);
+        const matches = [];
+        // Match TODO/FIXME/HACK/XXX as actionable markers in comments
+        // Covers: // TODO:, /* TODO */, * TODO, <!-- TODO -->, # TODO, @todo, etc.
+        //
+        // WU-1807: Tightened detection to prevent false positives:
+        // - Only matches markers at the START of comment text (after comment symbol)
+        // - Excludes slash-separated keyword lists like "TODO/FIXME/HACK" (documentation)
+        // - Excludes WU-XXX placeholders (not an XXX marker)
+        // - Excludes keywords appearing mid-sentence in prose
+        //
+        // Pattern explanation:
+        // - Comment start: ^[\s]*(\/\/|\/\*+|\*|<!--|#)[\s]* captures comment prefixes
+        // - Keyword at start: TODO/FIXME/HACK/XXX immediately after comment start
+        // - Or @-prefixed: @todo, @fixme, @hack, @xxx anywhere in comment
+        /**
+         * Check if a line contains an actionable TODO/FIXME/HACK/XXX marker
+         * @param {string} line - Line to check
+         * @returns {{found: boolean, pattern: string|null}} Match result
+         */
+        const checkForActionableMarker = (line) => {
+            const trimmed = line.trim();
+            // Skip lines that are documentation about the patterns themselves
+            // These contain keywords as examples, not actionable markers
+            if (trimmed.includes('// TODO:,') || trimmed.includes('/* TODO */')) {
+                return { found: false, pattern: null };
+            }
+            if (trimmed.includes('@todo,') || trimmed.includes('@-prefixed:')) {
+                return { found: false, pattern: null };
+            }
+            // Pattern 1: @-prefixed tags at start of JSDoc comment line
+            // Matches: * @todo Implement this
+            // Does NOT match: // mentions @todo in documentation
+            const atTagMatch = trimmed.match(/^\*\s+@(todo|fixme|hack|xxx)\b/i);
+            if (atTagMatch) {
+                return { found: true, pattern: atTagMatch[1].toUpperCase() };
+            }
+            // Pattern 2: Keyword at start of comment content
+            // Matches: // TODO:, /* TODO, * TODO, # TODO, <!-- TODO
+            // Does NOT match: // mentions TODO in workflow, // TODO/FIXME/HACK list
+            const commentStartMatch = trimmed.match(/^(?:\/\/|\/\*+|\*|<!--|#)\s*(TODO|FIXME|HACK|XXX)(?::|[\s]|$)/i);
+            if (commentStartMatch) {
+                // Check it is not followed by / (slash-separated list)
+                const afterKeyword = trimmed.slice(trimmed.indexOf(commentStartMatch[1]) + commentStartMatch[1].length);
+                if (!afterKeyword.startsWith('/')) {
+                    return { found: true, pattern: commentStartMatch[1].toUpperCase() };
+                }
+            }
+            // Pattern 3: Keyword in inline comment after code
+            // Matches: someCode(); // TODO: fix this
+            // Does NOT match: someCode(); // mentions TODO in prose
+            // Does NOT match: error('// TODO'); (// inside string literal)
+            const inlineCommentMatch = line.match(/\/\/\s*(TODO|FIXME|HACK|XXX)(?::|[\s]|$)/i);
+            if (inlineCommentMatch && !line.match(/\/\/\s*(TODO|FIXME|HACK|XXX)\//i)) {
+                // Verify the // is not inside a string literal
+                const doubleSlashIndex = line.indexOf('//');
+                const beforeSlash = line.slice(0, doubleSlashIndex);
+                // Count unescaped quotes - if odd number, we're inside a string
+                const singleQuotes = (beforeSlash.match(/(?<!\\)'/g) || []).length;
+                const doubleQuotes = (beforeSlash.match(/(?<!\\)"/g) || []).length;
+                const backticks = (beforeSlash.match(/(?<!\\)`/g) || []).length;
+                if (singleQuotes % 2 !== 0 || doubleQuotes % 2 !== 0 || backticks % 2 !== 0) {
+                    // The // is inside a string literal, not a real comment
+                    return { found: false, pattern: null };
+                }
+                // Verify the keyword is right after // (not buried in prose)
+                const commentPart = line.slice(doubleSlashIndex);
+                const keywordIndex = commentPart.search(/\b(TODO|FIXME|HACK|XXX)\b/i);
+                // Only flag if keyword appears within first 10 chars of comment
+                if (keywordIndex >= 0 && keywordIndex <= 10) {
+                    return { found: true, pattern: inlineCommentMatch[1].toUpperCase() };
+                }
+            }
+            // Pattern 4: Special check for XXX - must not be preceded by WU-
+            // This is handled by patterns above, but add explicit WU-XXX exclusion
+            if (trimmed.match(/\bWU-XXX\b/i)) {
+                return { found: false, pattern: null };
+            }
+            return { found: false, pattern: null };
+        };
+        lines.forEach((line, index) => {
+            const lineNumber = index + 1;
+            const trimmed = line.trim();
+            // Check if line contains a comment marker
+            const isComment = /^(\/\/|\/\*|\*|<!--|#)/.test(trimmed) || line.includes('//') || line.includes('/*');
+            if (isComment) {
+                const result = checkForActionableMarker(line);
+                if (result.found) {
+                    matches.push({
+                        line: lineNumber,
+                        text: trimmed,
+                        pattern: result.pattern,
+                    });
+                }
+            }
+        });
+        return {
+            found: matches.length > 0,
+            matches,
+        };
+    }
+    catch {
+        // If file can't be read, skip it
+        return { found: false, matches: [] };
+    }
+}
+/**
+ * Scan a file for Mock/Stub/Fake class/function names
+ * @param {string} filePath - Path to file to scan
+ * @returns {{found: boolean, matches: Array<{line: number, text: string, type: string}>}}
+ */
+export function scanFileForMocks(filePath) {
+    if (!existsSync(filePath)) {
+        return { found: false, matches: [] };
+    }
+    // Skip test files
+    if (isTestFile(filePath)) {
+        return { found: false, matches: [] };
+    }
+    try {
+        const content = readFileSync(filePath, { encoding: 'utf-8' });
+        const lines = content.split(/\r?\n/);
+        const matches = [];
+        // Match Mock/Stub/Fake/Placeholder in class/function/const names
+        const mockPatterns = [
+            // Classes: class MockService, export class StubAdapter
+            { name: 'Mock', regex: /\b(class|export\s+class)\s+(\w*Mock\w*)/i },
+            { name: 'Stub', regex: /\b(class|export\s+class)\s+(\w*Stub\w*)/i },
+            { name: 'Fake', regex: /\b(class|export\s+class)\s+(\w*Fake\w*)/i },
+            { name: 'Placeholder', regex: /\b(class|export\s+class)\s+(\w*Placeholder\w*)/i },
+            // Functions: function mockService, const stubAdapter =
+            { name: 'Mock', regex: /\b(function|const|let|var)\s+(\w*mock\w*)/i },
+            { name: 'Stub', regex: /\b(function|const|let|var)\s+(\w*stub\w*)/i },
+            { name: 'Fake', regex: /\b(function|const|let|var)\s+(\w*fake\w*)/i },
+            { name: 'Placeholder', regex: /\b(function|const|let|var)\s+(\w*placeholder\w*)/i },
+        ];
+        lines.forEach((line, index) => {
+            const lineNumber = index + 1;
+            mockPatterns.forEach(({ name, regex }) => {
+                const match = regex.exec(line);
+                if (match) {
+                    matches.push({
+                        line: lineNumber,
+                        text: line.trim(),
+                        type: name,
+                    });
+                }
+            });
+        });
+        return {
+            found: matches.length > 0,
+            matches,
+        };
+    }
+    catch {
+        // If file can't be read, skip it
+        return { found: false, matches: [] };
+    }
+}
+/**
+ * Get the repo root directory
+ * @returns {string} Absolute path to repo root
+ */
+function getRepoRoot() {
+    try {
+        return execSync('git rev-parse --show-toplevel', {
+            encoding: 'utf-8',
+            stdio: [STDIO.PIPE, STDIO.PIPE, STDIO.IGNORE],
+        }).trim();
+    }
+    catch {
+        return process.cwd();
+    }
+}
+/**
+ * Validate all code paths for a WU
+ * @param {Array<string>} codePaths - Array of file/directory paths from WU YAML
+ * @param {ValidateWUCodePathsOptions} options - Validation options
+ * @returns {{valid: boolean, errors: Array<string>, warnings: Array<string>}}
+ */
+export function validateWUCodePaths(codePaths, options = {}) {
+    const { allowTodos = false, worktreePath = null } = options;
+    const errors = [];
+    const warnings = [];
+    const repoRoot = worktreePath || getRepoRoot();
+    if (!codePaths || codePaths.length === 0) {
+        return { valid: true, errors, warnings };
+    }
+    const todoFindings = [];
+    const mockFindings = [];
+    // Scan each code path
+    for (const codePath of codePaths) {
+        const absolutePath = path.join(repoRoot, codePath);
+        if (!existsSync(absolutePath)) {
+            errors.push(`\n❌ Code path validation failed: File does not exist: ${codePath}\n\n` +
+                `This indicates the WU claims to have created/modified a file that doesn't exist.\n` +
+                `Either create the file, or remove it from code_paths in the WU YAML.\n`);
+            continue;
+        }
+        // Scan for TODOs
+        const todoResult = scanFileForTODOs(absolutePath);
+        if (todoResult.found) {
+            todoFindings.push({ path: codePath, ...todoResult });
+        }
+        // Scan for Mocks
+        const mockResult = scanFileForMocks(absolutePath);
+        if (mockResult.found) {
+            mockFindings.push({ path: codePath, ...mockResult });
+        }
+    }
+    // Report TODO findings
+    if (todoFindings.length > 0) {
+        const message = formatTODOFindings(todoFindings);
+        if (allowTodos) {
+            warnings.push(message);
+        }
+        else {
+            errors.push(message);
+        }
+    }
+    // Report Mock findings (always warnings, not errors)
+    if (mockFindings.length > 0) {
+        warnings.push(formatMockFindings(mockFindings));
+    }
+    return {
+        valid: errors.length === 0,
+        errors,
+        warnings,
+    };
+}
+/**
+ * Format TODO findings for display
+ * @param {Array} findings - TODO findings
+ * @returns {string} Formatted message
+ */
+function formatTODOFindings(findings) {
+    let msg = '\n❌ TODO/FIXME/HACK/XXX comments found in production code:\n';
+    findings.forEach(({ path, matches }) => {
+        msg += `\n  ${path}:\n`;
+        matches.forEach(({ line, text }) => {
+            msg += `    Line ${line}: ${text}\n`;
+        });
+    });
+    msg += '\nThese indicate incomplete work and must be resolved before WU completion.';
+    msg += '\nEither complete the work or use --allow-todo with justification in WU notes.';
+    return msg;
+}
+/**
+ * Format Mock findings for display
+ * @param {Array} findings - Mock findings
+ * @returns {string} Formatted message
+ */
+function formatMockFindings(findings) {
+    let msg = '\n⚠️  Mock/Stub/Fake/Placeholder classes found in production code:\n';
+    findings.forEach(({ path, matches }) => {
+        msg += `\n  ${path}:\n`;
+        matches.forEach(({ line, text }) => {
+            msg += `    Line ${line}: ${text}\n`;
+        });
+    });
+    msg += '\nThese suggest incomplete implementation (interface ≠ implementation).';
+    msg += '\nVerify these are actual implementations, not placeholder code.';
+    return msg;
+}