@lumenflow/core 2.4.0 → 2.5.1

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

@@ -7,6 +7,30 @@
  * @module lumenflow-config-schema
  */
 import { z } from 'zod';
+/**
+ * WU-1325: Lock policy for lane-level WIP enforcement
+ *
+ * Controls how lane locks behave:
+ * - 'all' (default): Lock acquired on claim, held through block, released on done
+ * - 'active': Lock acquired on claim, released on block, re-acquired on unblock
+ * - 'none': No lock files created, WIP checking disabled
+ *
+ * @example
+ * ```yaml
+ * lanes:
+ *   definitions:
+ *     - name: 'Content: Documentation'
+ *       wip_limit: 4
+ *       lock_policy: 'none'  # Docs don't need lock coordination
+ * ```
+ */
+export declare const LockPolicySchema: z.ZodDefault<z.ZodEnum<{
+    none: "none";
+    all: "all";
+    active: "active";
+}>>;
+/** WU-1325: TypeScript type for lock policy */
+export type LockPolicy = z.infer<typeof LockPolicySchema>;
 /**
  * Event archival configuration (WU-1207)
  *
@@ -36,6 +60,8 @@ export declare const DirectoriesSchema: z.ZodObject<{
     skillsDir: z.ZodDefault<z.ZodString>;
     agentsDir: z.ZodDefault<z.ZodString>;
     plansDir: z.ZodDefault<z.ZodString>;
+    templatesDir: z.ZodDefault<z.ZodString>;
+    onboardingDir: z.ZodDefault<z.ZodString>;
 }, z.core.$strip>;
 /**
  * Beacon paths configuration (.lumenflow directory structure)
@@ -56,6 +82,19 @@ export declare const BeaconPathsSchema: z.ZodObject<{
         keepArchives: z.ZodDefault<z.ZodBoolean>;
     }, z.core.$strip>>;
 }, z.core.$strip>;
+/**
+ * WU-1332: Push retry configuration for micro-worktree operations
+ *
+ * When non-fast-forward push errors occur (origin/main moved during operation),
+ * retry with exponential backoff. Uses p-retry for robust retry behavior.
+ */
+export declare const PushRetryConfigSchema: z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    retries: z.ZodDefault<z.ZodNumber>;
+    min_delay_ms: z.ZodDefault<z.ZodNumber>;
+    max_delay_ms: z.ZodDefault<z.ZodNumber>;
+    jitter: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
 /**
  * Git configuration
  */
@@ -72,6 +111,13 @@ export declare const GitConfigSchema: z.ZodObject<{
     agentBranchPatterns: z.ZodDefault<z.ZodArray<z.ZodString>>;
     agentBranchPatternsOverride: z.ZodOptional<z.ZodArray<z.ZodString>>;
     disableAgentPatternRegistry: z.ZodDefault<z.ZodBoolean>;
+    push_retry: z.ZodDefault<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        retries: z.ZodDefault<z.ZodNumber>;
+        min_delay_ms: z.ZodDefault<z.ZodNumber>;
+        max_delay_ms: z.ZodDefault<z.ZodNumber>;
+        jitter: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strip>>;
 }, z.core.$strip>;
 /**
  * WU (Work Unit) configuration
@@ -311,6 +357,92 @@ 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
+ *
+ * Extends the existing lane configuration with lock_policy field.
+ * Compatible with WU-1016 (wip_limit) and WU-1187 (wip_justification).
+ */
+export declare const LaneDefinitionSchema: 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>;
+/**
+ * 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
  */
@@ -332,6 +464,8 @@ export declare const LumenFlowConfigSchema: z.ZodObject<{
         skillsDir: z.ZodDefault<z.ZodString>;
         agentsDir: z.ZodDefault<z.ZodString>;
         plansDir: z.ZodDefault<z.ZodString>;
+        templatesDir: z.ZodDefault<z.ZodString>;
+        onboardingDir: z.ZodDefault<z.ZodString>;
     }, z.core.$strip>>;
     beacon: z.ZodDefault<z.ZodObject<{
         base: z.ZodDefault<z.ZodString>;
@@ -362,6 +496,13 @@ export declare const LumenFlowConfigSchema: z.ZodObject<{
         agentBranchPatterns: z.ZodDefault<z.ZodArray<z.ZodString>>;
         agentBranchPatternsOverride: z.ZodOptional<z.ZodArray<z.ZodString>>;
         disableAgentPatternRegistry: z.ZodDefault<z.ZodBoolean>;
+        push_retry: z.ZodDefault<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            retries: z.ZodDefault<z.ZodNumber>;
+            min_delay_ms: z.ZodDefault<z.ZodNumber>;
+            max_delay_ms: z.ZodDefault<z.ZodNumber>;
+            jitter: z.ZodDefault<z.ZodBoolean>;
+        }, z.core.$strip>>;
     }, z.core.$strip>>;
     wu: z.ZodDefault<z.ZodObject<{
         idPattern: z.ZodDefault<z.ZodString>;
@@ -499,12 +640,52 @@ 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>>;
 }, z.core.$strip>;
 /**
  * TypeScript types inferred from schemas
  */
 export type Directories = z.infer<typeof DirectoriesSchema>;
 export type BeaconPaths = z.infer<typeof BeaconPathsSchema>;
+export type PushRetryConfig = z.infer<typeof PushRetryConfigSchema>;
 export type GitConfig = z.infer<typeof GitConfigSchema>;
 export type WuConfig = z.infer<typeof WuConfigSchema>;
 export type GatesConfig = z.infer<typeof GatesConfigSchema>;
@@ -524,6 +705,9 @@ export type ValidationMode = z.infer<typeof ValidationModeSchema>;
 export type MethodologyTelemetryConfig = z.infer<typeof MethodologyTelemetryConfigSchema>;
 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
@@ -549,6 +733,8 @@ export declare function validateConfig(data: unknown): z.ZodSafeParseResult<{
         skillsDir: string;
         agentsDir: string;
         plansDir: string;
+        templatesDir: string;
+        onboardingDir: string;
     };
     beacon: {
         base: string;
@@ -578,6 +764,13 @@ export declare function validateConfig(data: unknown): z.ZodSafeParseResult<{
         requireRemote: boolean;
         agentBranchPatterns: string[];
         disableAgentPatternRegistry: boolean;
+        push_retry: {
+            enabled: boolean;
+            retries: number;
+            min_delay_ms: number;
+            max_delay_ms: number;
+            jitter: boolean;
+        };
         agentBranchPatternsOverride?: string[];
     };
     wu: {
@@ -697,6 +890,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,24 @@ 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-1325: Lock policy for lane-level WIP enforcement
+ *
+ * Controls how lane locks behave:
+ * - 'all' (default): Lock acquired on claim, held through block, released on done
+ * - 'active': Lock acquired on claim, released on block, re-acquired on unblock
+ * - 'none': No lock files created, WIP checking disabled
+ *
+ * @example
+ * ```yaml
+ * lanes:
+ *   definitions:
+ *     - name: 'Content: Documentation'
+ *       wip_limit: 4
+ *       lock_policy: 'none'  # Docs don't need lock coordination
+ * ```
+ */
+export const LockPolicySchema = z.enum(['all', 'active', 'none']).default('all');
 /**
  * Event archival configuration (WU-1207)
  *
@@ -69,6 +87,10 @@ export const DirectoriesSchema = z.object({
     agentsDir: z.string().default('.claude/agents'),
     /** Plans directory (default: 'docs/04-operations/plans') - WU-1301 */
     plansDir: z.string().default('docs/04-operations/plans'),
+    /** Templates directory (default: '.lumenflow/templates') - WU-1310 */
+    templatesDir: z.string().default('.lumenflow/templates'),
+    /** Onboarding directory (default: 'docs/04-operations/_frameworks/lumenflow/agent/onboarding') - WU-1310 */
+    onboardingDir: z.string().default('docs/04-operations/_frameworks/lumenflow/agent/onboarding'),
 });
 /**
  * Beacon paths configuration (.lumenflow directory structure)
@@ -100,6 +122,45 @@ export const BeaconPathsSchema = z.object({
      */
     eventArchival: EventArchivalConfigSchema.default(() => EventArchivalConfigSchema.parse({})),
 });
+/**
+ * WU-1332: Push retry configuration for micro-worktree operations
+ *
+ * When non-fast-forward push errors occur (origin/main moved during operation),
+ * retry with exponential backoff. Uses p-retry for robust retry behavior.
+ */
+export const PushRetryConfigSchema = z.object({
+    /**
+     * Enable push retry with rebase on non-fast-forward errors.
+     * When true, failed pushes trigger automatic rebase and retry.
+     * When false, the original error is thrown immediately.
+     * @default true
+     */
+    enabled: z.boolean().default(true),
+    /**
+     * Maximum number of retry attempts (including the initial attempt).
+     * After this many failures, the operation fails with clear guidance.
+     * @default 3
+     */
+    retries: z.number().int().positive().default(3),
+    /**
+     * Minimum delay in milliseconds between retries.
+     * Used as the base for exponential backoff.
+     * @default 100
+     */
+    min_delay_ms: z.number().int().nonnegative().default(100),
+    /**
+     * Maximum delay in milliseconds between retries.
+     * Caps the exponential backoff to prevent excessive waits.
+     * @default 1000
+     */
+    max_delay_ms: z.number().int().positive().default(1000),
+    /**
+     * Add randomization to retry delays (recommended for concurrent agents).
+     * Helps prevent thundering herd when multiple agents retry simultaneously.
+     * @default true
+     */
+    jitter: z.boolean().default(true),
+});
 /**
  * Git configuration
  */
@@ -189,6 +250,23 @@ export const GitConfigSchema = z.object({
      * ```
      */
     disableAgentPatternRegistry: z.boolean().default(false),
+    /**
+     * WU-1332: Push retry configuration for micro-worktree operations.
+     * When push fails due to non-fast-forward (origin moved), automatically
+     * rebase and retry with exponential backoff.
+     *
+     * @example
+     * ```yaml
+     * git:
+     *   push_retry:
+     *     enabled: true
+     *     retries: 5        # Try 5 times total
+     *     min_delay_ms: 200 # Start with 200ms delay
+     *     max_delay_ms: 2000 # Cap at 2 second delay
+     *     jitter: true      # Add randomization
+     * ```
+     */
+    push_retry: PushRetryConfigSchema.default(() => PushRetryConfigSchema.parse({})),
 });
 /**
  * WU (Work Unit) configuration
@@ -504,6 +582,89 @@ 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
+ *
+ * Extends the existing lane configuration with lock_policy field.
+ * Compatible with WU-1016 (wip_limit) and WU-1187 (wip_justification).
+ */
+export const LaneDefinitionSchema = z.object({
+    /** Lane name in "Parent: Sublane" format (e.g., "Framework: Core") */
+    name: z.string(),
+    /** WU-1016: Maximum WUs allowed in progress concurrently for this lane */
+    wip_limit: z.number().int().positive().optional(),
+    /** WU-1187: Required justification when wip_limit > 1 */
+    wip_justification: z.string().optional(),
+    /**
+     * WU-1322: Lock policy for this lane.
+     * - 'all': Lock lane for all other agents (default)
+     * - 'active': Lock only for agents with overlapping code_paths
+     * - 'none': No locking (suitable for documentation lanes)
+     *
+     * @default 'all'
+     *
+     * @example
+     * ```yaml
+     * lanes:
+     *   definitions:
+     *     - name: 'Content: Documentation'
+     *       wip_limit: 4
+     *       lock_policy: 'none'  # Docs can be worked in parallel
+     * ```
+     */
+    lock_policy: LockPolicySchema.default('all'),
+    /** 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
  */
@@ -551,6 +712,25 @@ 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(),
 });
 /**
  * Validate configuration data

package/dist/lumenflow-config.d.ts

@@ -72,6 +72,8 @@ export declare function getResolvedPaths(options?: {
     agentsDir: string;
     memoryBank: string;
     plansDir: string;
+    templatesDir: string;
+    onboardingDir: string;
 };
 /**
  * Validate a config file
@@ -93,5 +95,5 @@ export declare function validateConfigFile(configPath: string): {
 export declare function createSampleConfig(outputPath: string, options?: {
     includeComments?: boolean;
 }): void;
-export type { LumenFlowConfig, Directories, BeaconPaths, GitConfig, WuConfig, GatesConfig, MemoryConfig, UiConfig, YamlConfig, } from './lumenflow-config-schema.js';
+export type { LumenFlowConfig, Directories, BeaconPaths, PushRetryConfig, GitConfig, WuConfig, GatesConfig, MemoryConfig, UiConfig, YamlConfig, } from './lumenflow-config-schema.js';
 export { getDefaultConfig } from './lumenflow-config-schema.js';

package/dist/lumenflow-config.js

@@ -55,6 +55,7 @@ function loadConfigFile(projectRoot) {
         return data || {};
     }
     catch (error) {
+        // eslint-disable-next-line no-console -- Config loading runs before logger init
         console.warn(`Warning: Failed to parse ${CONFIG_FILE_NAME}:`, error);
         return null;
     }
@@ -145,6 +146,8 @@ export function getResolvedPaths(options = {}) {
         agentsDir: path.join(projectRoot, config.directories.agentsDir),
         memoryBank: path.join(projectRoot, config.directories.memoryBank),
         plansDir: path.join(projectRoot, config.directories.plansDir),
+        templatesDir: path.join(projectRoot, config.directories.templatesDir),
+        onboardingDir: path.join(projectRoot, config.directories.onboardingDir),
     };
 }
 /**
@@ -206,6 +209,12 @@ directories:
   skillsDir: "${defaultConfig.directories.skillsDir}"
   # Agents directory
   agentsDir: "${defaultConfig.directories.agentsDir}"
+  # Plans directory
+  plansDir: "${defaultConfig.directories.plansDir}"
+  # Templates directory
+  templatesDir: "${defaultConfig.directories.templatesDir}"
+  # Onboarding directory
+  onboardingDir: "${defaultConfig.directories.onboardingDir}"
 
 # Beacon paths (.lumenflow directory structure)
 beacon: