@lumenflow/cli 1.1.0 → 1.3.0

package/dist/wu-create.js

@@ -40,7 +40,7 @@ import { inferSubLane } from '@lumenflow/core/dist/lane-inference.js';
 import { parseBacklogFrontmatter } from '@lumenflow/core/dist/backlog-parser.js';
 import { createWUParser, WU_OPTIONS } from '@lumenflow/core/dist/arg-parser.js';
 import { WU_PATHS } from '@lumenflow/core/dist/wu-paths.js';
-import { PLACEHOLDER_SENTINEL, validateReadyWU } from '@lumenflow/core/dist/wu-schema.js';
+import { validateWU } from '@lumenflow/core/dist/wu-schema.js';
 import { COMMIT_FORMATS, FILE_SYSTEM, STRING_LITERALS, READINESS_UI, } from '@lumenflow/core/dist/wu-constants.js';
 // WU-1593: Use centralized validateWUIDFormat (DRY)
 import { ensureOnMain, validateWUIDFormat } from '@lumenflow/core/dist/wu-helpers.js';
@@ -52,6 +52,8 @@ import { validateSpecCompleteness } from '@lumenflow/core/dist/wu-done-validator
 import { readWU } from '@lumenflow/core/dist/wu-yaml.js';
 // WU-2253: Import WU spec linter for acceptance/code_paths validation
 import { lintWUSpec, formatLintErrors } from '@lumenflow/core/dist/wu-lint.js';
+// WU-1025: Import placeholder validator for inline content validation
+import { validateNoPlaceholders, buildPlaceholderErrorMessage, } from '@lumenflow/core/dist/wu-validator.js';
 /** Log prefix for console output */
 const LOG_PREFIX = '[wu:create]';
 /** Micro-worktree operation name */
@@ -175,67 +177,29 @@ function displayReadinessSummary(id) {
         console.warn(`${LOG_PREFIX} ⚠️  Could not validate readiness: ${err.message}`);
     }
 }
-/**
- * Create WU YAML file in micro-worktree
- *
- * @param {string} worktreePath - Path to micro-worktree
- * @param {string} id - WU ID
- * @param {string} lane - WU lane
- * @param {string} title - WU title
- * @param {string} priority - WU priority
- * @param {string} type - WU type
- * @param {Object} opts - Additional options
- * @returns {string} Relative path to created YAML file
- */
-function createWUYamlInWorktree(worktreePath, id, lane, title, priority, type, opts = {}) {
-    const wuRelativePath = WU_PATHS.WU(id);
-    const wuAbsolutePath = join(worktreePath, wuRelativePath);
-    const wuDir = join(worktreePath, WU_PATHS.WU_DIR());
-    mkdirSync(wuDir, { recursive: true });
-    // WU-1428: Use todayISO() for consistent YYYY-MM-DD format (library-first)
-    const today = todayISO();
-    // Parse initiative system fields from opts (WU-1247) and assigned_to (WU-1368)
-    const { initiative, phase, blockedBy, blocks, labels, assignedTo } = opts;
-    // WU-1364: Parse full spec inline options
-    const { description: inlineDescription, acceptance: inlineAcceptance, codePaths, testPathsManual, testPathsUnit, testPathsE2e, } = opts;
-    // WU-1998: Parse exposure field options
-    const { exposure, userJourney, uiPairingWus } = opts;
-    // WU-2320: Parse spec_refs option
-    const { specRefs } = opts;
-    // Helper to parse comma-separated strings into arrays (DRY)
-    const parseCommaSeparated = (value) => value
-        ? value
-            .split(',')
-            .map((s) => s.trim())
-            .filter(Boolean)
-        : [];
-    // WU-1364: Build description (inline or placeholder)
-    const description = inlineDescription
-        ? inlineDescription
-        : `${PLACEHOLDER_SENTINEL} Describe the work to be done.\n\nContext: ...\nProblem: ...\nSolution: ...\n`;
-    // WU-1364: Build acceptance (inline array or placeholder)
-    const acceptance = inlineAcceptance && inlineAcceptance.length > 0
-        ? inlineAcceptance
-        : [
-            `${PLACEHOLDER_SENTINEL} Define acceptance criteria`,
-            'pnpm format, lint, typecheck → PASS',
-        ];
-    // WU-1364: Build code_paths from inline flag
+// Helper to parse comma-separated strings into arrays (DRY)
+const parseCommaSeparated = (value) => value
+    ? value
+        .split(',')
+        .map((s) => s.trim())
+        .filter(Boolean)
+    : [];
+function buildWUContent({ id, lane, title, priority, type, created, opts, }) {
+    const { description, acceptance, codePaths, testPathsManual, testPathsUnit, testPathsE2e, initiative, phase, blockedBy, blocks, labels, assignedTo, exposure, userJourney, uiPairingWus, specRefs, } = opts;
     const code_paths = parseCommaSeparated(codePaths);
-    // WU-1364: Build tests object from inline flags
     const tests = {
         manual: parseCommaSeparated(testPathsManual),
         unit: parseCommaSeparated(testPathsUnit),
         e2e: parseCommaSeparated(testPathsE2e),
     };
-    const wuContent = {
+    return {
         id,
         title,
         lane,
         type,
         status: 'ready',
         priority,
-        created: today,
+        created,
         description,
         acceptance,
         code_paths,
@@ -245,24 +209,107 @@ function createWUYamlInWorktree(worktreePath, id, lane, title, priority, type, o
         risks: [],
         notes: '',
         requires_review: false,
-        // Initiative system fields - only include if provided (WU-1247)
         ...(initiative && { initiative }),
         ...(phase && { phase: parseInt(phase, 10) }),
         ...(blockedBy && { blocked_by: blockedBy.split(',').map((s) => s.trim()) }),
         ...(blocks && { blocks: blocks.split(',').map((s) => s.trim()) }),
         ...(labels && { labels: labels.split(',').map((s) => s.trim()) }),
-        // WU-1368: Default assigned_to from git config user.email
         ...(assignedTo && { assigned_to: assignedTo }),
-        // WU-1998: Exposure field options - only include if provided
         ...(exposure && { exposure }),
         ...(userJourney && { user_journey: userJourney }),
         ...(uiPairingWus && { ui_pairing_wus: parseCommaSeparated(uiPairingWus) }),
-        // WU-2320: Spec references - only include if provided
         ...(specRefs && { spec_refs: parseCommaSeparated(specRefs) }),
     };
-    // WU-1539: Validate WU structure before writing (fail-fast, allows placeholders)
+}
+export function validateCreateSpec({ id, lane, title, priority, type, opts, }) {
+    const errors = [];
+    const effectiveType = type || DEFAULT_TYPE;
+    if (!opts.description) {
+        errors.push('--description is required');
+    }
+    if (!opts.acceptance || opts.acceptance.length === 0) {
+        errors.push('--acceptance is required (repeatable)');
+    }
+    if (!opts.exposure) {
+        errors.push('--exposure is required');
+    }
+    const hasTestPaths = opts.testPathsManual || opts.testPathsUnit || opts.testPathsE2e;
+    if (effectiveType !== 'documentation' && effectiveType !== 'process') {
+        if (!opts.codePaths) {
+            errors.push('--code-paths is required for non-documentation WUs');
+        }
+        if (!hasTestPaths) {
+            errors.push('At least one test path flag is required (--test-paths-manual, --test-paths-unit, or --test-paths-e2e)');
+        }
+    }
+    if (effectiveType === 'feature' && !opts.specRefs) {
+        errors.push('--spec-refs is required for type: feature WUs');
+    }
+    if (errors.length > 0) {
+        return { valid: false, errors };
+    }
+    const placeholderResult = validateNoPlaceholders({
+        description: opts.description,
+        acceptance: opts.acceptance,
+    });
+    if (!placeholderResult.valid) {
+        return {
+            valid: false,
+            errors: [buildPlaceholderErrorMessage('wu:create', placeholderResult)],
+        };
+    }
+    const today = todayISO();
+    const wuContent = buildWUContent({
+        id,
+        lane,
+        title,
+        priority,
+        type: effectiveType,
+        created: today,
+        opts,
+    });
+    const schemaResult = validateWU(wuContent);
+    if (!schemaResult.success) {
+        const schemaErrors = schemaResult.error.issues.map((issue) => `${issue.path.join('.')}: ${issue.message}`);
+        return { valid: false, errors: schemaErrors };
+    }
+    const completeness = validateSpecCompleteness(wuContent, id);
+    if (!completeness.valid) {
+        return { valid: false, errors: completeness.errors };
+    }
+    return { valid: true, errors: [] };
+}
+/**
+ * Create WU YAML file in micro-worktree
+ *
+ * @param {string} worktreePath - Path to micro-worktree
+ * @param {string} id - WU ID
+ * @param {string} lane - WU lane
+ * @param {string} title - WU title
+ * @param {string} priority - WU priority
+ * @param {string} type - WU type
+ * @param {Object} opts - Additional options
+ * @returns {string} Relative path to created YAML file
+ */
+function createWUYamlInWorktree(worktreePath, id, lane, title, priority, type, opts = {}) {
+    const wuRelativePath = WU_PATHS.WU(id);
+    const wuAbsolutePath = join(worktreePath, wuRelativePath);
+    const wuDir = join(worktreePath, WU_PATHS.WU_DIR());
+    mkdirSync(wuDir, { recursive: true });
+    // WU-1428: Use todayISO() for consistent YYYY-MM-DD format (library-first)
+    const today = todayISO();
+    const wuContent = buildWUContent({
+        id,
+        lane,
+        title,
+        priority,
+        type,
+        created: today,
+        opts,
+    });
+    // WU-1539: Validate WU structure before writing (fail-fast, no placeholders)
     // WU-1750: Zod transforms normalize embedded newlines in arrays and strings
-    const validationResult = validateReadyWU(wuContent);
+    const validationResult = validateWU(wuContent);
     if (!validationResult.success) {
         const errors = validationResult.error.issues
             .map((issue) => `  • ${issue.path.join('.')}: ${issue.message}`)
@@ -270,6 +317,14 @@ function createWUYamlInWorktree(worktreePath, id, lane, title, priority, type, o
         die(`${LOG_PREFIX} ❌ WU YAML validation failed:\n\n${errors}\n\n` +
             `Fix the issues above and retry.`);
     }
+    const completenessResult = validateSpecCompleteness(wuContent, id);
+    if (!completenessResult.valid) {
+        const errorList = completenessResult.errors
+            .map((error) => `  • ${error}`)
+            .join(STRING_LITERALS.NEWLINE);
+        die(`${LOG_PREFIX} ❌ WU SPEC INCOMPLETE:\n\n${errorList}\n\n` +
+            `Provide the missing fields and retry.`);
+    }
     // WU-2253: Validate acceptance/code_paths consistency and invariants compliance
     // This blocks WU creation if acceptance references paths not in code_paths
     // or if code_paths conflicts with tools/invariants.yml
@@ -429,76 +484,95 @@ async function main() {
     if (!assignedTo) {
         console.warn(`${LOG_PREFIX} ⚠️  No assigned_to set - WU will need manual assignment`);
     }
-    // WU-1364: Validate spec completeness when --validate is set
-    if (args.validate) {
-        const validationErrors = [];
-        if (!args.description) {
-            validationErrors.push('--description is required when --validate is set');
-        }
-        // acceptance is an array from repeatable flag (empty array if not provided)
-        if (!args.acceptance || args.acceptance.length === 0) {
-            validationErrors.push('--acceptance is required when --validate is set (use multiple times)');
-        }
-        const hasTestPaths = args.testPathsManual || args.testPathsUnit || args.testPathsE2e;
-        if (!hasTestPaths) {
-            validationErrors.push('--validate requires at least one test path flag (--test-paths-manual, --test-paths-unit, or --test-paths-e2e)');
-        }
-        // WU-2320: spec_refs required for feature WUs (type defaults to feature)
-        const effectiveType = args.type || DEFAULT_TYPE;
-        if (effectiveType === 'feature' && !args.specRefs) {
-            validationErrors.push('--spec-refs is required for type: feature WUs (link to plan file in docs/04-operations/plans/)');
-        }
-        if (validationErrors.length > 0) {
-            const errorList = validationErrors.map((e) => `  • ${e}`).join(STRING_LITERALS.NEWLINE);
-            die(`Spec validation failed:\n\n${errorList}\n\nTo create without validation, omit the --validate flag.`);
-        }
-        console.log(`${LOG_PREFIX} ✅ Spec validation passed`);
+    const createSpecValidation = validateCreateSpec({
+        id: args.id,
+        lane: args.lane,
+        title: args.title,
+        priority: args.priority || DEFAULT_PRIORITY,
+        type: args.type || DEFAULT_TYPE,
+        opts: {
+            description: args.description,
+            acceptance: args.acceptance,
+            codePaths: args.codePaths,
+            testPathsManual: args.testPathsManual,
+            testPathsUnit: args.testPathsUnit,
+            testPathsE2e: args.testPathsE2e,
+            exposure: args.exposure,
+            userJourney: args.userJourney,
+            uiPairingWus: args.uiPairingWus,
+            specRefs: args.specRefs,
+            initiative: args.initiative,
+            phase: args.phase,
+            blockedBy: args.blockedBy,
+            blocks: args.blocks,
+            labels: args.labels,
+            assignedTo,
+        },
+    });
+    if (!createSpecValidation.valid) {
+        const errorList = createSpecValidation.errors
+            .map((error) => `  • ${error}`)
+            .join(STRING_LITERALS.NEWLINE);
+        die(`${LOG_PREFIX} ❌ Spec validation failed:\n\n${errorList}`);
     }
+    console.log(`${LOG_PREFIX} ✅ Spec validation passed`);
     // Transaction: micro-worktree isolation (WU-1439)
     try {
         const priority = args.priority || DEFAULT_PRIORITY;
         const type = args.type || DEFAULT_TYPE;
-        await withMicroWorktree({
-            operation: OPERATION_NAME,
-            id: args.id,
-            logPrefix: LOG_PREFIX,
-            execute: async ({ worktreePath }) => {
-                // Create WU YAML in micro-worktree
-                const wuPath = createWUYamlInWorktree(worktreePath, args.id, args.lane, args.title, priority, type, {
-                    // Initiative system fields (WU-1247)
-                    initiative: args.initiative,
-                    phase: args.phase,
-                    blockedBy: args.blockedBy,
-                    blocks: args.blocks,
-                    labels: args.labels,
-                    // WU-1368: Assigned to
-                    assignedTo,
-                    // WU-1364: Full spec inline options
-                    description: args.description,
-                    acceptance: args.acceptance,
-                    codePaths: args.codePaths,
-                    testPathsManual: args.testPathsManual,
-                    testPathsUnit: args.testPathsUnit,
-                    testPathsE2e: args.testPathsE2e,
-                    // WU-1998: Exposure field options
-                    exposure: args.exposure,
-                    userJourney: args.userJourney,
-                    uiPairingWus: args.uiPairingWus,
-                    // WU-2320: Spec references
-                    specRefs: args.specRefs,
-                });
-                // Update backlog.md in micro-worktree
-                const backlogPath = updateBacklogInWorktree(worktreePath, args.id, args.lane, args.title);
-                // Build commit message
-                const shortTitle = truncateTitle(args.title);
-                const commitMessage = COMMIT_FORMATS.CREATE(args.id, shortTitle);
-                // Return commit message and files to commit
-                return {
-                    commitMessage,
-                    files: [wuPath, backlogPath],
-                };
-            },
-        });
+        const previousWuTool = process.env.LUMENFLOW_WU_TOOL;
+        process.env.LUMENFLOW_WU_TOOL = OPERATION_NAME;
+        try {
+            await withMicroWorktree({
+                operation: OPERATION_NAME,
+                id: args.id,
+                logPrefix: LOG_PREFIX,
+                execute: async ({ worktreePath }) => {
+                    // Create WU YAML in micro-worktree
+                    const wuPath = createWUYamlInWorktree(worktreePath, args.id, args.lane, args.title, priority, type, {
+                        // Initiative system fields (WU-1247)
+                        initiative: args.initiative,
+                        phase: args.phase,
+                        blockedBy: args.blockedBy,
+                        blocks: args.blocks,
+                        labels: args.labels,
+                        // WU-1368: Assigned to
+                        assignedTo,
+                        // WU-1364: Full spec inline options
+                        description: args.description,
+                        acceptance: args.acceptance,
+                        codePaths: args.codePaths,
+                        testPathsManual: args.testPathsManual,
+                        testPathsUnit: args.testPathsUnit,
+                        testPathsE2e: args.testPathsE2e,
+                        // WU-1998: Exposure field options
+                        exposure: args.exposure,
+                        userJourney: args.userJourney,
+                        uiPairingWus: args.uiPairingWus,
+                        // WU-2320: Spec references
+                        specRefs: args.specRefs,
+                    });
+                    // Update backlog.md in micro-worktree
+                    const backlogPath = updateBacklogInWorktree(worktreePath, args.id, args.lane, args.title);
+                    // Build commit message
+                    const shortTitle = truncateTitle(args.title);
+                    const commitMessage = COMMIT_FORMATS.CREATE(args.id, shortTitle);
+                    // Return commit message and files to commit
+                    return {
+                        commitMessage,
+                        files: [wuPath, backlogPath],
+                    };
+                },
+            });
+        }
+        finally {
+            if (previousWuTool === undefined) {
+                delete process.env.LUMENFLOW_WU_TOOL;
+            }
+            else {
+                process.env.LUMENFLOW_WU_TOOL = previousWuTool;
+            }
+        }
         console.log(`\n${LOG_PREFIX} ✅ Transaction complete!`);
         console.log(`\nWU ${args.id} created successfully:`);
         console.log(`  File: ${WU_PATHS.WU(args.id)}`);

package/dist/wu-done.js

@@ -147,7 +147,7 @@ async function validateClaimMetadataBeforeGates(id, worktreePath, yamlStatus) {
         `  pnpm wu:repair-claim --id ${id}\n\n` +
         `After repair, retry:\n` +
         `  pnpm wu:done --id ${id}\n\n` +
-        `See: ai/onboarding/troubleshooting-wu-done.md for more recovery options.`);
+        `See: docs/04-operations/_frameworks/lumenflow/agent/onboarding/troubleshooting-wu-done.md for more recovery options.`);
 }
 export function printExposureWarnings(wu, options = {}) {
     // Validate exposure
@@ -1793,7 +1793,8 @@ async function executeGates({ id, args, isBranchOnly, isDocsOnly, worktreePath,
     }
     else {
         die(`Worktree not found (${worktreePath || 'unknown'}). Gates must run in the lane worktree.\n` +
-            `If the worktree was removed, recreate it and retry, or use --skip-gates with justification.`);
+            `If the worktree was removed, recreate it and retry, or rerun with --branch-only when the lane branch exists.\n` +
+            `Use --skip-gates only with justification.`);
     }
     // Step 0.75: Run COS governance gates (WU-614, COS v1.3 §7)
     if (!args.skipCosGates) {
@@ -1858,6 +1859,13 @@ async function executeGates({ id, args, isBranchOnly, isDocsOnly, worktreePath,
  * @param {string|null} params.derivedWorktree - Derived worktree path
  * @param {string} params.STAMPS_DIR - Stamps directory path
  */
+export function computeBranchOnlyFallback({ isBranchOnly, branchOnlyRequested, worktreeExists, derivedWorktree, }) {
+    const allowFallback = Boolean(branchOnlyRequested) && !isBranchOnly && !worktreeExists && Boolean(derivedWorktree);
+    return {
+        allowFallback,
+        effectiveBranchOnly: isBranchOnly || allowFallback,
+    };
+}
 function printStateHUD({ id, docMain, isBranchOnly, isDocsOnly, derivedWorktree, STAMPS_DIR }) {
     const stampExists = existsSync(path.join(STAMPS_DIR, `${id}.done`)) ? 'yes' : 'no';
     const yamlStatus = docMain.status || 'unknown';
@@ -1869,6 +1877,8 @@ function printStateHUD({ id, docMain, isBranchOnly, isDocsOnly, derivedWorktree,
 }
 // eslint-disable-next-line sonarjs/cognitive-complexity -- Pre-existing complexity, refactor tracked separately
 async function main() {
+    // Allow pre-push hook to recognize wu:done automation (WU-1030)
+    process.env.LUMENFLOW_WU_TOOL = 'wu-done';
     // Validate CLI arguments and WU ID format (extracted to wu-done-validators.mjs)
     const { args, id } = validateInputs(process.argv);
     // Detect workspace mode and calculate paths (WU-1215: extracted to validators module)
@@ -1876,25 +1886,39 @@ async function main() {
     const { WU_PATH, STATUS_PATH, BACKLOG_PATH, STAMPS_DIR, docMain, isBranchOnly, derivedWorktree, docForValidation: initialDocForValidation, isDocsOnly, } = pathInfo;
     // Capture main checkout path once. process.cwd() may drift later during recovery flows.
     const mainCheckoutPath = process.cwd();
+    // Resolve worktree path early so we can detect missing worktree before pre-flight checks
+    const resolvedWorktreePath = derivedWorktree && !isBranchOnly
+        ? path.isAbsolute(derivedWorktree)
+            ? derivedWorktree
+            : path.resolve(mainCheckoutPath, derivedWorktree)
+        : null;
+    const worktreeExists = resolvedWorktreePath ? existsSync(resolvedWorktreePath) : false;
+    const { allowFallback: allowBranchOnlyFallback, effectiveBranchOnly } = computeBranchOnlyFallback({
+        isBranchOnly,
+        branchOnlyRequested: args.branchOnly,
+        worktreeExists,
+        derivedWorktree,
+    });
+    if (allowBranchOnlyFallback) {
+        console.warn(`${LOG_PREFIX.DONE} ${EMOJI.WARNING} Worktree missing (${resolvedWorktreePath}). Proceeding in branch-only mode because --branch-only was provided.`);
+    }
+    const effectiveDerivedWorktree = effectiveBranchOnly ? null : derivedWorktree;
+    const effectiveWorktreePath = effectiveBranchOnly ? null : resolvedWorktreePath;
     // Pre-flight checks (WU-1215: extracted to executePreFlightChecks function)
     const preFlightResult = await executePreFlightChecks({
         id,
         args,
-        isBranchOnly,
+        isBranchOnly: effectiveBranchOnly,
         isDocsOnly,
         docMain,
         docForValidation: initialDocForValidation,
-        derivedWorktree,
+        derivedWorktree: effectiveDerivedWorktree,
     });
     const title = preFlightResult.title;
     // Note: docForValidation is returned but not used after pre-flight checks
     // The metadata transaction uses docForUpdate instead
     // Step 0: Run gates (WU-1215: extracted to executeGates function)
-    const worktreePath = derivedWorktree && !isBranchOnly
-        ? path.isAbsolute(derivedWorktree)
-            ? derivedWorktree
-            : path.resolve(mainCheckoutPath, derivedWorktree)
-        : null;
+    const worktreePath = effectiveWorktreePath;
     // WU-1943: Check if any checkpoints exist for this WU session
     // Warn (don't block) if no checkpoints - agent should have been checkpointing periodically
     try {
@@ -1908,9 +1932,16 @@ async function main() {
     catch {
         // Non-blocking: checkpoint check failure should not block wu:done
     }
-    await executeGates({ id, args, isBranchOnly, isDocsOnly, worktreePath });
+    await executeGates({ id, args, isBranchOnly: effectiveBranchOnly, isDocsOnly, worktreePath });
     // Print State HUD for visibility (WU-1215: extracted to printStateHUD function)
-    printStateHUD({ id, docMain, isBranchOnly, isDocsOnly, derivedWorktree, STAMPS_DIR });
+    printStateHUD({
+        id,
+        docMain,
+        isBranchOnly: effectiveBranchOnly,
+        isDocsOnly,
+        derivedWorktree: effectiveDerivedWorktree,
+        STAMPS_DIR,
+    });
     // Step 0.5: Pre-flight validation - run ALL pre-commit hooks BEFORE merge
     // This prevents partial completion states where merge succeeds but commit fails
     // Validates all 8 gates: secrets, file size, ESLint, Prettier, TypeScript, audit, architecture, tasks
@@ -1947,7 +1978,7 @@ async function main() {
             validateStagedFiles,
         };
         try {
-            if (isBranchOnly) {
+            if (effectiveBranchOnly) {
                 // Branch-Only mode: merge first, then update metadata on main
                 // NOTE: Branch-only still uses old rollback mechanism
                 const branchOnlyContext = {
@@ -2165,7 +2196,7 @@ async function detectChangedDocPaths(worktreePath, baseBranch) {
         // Get files changed in this branch vs base
         const diff = await git.raw(['diff', '--name-only', baseBranch]);
         const changedFiles = diff.split('\n').filter(Boolean);
-        // Filter to docs: ai/onboarding/, docs/, CLAUDE.md, README.md, *.md in root
+        // Filter to docs: docs/04-operations/_frameworks/lumenflow/agent/onboarding/, docs/, CLAUDE.md, README.md, *.md in root
         const docPatterns = [
             /^ai\/onboarding\//,
             /^docs\//,