@lumenflow/core 2.5.0 → 2.5.1

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

@@ -357,6 +357,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 +383,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
  */
@@ -571,6 +640,45 @@ 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
@@ -598,6 +706,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
@@ -780,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

@@ -582,6 +582,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 +634,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 +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/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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lumenflow/core",
-  "version": "2.5.0",
+  "version": "2.5.1",
   "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.5.1"
   },
   "peerDependenciesMeta": {
     "@lumenflow/memory": {