@lumenflow/core 2.5.0 → 2.6.0

package/dist/gates-config.d.ts

@@ -204,3 +204,75 @@ export interface TestPolicy extends CoverageConfig {
  * @returns Resolved test policy including tests_required
  */
 export declare function resolveTestPolicy(projectRoot: string): TestPolicy;
+/**
+ * WU-1356: Supported package managers type
+ * Re-exported from lumenflow-config-schema to avoid circular import
+ */
+type PackageManager = 'pnpm' | 'npm' | 'yarn' | 'bun';
+/**
+ * WU-1356: Supported test runners type
+ * Re-exported from lumenflow-config-schema to avoid circular import
+ */
+type TestRunner = 'vitest' | 'jest' | 'mocha';
+/**
+ * WU-1356: Gates commands configuration type
+ */
+export interface GatesCommands {
+    test_full: string;
+    test_docs_only: string;
+    test_incremental: string;
+    lint?: string;
+    typecheck?: string;
+    format?: string;
+}
+/**
+ * WU-1356: Resolve package manager from configuration
+ *
+ * Reads the package_manager field from .lumenflow.config.yaml.
+ * Returns 'pnpm' as default if not configured.
+ *
+ * @param projectRoot - Project root directory
+ * @returns Resolved package manager ('pnpm', 'npm', 'yarn', or 'bun')
+ */
+export declare function resolvePackageManager(projectRoot: string): PackageManager;
+/**
+ * WU-1356: Resolve test runner from configuration
+ *
+ * Reads the test_runner field from .lumenflow.config.yaml.
+ * Returns 'vitest' as default if not configured.
+ *
+ * @param projectRoot - Project root directory
+ * @returns Resolved test runner ('vitest', 'jest', or 'mocha')
+ */
+export declare function resolveTestRunner(projectRoot: string): TestRunner;
+/**
+ * WU-1356: Resolve build command from configuration
+ *
+ * Reads the build_command field from .lumenflow.config.yaml.
+ * If not configured, uses default based on package_manager.
+ *
+ * @param projectRoot - Project root directory
+ * @returns Resolved build command
+ */
+export declare function resolveBuildCommand(projectRoot: string): string;
+/**
+ * WU-1356: Resolve gates commands from configuration
+ *
+ * Reads gates.commands from .lumenflow.config.yaml.
+ * Merges with defaults based on package_manager if not fully specified.
+ *
+ * @param projectRoot - Project root directory
+ * @returns Resolved gates commands configuration
+ */
+export declare function resolveGatesCommands(projectRoot: string): GatesCommands;
+/**
+ * WU-1356: Get ignore patterns for test runner
+ *
+ * Returns patterns to ignore when detecting changed tests,
+ * based on the test runner configuration.
+ *
+ * @param testRunner - Test runner type (vitest, jest, mocha)
+ * @returns Array of ignore patterns
+ */
+export declare function getIgnorePatterns(testRunner: TestRunner): string[];
+export {};

package/dist/gates-config.js

@@ -453,3 +453,193 @@ export function resolveTestPolicy(projectRoot) {
         tests_required: policy.tests_required,
     };
 }
+/**
+ * WU-1356: Default gates commands by package manager
+ *
+ * Provides sensible defaults for different package manager and test runner combinations.
+ */
+const DEFAULT_GATES_COMMANDS = {
+    pnpm: {
+        test_full: 'pnpm turbo run test',
+        test_docs_only: '',
+        test_incremental: 'pnpm vitest run --changed origin/main',
+        lint: 'pnpm lint',
+        typecheck: 'pnpm typecheck',
+        format: 'pnpm format:check',
+    },
+    npm: {
+        test_full: 'npm test',
+        test_docs_only: '',
+        test_incremental: 'npm test -- --onlyChanged',
+        lint: 'npm run lint',
+        typecheck: 'npm run typecheck',
+        format: 'npm run format:check',
+    },
+    yarn: {
+        test_full: 'yarn test',
+        test_docs_only: '',
+        test_incremental: 'yarn test --onlyChanged',
+        lint: 'yarn lint',
+        typecheck: 'yarn typecheck',
+        format: 'yarn format:check',
+    },
+    bun: {
+        test_full: 'bun test',
+        test_docs_only: '',
+        test_incremental: 'bun test --changed',
+        lint: 'bun run lint',
+        typecheck: 'bun run typecheck',
+        format: 'bun run format:check',
+    },
+};
+/**
+ * WU-1356: Default build commands by package manager
+ */
+const DEFAULT_BUILD_COMMANDS = {
+    pnpm: 'pnpm --filter @lumenflow/cli build',
+    npm: 'npm run build --workspace @lumenflow/cli',
+    yarn: 'yarn workspace @lumenflow/cli build',
+    bun: 'bun run --filter @lumenflow/cli build',
+};
+/**
+ * WU-1356: Ignore patterns by test runner
+ *
+ * Different test runners use different cache directories that should be ignored.
+ */
+const IGNORE_PATTERNS_BY_RUNNER = {
+    vitest: ['.turbo'],
+    jest: ['coverage', '.jest-cache'],
+    mocha: ['coverage', '.nyc_output'],
+};
+/**
+ * WU-1356: Resolve package manager from configuration
+ *
+ * Reads the package_manager field from .lumenflow.config.yaml.
+ * Returns 'pnpm' as default if not configured.
+ *
+ * @param projectRoot - Project root directory
+ * @returns Resolved package manager ('pnpm', 'npm', 'yarn', or 'bun')
+ */
+export function resolvePackageManager(projectRoot) {
+    const configPath = path.join(projectRoot, CONFIG_FILE_NAME);
+    if (!fs.existsSync(configPath)) {
+        return 'pnpm';
+    }
+    try {
+        const content = fs.readFileSync(configPath, 'utf8');
+        const data = yaml.parse(content);
+        const pm = data?.package_manager;
+        if (pm && ['pnpm', 'npm', 'yarn', 'bun'].includes(pm)) {
+            return pm;
+        }
+        return 'pnpm';
+    }
+    catch {
+        return 'pnpm';
+    }
+}
+/**
+ * WU-1356: Resolve test runner from configuration
+ *
+ * Reads the test_runner field from .lumenflow.config.yaml.
+ * Returns 'vitest' as default if not configured.
+ *
+ * @param projectRoot - Project root directory
+ * @returns Resolved test runner ('vitest', 'jest', or 'mocha')
+ */
+export function resolveTestRunner(projectRoot) {
+    const configPath = path.join(projectRoot, CONFIG_FILE_NAME);
+    if (!fs.existsSync(configPath)) {
+        return 'vitest';
+    }
+    try {
+        const content = fs.readFileSync(configPath, 'utf8');
+        const data = yaml.parse(content);
+        const runner = data?.test_runner;
+        if (runner && ['vitest', 'jest', 'mocha'].includes(runner)) {
+            return runner;
+        }
+        return 'vitest';
+    }
+    catch {
+        return 'vitest';
+    }
+}
+/**
+ * WU-1356: Resolve build command from configuration
+ *
+ * Reads the build_command field from .lumenflow.config.yaml.
+ * If not configured, uses default based on package_manager.
+ *
+ * @param projectRoot - Project root directory
+ * @returns Resolved build command
+ */
+export function resolveBuildCommand(projectRoot) {
+    const configPath = path.join(projectRoot, CONFIG_FILE_NAME);
+    const defaultPm = resolvePackageManager(projectRoot);
+    if (!fs.existsSync(configPath)) {
+        return DEFAULT_BUILD_COMMANDS[defaultPm];
+    }
+    try {
+        const content = fs.readFileSync(configPath, 'utf8');
+        const data = yaml.parse(content);
+        // If explicit build_command is set, use it
+        if (data?.build_command && typeof data.build_command === 'string') {
+            return data.build_command;
+        }
+        // Otherwise, use default for the configured package manager
+        return DEFAULT_BUILD_COMMANDS[defaultPm];
+    }
+    catch {
+        return DEFAULT_BUILD_COMMANDS[defaultPm];
+    }
+}
+/**
+ * WU-1356: Resolve gates commands from configuration
+ *
+ * Reads gates.commands from .lumenflow.config.yaml.
+ * Merges with defaults based on package_manager if not fully specified.
+ *
+ * @param projectRoot - Project root directory
+ * @returns Resolved gates commands configuration
+ */
+export function resolveGatesCommands(projectRoot) {
+    const configPath = path.join(projectRoot, CONFIG_FILE_NAME);
+    const pm = resolvePackageManager(projectRoot);
+    const defaults = DEFAULT_GATES_COMMANDS[pm];
+    if (!fs.existsSync(configPath)) {
+        return defaults;
+    }
+    try {
+        const content = fs.readFileSync(configPath, 'utf8');
+        const data = yaml.parse(content);
+        const commands = data?.gates?.commands;
+        if (!commands) {
+            return defaults;
+        }
+        // Merge user config with defaults (user config wins)
+        return {
+            test_full: commands.test_full ?? defaults.test_full,
+            test_docs_only: commands.test_docs_only ?? defaults.test_docs_only,
+            test_incremental: commands.test_incremental ?? defaults.test_incremental,
+            lint: commands.lint ?? defaults.lint,
+            typecheck: commands.typecheck ?? defaults.typecheck,
+            format: commands.format ?? defaults.format,
+        };
+    }
+    catch {
+        return defaults;
+    }
+}
+/**
+ * WU-1356: Get ignore patterns for test runner
+ *
+ * Returns patterns to ignore when detecting changed tests,
+ * based on the test runner configuration.
+ *
+ * @param testRunner - Test runner type (vitest, jest, mocha)
+ * @returns Array of ignore patterns
+ */
+export function getIgnorePatterns(testRunner) {
+    return IGNORE_PATTERNS_BY_RUNNER[testRunner] ?? ['.turbo'];
+}

package/dist/lumenflow-config-schema.d.ts

@@ -7,6 +7,68 @@
  * @module lumenflow-config-schema
  */
 import { z } from 'zod';
+/**
+ * WU-1356: Package manager options
+ *
+ * Supported package managers for LumenFlow CLI operations.
+ * Used for build commands, dependency installation, and script execution.
+ *
+ * @example
+ * ```yaml
+ * package_manager: npm
+ * ```
+ */
+export declare const PackageManagerSchema: z.ZodDefault<z.ZodEnum<{
+    pnpm: "pnpm";
+    npm: "npm";
+    yarn: "yarn";
+    bun: "bun";
+}>>;
+/** WU-1356: TypeScript type for package manager */
+export type PackageManager = z.infer<typeof PackageManagerSchema>;
+/**
+ * WU-1356: Test runner options
+ *
+ * Supported test runners for incremental test detection and execution.
+ * Determines how changed tests are detected and ignore patterns are derived.
+ *
+ * @example
+ * ```yaml
+ * test_runner: jest
+ * ```
+ */
+export declare const TestRunnerSchema: z.ZodDefault<z.ZodEnum<{
+    vitest: "vitest";
+    jest: "jest";
+    mocha: "mocha";
+}>>;
+/** WU-1356: TypeScript type for test runner */
+export type TestRunner = z.infer<typeof TestRunnerSchema>;
+/**
+ * WU-1356: Gates commands configuration
+ *
+ * Configurable test commands for gates execution.
+ * Replaces hard-coded turbo/vitest commands with user-configurable alternatives.
+ *
+ * @example
+ * ```yaml
+ * gates:
+ *   commands:
+ *     test_full: 'npm test'
+ *     test_docs_only: 'npm test -- --testPathPattern=docs'
+ *     test_incremental: 'npm test -- --onlyChanged'
+ * ```
+ */
+export declare const GatesCommandsConfigSchema: z.ZodObject<{
+    test_full: z.ZodDefault<z.ZodString>;
+    test_docs_only: z.ZodDefault<z.ZodString>;
+    test_incremental: z.ZodDefault<z.ZodString>;
+    lint: z.ZodOptional<z.ZodString>;
+    typecheck: z.ZodOptional<z.ZodString>;
+    format: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/** WU-1356: TypeScript type for gates commands config */
+export type GatesCommandsConfig = z.infer<typeof GatesCommandsConfigSchema>;
 /**
  * WU-1325: Lock policy for lane-level WIP enforcement
  *
@@ -172,6 +234,20 @@ export declare const GatesConfigSchema: z.ZodObject<{
             threshold: z.ZodOptional<z.ZodNumber>;
         }, z.core.$strip>]>>;
     }, z.core.$strip>>;
+    commands: z.ZodDefault<z.ZodObject<{
+        test_full: z.ZodDefault<z.ZodString>;
+        test_docs_only: z.ZodDefault<z.ZodString>;
+        test_incremental: z.ZodDefault<z.ZodString>;
+        lint: z.ZodOptional<z.ZodString>;
+        typecheck: z.ZodOptional<z.ZodString>;
+        format: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    ignore_patterns: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    lane_health: z.ZodDefault<z.ZodEnum<{
+        error: "error";
+        off: "off";
+        warn: "warn";
+    }>>;
 }, z.core.$strip>;
 /**
  * WU-1203: Progress signals configuration for sub-agent coordination
@@ -357,6 +433,15 @@ export declare const TelemetryConfigSchema: z.ZodObject<{
         enabled: z.ZodDefault<z.ZodBoolean>;
     }, z.core.$strip>>;
 }, z.core.$strip>;
+/**
+ * WU-1345: Lane enforcement configuration schema
+ *
+ * Controls how lane format validation behaves.
+ */
+export declare const LanesEnforcementSchema: z.ZodObject<{
+    require_parent: z.ZodDefault<z.ZodBoolean>;
+    allow_custom: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
 /**
  * WU-1322: Lane definition schema for .lumenflow.config.yaml
  *
@@ -374,6 +459,66 @@ export declare const LaneDefinitionSchema: z.ZodObject<{
     }>>>;
     code_paths: z.ZodOptional<z.ZodArray<z.ZodString>>;
 }, z.core.$strip>;
+/**
+ * WU-1345: Complete lanes configuration schema
+ *
+ * Supports three formats:
+ * 1. definitions array (recommended)
+ * 2. engineering + business arrays (legacy/alternate)
+ * 3. flat array (simple format - parsed as definitions)
+ *
+ * @example
+ * ```yaml
+ * lanes:
+ *   enforcement:
+ *     require_parent: true
+ *     allow_custom: false
+ *   definitions:
+ *     - name: 'Framework: Core'
+ *       wip_limit: 1
+ *       code_paths:
+ *         - 'packages/@lumenflow/core/**'
+ * ```
+ */
+export declare const LanesConfigSchema: z.ZodObject<{
+    enforcement: z.ZodOptional<z.ZodObject<{
+        require_parent: z.ZodDefault<z.ZodBoolean>;
+        allow_custom: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    definitions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        wip_limit: z.ZodOptional<z.ZodNumber>;
+        wip_justification: z.ZodOptional<z.ZodString>;
+        lock_policy: z.ZodDefault<z.ZodDefault<z.ZodEnum<{
+            none: "none";
+            all: "all";
+            active: "active";
+        }>>>;
+        code_paths: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>>;
+    engineering: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        wip_limit: z.ZodOptional<z.ZodNumber>;
+        wip_justification: z.ZodOptional<z.ZodString>;
+        lock_policy: z.ZodDefault<z.ZodDefault<z.ZodEnum<{
+            none: "none";
+            all: "all";
+            active: "active";
+        }>>>;
+        code_paths: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>>;
+    business: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        wip_limit: z.ZodOptional<z.ZodNumber>;
+        wip_justification: z.ZodOptional<z.ZodString>;
+        lock_policy: z.ZodDefault<z.ZodDefault<z.ZodEnum<{
+            none: "none";
+            all: "all";
+            active: "active";
+        }>>>;
+        code_paths: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
 /**
  * Complete LumenFlow configuration schema
  */
@@ -481,6 +626,20 @@ export declare const LumenFlowConfigSchema: z.ZodObject<{
                 threshold: z.ZodOptional<z.ZodNumber>;
             }, z.core.$strip>]>>;
         }, z.core.$strip>>;
+        commands: z.ZodDefault<z.ZodObject<{
+            test_full: z.ZodDefault<z.ZodString>;
+            test_docs_only: z.ZodDefault<z.ZodString>;
+            test_incremental: z.ZodDefault<z.ZodString>;
+            lint: z.ZodOptional<z.ZodString>;
+            typecheck: z.ZodOptional<z.ZodString>;
+            format: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        ignore_patterns: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        lane_health: z.ZodDefault<z.ZodEnum<{
+            error: "error";
+            off: "off";
+            warn: "warn";
+        }>>;
     }, z.core.$strip>>;
     memory: z.ZodDefault<z.ZodObject<{
         directory: z.ZodDefault<z.ZodString>;
@@ -571,6 +730,57 @@ export declare const LumenFlowConfigSchema: z.ZodObject<{
             }>>;
         }, z.core.$strip>>;
     }, z.core.$strip>>;
+    lanes: z.ZodOptional<z.ZodObject<{
+        enforcement: z.ZodOptional<z.ZodObject<{
+            require_parent: z.ZodDefault<z.ZodBoolean>;
+            allow_custom: z.ZodDefault<z.ZodBoolean>;
+        }, z.core.$strip>>;
+        definitions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            wip_limit: z.ZodOptional<z.ZodNumber>;
+            wip_justification: z.ZodOptional<z.ZodString>;
+            lock_policy: z.ZodDefault<z.ZodDefault<z.ZodEnum<{
+                none: "none";
+                all: "all";
+                active: "active";
+            }>>>;
+            code_paths: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>>>;
+        engineering: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            wip_limit: z.ZodOptional<z.ZodNumber>;
+            wip_justification: z.ZodOptional<z.ZodString>;
+            lock_policy: z.ZodDefault<z.ZodDefault<z.ZodEnum<{
+                none: "none";
+                all: "all";
+                active: "active";
+            }>>>;
+            code_paths: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>>>;
+        business: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            wip_limit: z.ZodOptional<z.ZodNumber>;
+            wip_justification: z.ZodOptional<z.ZodString>;
+            lock_policy: z.ZodDefault<z.ZodDefault<z.ZodEnum<{
+                none: "none";
+                all: "all";
+                active: "active";
+            }>>>;
+            code_paths: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
+    package_manager: z.ZodDefault<z.ZodEnum<{
+        pnpm: "pnpm";
+        npm: "npm";
+        yarn: "yarn";
+        bun: "bun";
+    }>>;
+    test_runner: z.ZodDefault<z.ZodEnum<{
+        vitest: "vitest";
+        jest: "jest";
+        mocha: "mocha";
+    }>>;
+    build_command: z.ZodDefault<z.ZodString>;
 }, z.core.$strip>;
 /**
  * TypeScript types inferred from schemas
@@ -598,6 +808,8 @@ export type MethodologyTelemetryConfig = z.infer<typeof MethodologyTelemetryConf
 export type TelemetryConfig = z.infer<typeof TelemetryConfigSchema>;
 export type LumenFlowConfig = z.infer<typeof LumenFlowConfigSchema>;
 export type LaneDefinition = z.infer<typeof LaneDefinitionSchema>;
+export type LanesEnforcement = z.infer<typeof LanesEnforcementSchema>;
+export type LanesConfig = z.infer<typeof LanesConfigSchema>;
 export type { MethodologyConfig, MethodologyOverrides } from './resolve-policy.js';
 /**
  * Validate configuration data
@@ -677,6 +889,15 @@ export declare function validateConfig(data: unknown): z.ZodSafeParseResult<{
         minCoverage: number;
         enableSafetyCriticalTests: boolean;
         enableInvariants: boolean;
+        commands: {
+            test_full: string;
+            test_docs_only: string;
+            test_incremental: string;
+            lint?: string;
+            typecheck?: string;
+            format?: string;
+        };
+        lane_health: "error" | "off" | "warn";
         execution?: {
             preset?: string;
             setup?: string | {
@@ -709,6 +930,7 @@ export declare function validateConfig(data: unknown): z.ZodSafeParseResult<{
                 threshold?: number;
             };
         };
+        ignore_patterns?: string[];
     };
     memory: {
         directory: string;
@@ -772,6 +994,9 @@ export declare function validateConfig(data: unknown): z.ZodSafeParseResult<{
             enabled: boolean;
         };
     };
+    package_manager: "pnpm" | "npm" | "yarn" | "bun";
+    test_runner: "vitest" | "jest" | "mocha";
+    build_command: string;
     methodology?: {
         testing: "tdd" | "test-after" | "none";
         architecture: "none" | "hexagonal" | "layered";
@@ -780,6 +1005,33 @@ export declare function validateConfig(data: unknown): z.ZodSafeParseResult<{
             coverage_mode?: "off" | "warn" | "block";
         };
     };
+    lanes?: {
+        enforcement?: {
+            require_parent: boolean;
+            allow_custom: boolean;
+        };
+        definitions?: {
+            name: string;
+            lock_policy: "none" | "all" | "active";
+            wip_limit?: number;
+            wip_justification?: string;
+            code_paths?: string[];
+        }[];
+        engineering?: {
+            name: string;
+            lock_policy: "none" | "all" | "active";
+            wip_limit?: number;
+            wip_justification?: string;
+            code_paths?: string[];
+        }[];
+        business?: {
+            name: string;
+            lock_policy: "none" | "all" | "active";
+            wip_limit?: number;
+            wip_justification?: string;
+            code_paths?: string[];
+        }[];
+    };
 }>;
 /**
  * Parse configuration with defaults

package/dist/lumenflow-config-schema.js

@@ -11,6 +11,77 @@ import { z } from 'zod';
 import { GatesExecutionConfigSchema } from './gates-config.js';
 // WU-1259: Import methodology config schema for resolvePolicy()
 import { MethodologyConfigSchema } from './resolve-policy.js';
+/**
+ * WU-1356: Package manager options
+ *
+ * Supported package managers for LumenFlow CLI operations.
+ * Used for build commands, dependency installation, and script execution.
+ *
+ * @example
+ * ```yaml
+ * package_manager: npm
+ * ```
+ */
+export const PackageManagerSchema = z.enum(['pnpm', 'npm', 'yarn', 'bun']).default('pnpm');
+/**
+ * WU-1356: Test runner options
+ *
+ * Supported test runners for incremental test detection and execution.
+ * Determines how changed tests are detected and ignore patterns are derived.
+ *
+ * @example
+ * ```yaml
+ * test_runner: jest
+ * ```
+ */
+export const TestRunnerSchema = z.enum(['vitest', 'jest', 'mocha']).default('vitest');
+/**
+ * WU-1356: Gates commands configuration
+ *
+ * Configurable test commands for gates execution.
+ * Replaces hard-coded turbo/vitest commands with user-configurable alternatives.
+ *
+ * @example
+ * ```yaml
+ * gates:
+ *   commands:
+ *     test_full: 'npm test'
+ *     test_docs_only: 'npm test -- --testPathPattern=docs'
+ *     test_incremental: 'npm test -- --onlyChanged'
+ * ```
+ */
+export const GatesCommandsConfigSchema = z.object({
+    /**
+     * Command to run full test suite.
+     * Default: 'pnpm turbo run test'
+     */
+    test_full: z.string().default('pnpm turbo run test'),
+    /**
+     * Command to run tests in docs-only mode.
+     * Default: empty (skip tests in docs-only mode)
+     */
+    test_docs_only: z.string().default(''),
+    /**
+     * Command to run incremental tests (changed files only).
+     * Default: 'pnpm vitest run --changed origin/main'
+     */
+    test_incremental: z.string().default('pnpm vitest run --changed origin/main'),
+    /**
+     * Command to run lint checks.
+     * Default: 'pnpm lint'
+     */
+    lint: z.string().optional(),
+    /**
+     * Command to run type checks.
+     * Default: 'pnpm typecheck'
+     */
+    typecheck: z.string().optional(),
+    /**
+     * Command to run format checks.
+     * Default: 'pnpm format:check'
+     */
+    format: z.string().optional(),
+});
 /**
  * WU-1325: Lock policy for lane-level WIP enforcement
  *
@@ -306,6 +377,26 @@ export const GatesConfigSchema = z.object({
      * When set, gates runner uses these instead of hardcoded commands.
      */
     execution: GatesExecutionConfigSchema.optional(),
+    /**
+     * WU-1356: Configurable gate commands
+     * Replaces hard-coded turbo/vitest commands with user-configurable alternatives.
+     * Enables LumenFlow to work with npm/yarn/bun, Nx/plain scripts, Jest/Mocha, etc.
+     */
+    commands: GatesCommandsConfigSchema.default(() => GatesCommandsConfigSchema.parse({})),
+    /**
+     * WU-1356: Ignore patterns for test runners
+     * Patterns to ignore when detecting changed tests.
+     * Default: ['.turbo'] for vitest (derived from test_runner if not specified)
+     */
+    ignore_patterns: z.array(z.string()).optional(),
+    /**
+     * WU-1191: Lane health gate mode
+     * Controls how lane health check behaves during gates.
+     * - 'warn': Log warning if issues found (default)
+     * - 'error': Fail gates if issues found
+     * - 'off': Skip lane health check
+     */
+    lane_health: z.enum(['warn', 'error', 'off']).default('warn'),
 });
 /**
  * WU-1203: Progress signals configuration for sub-agent coordination
@@ -582,6 +673,24 @@ export const TelemetryConfigSchema = z.object({
      */
     methodology: MethodologyTelemetryConfigSchema.default(() => MethodologyTelemetryConfigSchema.parse({})),
 });
+/**
+ * WU-1345: Lane enforcement configuration schema
+ *
+ * Controls how lane format validation behaves.
+ */
+export const LanesEnforcementSchema = z.object({
+    /**
+     * When true, lanes MUST use "Parent: Sublane" format if parent has taxonomy.
+     * @default true
+     */
+    require_parent: z.boolean().default(true),
+    /**
+     * When false, only lanes in the taxonomy are allowed.
+     * When true, custom lanes can be used.
+     * @default false
+     */
+    allow_custom: z.boolean().default(false),
+});
 /**
  * WU-1322: Lane definition schema for .lumenflow.config.yaml
  *
@@ -616,6 +725,37 @@ export const LaneDefinitionSchema = z.object({
     /** Code paths associated with this lane (glob patterns) */
     code_paths: z.array(z.string()).optional(),
 });
+/**
+ * WU-1345: Complete lanes configuration schema
+ *
+ * Supports three formats:
+ * 1. definitions array (recommended)
+ * 2. engineering + business arrays (legacy/alternate)
+ * 3. flat array (simple format - parsed as definitions)
+ *
+ * @example
+ * ```yaml
+ * lanes:
+ *   enforcement:
+ *     require_parent: true
+ *     allow_custom: false
+ *   definitions:
+ *     - name: 'Framework: Core'
+ *       wip_limit: 1
+ *       code_paths:
+ *         - 'packages/@lumenflow/core/**'
+ * ```
+ */
+export const LanesConfigSchema = z.object({
+    /** Lane enforcement configuration (validation rules) */
+    enforcement: LanesEnforcementSchema.optional(),
+    /** Primary lane definitions array (recommended format) */
+    definitions: z.array(LaneDefinitionSchema).optional(),
+    /** Engineering lanes (alternate format) */
+    engineering: z.array(LaneDefinitionSchema).optional(),
+    /** Business lanes (alternate format) */
+    business: z.array(LaneDefinitionSchema).optional(),
+});
 /**
  * Complete LumenFlow configuration schema
  */
@@ -663,6 +803,62 @@ export const LumenFlowConfigSchema = z.object({
      * ```
      */
     methodology: MethodologyConfigSchema.optional(),
+    /**
+     * WU-1345: Lanes configuration
+     * Defines delivery lanes with WIP limits, code paths, and lock policies.
+     * Required for resolveLaneConfigsFromConfig() to work with getConfig().
+     *
+     * @example
+     * ```yaml
+     * lanes:
+     *   enforcement:
+     *     require_parent: true
+     *     allow_custom: false
+     *   definitions:
+     *     - name: 'Framework: Core'
+     *       wip_limit: 1
+     *       code_paths:
+     *         - 'packages/@lumenflow/core/**'
+     * ```
+     */
+    lanes: LanesConfigSchema.optional(),
+    /**
+     * WU-1356: Package manager for CLI operations
+     * Determines which package manager is used for build commands,
+     * dependency installation, and script execution.
+     *
+     * @default 'pnpm'
+     *
+     * @example
+     * ```yaml
+     * package_manager: npm
+     * ```
+     */
+    package_manager: PackageManagerSchema,
+    /**
+     * WU-1356: Test runner for incremental test detection
+     * Determines how changed tests are detected and which ignore patterns to use.
+     *
+     * @default 'vitest'
+     *
+     * @example
+     * ```yaml
+     * test_runner: jest
+     * ```
+     */
+    test_runner: TestRunnerSchema,
+    /**
+     * WU-1356: Custom build command for CLI bootstrap
+     * Overrides the default build command used in cli-entry.mjs.
+     *
+     * @default 'pnpm --filter @lumenflow/cli build'
+     *
+     * @example
+     * ```yaml
+     * build_command: 'npm run build'
+     * ```
+     */
+    build_command: z.string().default('pnpm --filter @lumenflow/cli build'),
 });
 /**
  * Validate configuration data

package/dist/micro-worktree.d.ts

@@ -306,11 +306,16 @@ export declare function mergeWithRetry(tempBranchName: string, microWorktreePath
  * Push to origin/main with retry logic for race conditions
  *
  * WU-1179: When push fails because origin/main advanced (race condition with
- * parallel agents), this function rolls back local main to origin/main and
- * retries the full sequence: fetch -> rebase temp branch -> re-merge -> push.
+ * parallel agents), this function retries with fetch and rebase.
  *
- * This prevents the scenario where local main is left diverged from origin
- * after a push failure.
+ * WU-1348: The retry logic no longer resets the main checkout. Instead, it:
+ * 1. Fetches origin/main to get latest remote state
+ * 2. Rebases the temp branch onto origin/main (in the micro-worktree)
+ * 3. Re-merges the rebased temp branch to local main (ff-only)
+ * 4. Retries the push
+ *
+ * This preserves micro-worktree isolation - the main checkout files are never
+ * hard-reset, preventing file flash and preserving any uncommitted work.
  *
  * @param {Object} mainGit - GitAdapter instance for main checkout
  * @param {Object} worktreeGit - GitAdapter instance for micro-worktree
@@ -328,6 +333,15 @@ export declare function pushWithRetry(mainGit: GitAdapter, worktreeGit: GitAdapt
  * and supports configuration via PushRetryConfig. When push fails due to
  * non-fast-forward (origin moved), automatically rebases and retries.
  *
+ * WU-1348: The retry logic no longer resets the main checkout. Instead, it:
+ * 1. Fetches origin/main to get latest remote state
+ * 2. Rebases the temp branch onto origin/main (in the micro-worktree)
+ * 3. Re-merges the rebased temp branch to local main (ff-only)
+ * 4. Retries the push
+ *
+ * This preserves micro-worktree isolation - the main checkout files are never
+ * hard-reset, preventing file flash and preserving any uncommitted work.
+ *
  * @param {Object} mainGit - GitAdapter instance for main checkout
  * @param {Object} worktreeGit - GitAdapter instance for micro-worktree
  * @param {string} remote - Remote name (e.g., 'origin')

package/dist/micro-worktree.js

@@ -518,11 +518,16 @@ export async function mergeWithRetry(tempBranchName, microWorktreePath, logPrefi
  * Push to origin/main with retry logic for race conditions
  *
  * WU-1179: When push fails because origin/main advanced (race condition with
- * parallel agents), this function rolls back local main to origin/main and
- * retries the full sequence: fetch -> rebase temp branch -> re-merge -> push.
+ * parallel agents), this function retries with fetch and rebase.
  *
- * This prevents the scenario where local main is left diverged from origin
- * after a push failure.
+ * WU-1348: The retry logic no longer resets the main checkout. Instead, it:
+ * 1. Fetches origin/main to get latest remote state
+ * 2. Rebases the temp branch onto origin/main (in the micro-worktree)
+ * 3. Re-merges the rebased temp branch to local main (ff-only)
+ * 4. Retries the push
+ *
+ * This preserves micro-worktree isolation - the main checkout files are never
+ * hard-reset, preventing file flash and preserving any uncommitted work.
  *
  * @param {Object} mainGit - GitAdapter instance for main checkout
  * @param {Object} worktreeGit - GitAdapter instance for micro-worktree
@@ -544,27 +549,27 @@ export async function pushWithRetry(mainGit, worktreeGit, remote, branch, tempBr
         }
         catch (pushErr) {
             if (attempt < maxRetries) {
-                console.log(`${logPrefix} ⚠️  Push failed (origin moved). Rolling back and retrying...`);
-                // Step 1: Rollback local main to origin/main
-                console.log(`${logPrefix} Rolling back local ${branch} to ${remote}/${branch}...`);
-                await mainGit.reset(`${remote}/${branch}`, { hard: true });
-                // Step 2: Fetch latest origin/main
+                console.log(`${logPrefix} ⚠️  Push failed (origin moved). Fetching and rebasing before retry...`);
+                // WU-1348: Do NOT reset main checkout - preserve micro-worktree isolation
+                // Instead, fetch latest remote state and rebase the temp branch
+                // Step 1: Fetch latest origin/main
                 console.log(`${logPrefix} Fetching ${remote}/${branch}...`);
                 await mainGit.fetch(remote, branch);
-                // Step 3: Update local main to match origin/main (ff-only)
-                console.log(`${logPrefix} Updating local ${branch}...`);
-                await mainGit.merge(`${remote}/${branch}`, { ffOnly: true });
-                // Step 4: Rebase temp branch onto updated main
-                console.log(`${logPrefix} Rebasing temp branch onto ${branch}...`);
-                await worktreeGit.rebase(branch);
-                // Step 5: Re-merge temp branch to local main
+                // Step 2: Rebase temp branch onto updated origin/main
+                console.log(`${logPrefix} Rebasing temp branch onto ${remote}/${branch}...`);
+                await worktreeGit.rebase(`${remote}/${branch}`);
+                // Step 3: Re-merge temp branch to local main (ff-only)
+                // This updates local main to include the rebased commits
                 console.log(`${logPrefix} Re-merging temp branch to ${branch}...`);
                 await mainGit.merge(tempBranchName, { ffOnly: true });
             }
             else {
                 const errMsg = pushErr instanceof Error ? pushErr.message : String(pushErr);
                 throw new Error(`Push failed after ${maxRetries} attempts. ` +
-                    `Origin ${branch} may have significant traffic.\n` +
+                    `Origin ${branch} may have significant traffic.\n\n` +
+                    `Suggestions:\n` +
+                    `  - Wait a few seconds and retry the operation\n` +
+                    `  - Check if another agent is rapidly pushing changes\n` +
                     `Error: ${errMsg}`);
             }
         }
@@ -577,6 +582,15 @@ export async function pushWithRetry(mainGit, worktreeGit, remote, branch, tempBr
  * and supports configuration via PushRetryConfig. When push fails due to
  * non-fast-forward (origin moved), automatically rebases and retries.
  *
+ * WU-1348: The retry logic no longer resets the main checkout. Instead, it:
+ * 1. Fetches origin/main to get latest remote state
+ * 2. Rebases the temp branch onto origin/main (in the micro-worktree)
+ * 3. Re-merges the rebased temp branch to local main (ff-only)
+ * 4. Retries the push
+ *
+ * This preserves micro-worktree isolation - the main checkout files are never
+ * hard-reset, preventing file flash and preserving any uncommitted work.
+ *
  * @param {Object} mainGit - GitAdapter instance for main checkout
  * @param {Object} worktreeGit - GitAdapter instance for micro-worktree
  * @param {string} remote - Remote name (e.g., 'origin')
@@ -603,20 +617,17 @@ export async function pushWithRetryConfig(mainGit, worktreeGit, remote, branch,
             console.log(`${logPrefix} ✅ Pushed to ${remote}/${branch}`);
         }
         catch (pushErr) {
-            console.log(`${logPrefix} ⚠️  Push failed (origin moved). Rolling back and retrying...`);
-            // Rollback local main to origin/main
-            console.log(`${logPrefix} Rolling back local ${branch} to ${remote}/${branch}...`);
-            await mainGit.reset(`${remote}/${branch}`, { hard: true });
+            console.log(`${logPrefix} ⚠️  Push failed (origin moved). Fetching and rebasing before retry...`);
+            // WU-1348: Do NOT reset main checkout - preserve micro-worktree isolation
+            // Instead, fetch latest remote state and rebase the temp branch
             // Fetch latest origin/main
             console.log(`${logPrefix} Fetching ${remote}/${branch}...`);
             await mainGit.fetch(remote, branch);
-            // Update local main to match origin/main (ff-only)
-            console.log(`${logPrefix} Updating local ${branch}...`);
-            await mainGit.merge(`${remote}/${branch}`, { ffOnly: true });
-            // Rebase temp branch onto updated main
-            console.log(`${logPrefix} Rebasing temp branch onto ${branch}...`);
-            await worktreeGit.rebase(branch);
-            // Re-merge temp branch to local main
+            // Rebase temp branch onto updated origin/main
+            console.log(`${logPrefix} Rebasing temp branch onto ${remote}/${branch}...`);
+            await worktreeGit.rebase(`${remote}/${branch}`);
+            // Re-merge temp branch to local main (ff-only)
+            // This updates local main to include the rebased commits
             console.log(`${logPrefix} Re-merging temp branch to ${branch}...`);
             await mainGit.merge(tempBranchName, { ffOnly: true });
             // Re-throw to trigger p-retry
@@ -627,11 +638,8 @@ export async function pushWithRetryConfig(mainGit, worktreeGit, remote, branch,
         minTimeout: config.min_delay_ms,
         maxTimeout: config.max_delay_ms,
         randomize: config.jitter,
-        onFailedAttempt: (error) => {
-            // Log is handled in the try/catch above
-            if (error.retriesLeft === 0) {
-                // This will be the final failure
-            }
+        onFailedAttempt: () => {
+            // Logging is handled in the try/catch above
         },
     }).catch(() => {
         // p-retry exhausted all retries, throw descriptive error

package/dist/wu-constants.d.ts

@@ -1718,6 +1718,75 @@ export declare const CONTEXT_VALIDATION: {
         readonly GATES: "gates";
     };
 };
+/**
+ * Git hook error messages (WU-1357)
+ *
+ * Educational, structured messages for git hook blocks.
+ * Follows the "message bag" pattern: TITLE, WHY, ACTIONS, HELP, BYPASS.
+ *
+ * Design principles:
+ * - Explain WHY before showing WHAT to do
+ * - Provide multiple paths forward (not just one command)
+ * - Put emergency bypass LAST with clear warnings
+ * - Include help resources for learning
+ *
+ * @see .husky/hooks/pre-commit.mjs - Primary consumer
+ */
+export declare const HOOK_MESSAGES: {
+    /**
+     * Main branch protection block message components
+     */
+    readonly MAIN_BRANCH_BLOCK: {
+        /** Box drawing for visual structure */
+        readonly BOX: {
+            readonly TOP: "══════════════════════════════════════════════════════════════";
+            readonly DIVIDER: "──────────────────────────────────────────────────────────────";
+        };
+        /** Title shown at the top */
+        readonly TITLE: (branch: string) => string;
+        /** Educational explanation of WHY the block exists */
+        readonly WHY: {
+            readonly HEADER: "WHY THIS HAPPENS";
+            readonly LINES: readonly ["LumenFlow protects main from direct commits to ensure:", "  • All work is tracked in Work Units (WUs)", "  • Changes can be reviewed and coordinated", "  • Parallel work across lanes stays isolated"];
+        };
+        /** Action paths - multiple ways forward */
+        readonly ACTIONS: {
+            readonly HEADER: "WHAT TO DO";
+            readonly HAVE_WU: {
+                readonly HEADER: "1. If you have a Work Unit to implement:";
+                readonly COMMANDS: readonly ["pnpm wu:claim --id WU-XXXX --lane \"<Lane>\"", "cd worktrees/<lane>-wu-xxxx"];
+                readonly NOTE: "Then make your commits there";
+            };
+            readonly NEED_WU: {
+                readonly HEADER: "2. If you need to create a new Work Unit:";
+                readonly COMMANDS: readonly ["pnpm wu:create --lane \"<Lane>\" --title \"Your task\""];
+                readonly NOTE: "This generates a WU ID, then claim it as above";
+            };
+            readonly LIST_LANES: {
+                readonly HEADER: "3. Not sure what lane to use?";
+                readonly COMMANDS: readonly ["pnpm wu:list-lanes"];
+            };
+        };
+        /** Help resources */
+        readonly HELP: {
+            readonly HEADER: "NEED HELP?";
+            readonly RESOURCES: readonly ["• Read: LUMENFLOW.md (workflow overview)", "• Read: docs/04-operations/_frameworks/lumenflow/agent/onboarding/", "• Run:  pnpm wu:help"];
+        };
+        /** Emergency bypass (shown last, with warnings) */
+        readonly BYPASS: {
+            readonly HEADER: "EMERGENCY BYPASS (logged, use sparingly)";
+            readonly WARNING: "Bypasses are audit-logged. Only use for genuine emergencies.";
+            readonly COMMAND: "LUMENFLOW_FORCE=1 LUMENFLOW_FORCE_REASON=\"<reason>\" git commit ...";
+        };
+    };
+    /**
+     * Worktree discipline block message components
+     */
+    readonly WORKTREE_BLOCK: {
+        readonly TITLE: "LANE BRANCH WORK SHOULD BE IN WORKTREE";
+        readonly WHY: "Worktrees provide isolation for parallel work. Working on a lane branch from the main checkout bypasses this isolation.";
+    };
+};
 /** Type for location types */
 export type LocationType = (typeof CONTEXT_VALIDATION.LOCATION_TYPES)[keyof typeof CONTEXT_VALIDATION.LOCATION_TYPES];
 /** Type for validation error codes */

package/dist/wu-constants.js

@@ -1789,3 +1789,81 @@ export const CONTEXT_VALIDATION = {
         GATES: 'gates',
     },
 };
+/**
+ * Git hook error messages (WU-1357)
+ *
+ * Educational, structured messages for git hook blocks.
+ * Follows the "message bag" pattern: TITLE, WHY, ACTIONS, HELP, BYPASS.
+ *
+ * Design principles:
+ * - Explain WHY before showing WHAT to do
+ * - Provide multiple paths forward (not just one command)
+ * - Put emergency bypass LAST with clear warnings
+ * - Include help resources for learning
+ *
+ * @see .husky/hooks/pre-commit.mjs - Primary consumer
+ */
+export const HOOK_MESSAGES = {
+    /**
+     * Main branch protection block message components
+     */
+    MAIN_BRANCH_BLOCK: {
+        /** Box drawing for visual structure */
+        BOX: {
+            TOP: '══════════════════════════════════════════════════════════════',
+            DIVIDER: '──────────────────────────────────────────────────────────────',
+        },
+        /** Title shown at the top */
+        TITLE: (branch) => `DIRECT COMMIT TO ${branch.toUpperCase()} BLOCKED`,
+        /** Educational explanation of WHY the block exists */
+        WHY: {
+            HEADER: 'WHY THIS HAPPENS',
+            LINES: [
+                'LumenFlow protects main from direct commits to ensure:',
+                '  • All work is tracked in Work Units (WUs)',
+                '  • Changes can be reviewed and coordinated',
+                '  • Parallel work across lanes stays isolated',
+            ],
+        },
+        /** Action paths - multiple ways forward */
+        ACTIONS: {
+            HEADER: 'WHAT TO DO',
+            HAVE_WU: {
+                HEADER: '1. If you have a Work Unit to implement:',
+                COMMANDS: ['pnpm wu:claim --id WU-XXXX --lane "<Lane>"', 'cd worktrees/<lane>-wu-xxxx'],
+                NOTE: 'Then make your commits there',
+            },
+            NEED_WU: {
+                HEADER: '2. If you need to create a new Work Unit:',
+                COMMANDS: ['pnpm wu:create --lane "<Lane>" --title "Your task"'],
+                NOTE: 'This generates a WU ID, then claim it as above',
+            },
+            LIST_LANES: {
+                HEADER: '3. Not sure what lane to use?',
+                COMMANDS: ['pnpm wu:list-lanes'],
+            },
+        },
+        /** Help resources */
+        HELP: {
+            HEADER: 'NEED HELP?',
+            RESOURCES: [
+                '• Read: LUMENFLOW.md (workflow overview)',
+                '• Read: docs/04-operations/_frameworks/lumenflow/agent/onboarding/',
+                '• Run:  pnpm wu:help',
+            ],
+        },
+        /** Emergency bypass (shown last, with warnings) */
+        BYPASS: {
+            HEADER: 'EMERGENCY BYPASS (logged, use sparingly)',
+            WARNING: 'Bypasses are audit-logged. Only use for genuine emergencies.',
+            COMMAND: 'LUMENFLOW_FORCE=1 LUMENFLOW_FORCE_REASON="<reason>" git commit ...',
+        },
+    },
+    /**
+     * Worktree discipline block message components
+     */
+    WORKTREE_BLOCK: {
+        TITLE: 'LANE BRANCH WORK SHOULD BE IN WORKTREE',
+        WHY: 'Worktrees provide isolation for parallel work. Working on a lane branch from the main checkout bypasses this isolation.',
+    },
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lumenflow/core",
-  "version": "2.5.0",
+  "version": "2.6.0",
   "description": "Core WU lifecycle tools for LumenFlow workflow framework",
   "keywords": [
     "lumenflow",
@@ -99,7 +99,7 @@
     "vitest": "^4.0.17"
   },
   "peerDependencies": {
-    "@lumenflow/memory": "2.5.0"
+    "@lumenflow/memory": "2.6.0"
   },
   "peerDependenciesMeta": {
     "@lumenflow/memory": {