@lumenflow/core 2.7.0 → 2.9.0

package/dist/backlog-editor.js

@@ -1,4 +1,3 @@
-/* eslint-disable security/detect-non-literal-fs-filename, security/detect-object-injection */
 import { existsSync, readFileSync, writeFileSync } from 'node:fs';
 import matter from 'gray-matter';
 import { createError, ErrorCodes } from './error-handler.js';

package/dist/backlog-generator.js

@@ -133,7 +133,7 @@ sections:
     insertion: after_heading_blank_line
 ---
 
-> Agent: Read **docs/04-operations/_frameworks/lumenflow/agent/onboarding/starting-prompt.md** first, then follow **docs/04-operations/\_frameworks/lumenflow/lumenflow-complete.md** for execution.
+> Agent: Read **docs/04-operations/_frameworks/lumenflow/agent/onboarding/starting-prompt.md** first, then follow **docs/04-operations/_frameworks/lumenflow/lumenflow-complete.md** for execution.
 
 # Backlog (single source of truth)
 

package/dist/cleanup-lock.js

@@ -20,7 +20,6 @@
  *
  * @module cleanup-lock
  */
-/* eslint-disable security/detect-non-literal-fs-filename -- Lock file paths are computed from trusted sources */
 import { existsSync, readFileSync, writeFileSync, unlinkSync, mkdirSync, openSync, closeSync, } from 'node:fs';
 import path from 'node:path';
 import crypto from 'node:crypto';

package/dist/code-path-validator.js

@@ -21,7 +21,6 @@
  *
  * Part of INIT-023: Workflow Integrity initiative.
  */
-/* eslint-disable security/detect-non-literal-fs-filename, security/detect-object-injection */
 import path from 'node:path';
 import { existsSync, readFileSync } from 'node:fs';
 import { execSync } from 'node:child_process';

package/dist/commands-logger.js

@@ -12,7 +12,6 @@
  * Legacy format (v1): timestamp | command | branch | worktree
  * - Backward compatible: old entries are parsed with user='unknown' and outcome='unknown'
  */
-/* eslint-disable security/detect-non-literal-fs-filename */
 import fs from 'node:fs';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';

package/dist/compliance-parser.js

@@ -221,7 +221,7 @@ export class ComplianceParser {
             }
             // Parse blockers
             if (inBlockers && trimmedLine.startsWith('-') && !trimmedLine.includes('None')) {
-                const blockerText = trimmedLine.replace(/^-\s*/, '').replace(/^[🔴🟡]\s*/, '');
+                const blockerText = trimmedLine.replace(/^-\s*/, '').replace(/^[🔴🟡]\s*/u, '');
                 if (blockerText.trim()) {
                     currentGap.blockers.push(blockerText.trim());
                     // Also extract any GAP references

package/dist/gates-config.js

@@ -182,7 +182,6 @@ export function loadGatesConfig(projectRoot) {
         // Validate the config
         const result = GatesExecutionConfigSchema.safeParse(executionConfig);
         if (!result.success) {
-            // eslint-disable-next-line no-console -- Intentional warning for invalid config
             console.warn('Warning: Invalid gates.execution config:', result.error.message);
             return null;
         }
@@ -195,7 +194,6 @@ export function loadGatesConfig(projectRoot) {
         return merged;
     }
     catch (error) {
-        // eslint-disable-next-line no-console -- Intentional warning for parse failure
         console.warn(`Warning: Failed to parse ${CONFIG_FILE_NAME}:`, error instanceof Error ? error.message : String(error));
         return null;
     }
@@ -291,14 +289,12 @@ export function loadLaneHealthConfig(projectRoot) {
         // Validate the config value
         const result = LaneHealthModeSchema.safeParse(laneHealthConfig);
         if (!result.success) {
-            // eslint-disable-next-line no-console -- Intentional warning for invalid config
             console.warn(`Warning: Invalid gates.lane_health value '${laneHealthConfig}', expected 'warn', 'error', or 'off'. Using default 'warn'.`);
             return DEFAULT_LANE_HEALTH_MODE;
         }
         return result.data;
     }
     catch (error) {
-        // eslint-disable-next-line no-console -- Intentional warning for parse failure
         console.warn(`Warning: Failed to parse ${CONFIG_FILE_NAME} for lane_health config:`, error instanceof Error ? error.message : String(error));
         return DEFAULT_LANE_HEALTH_MODE;
     }

package/dist/git-adapter.js

@@ -485,7 +485,6 @@ export class GitAdapter {
         catch (err) {
             // If git fails, we still want to clean up the directory
             // Re-throw after cleanup attempt to report the original error
-            // eslint-disable-next-line security/detect-non-literal-fs-filename -- CLI tool with validated worktree path
             if (existsSync(worktreePath)) {
                 rmSync(worktreePath, { recursive: true, force: true });
             }
@@ -493,7 +492,6 @@ export class GitAdapter {
         }
         // Layer 1 defense (WU-1476): Explicit cleanup if directory still exists
         // This handles edge cases where git worktree remove succeeds but leaves the directory
-        // eslint-disable-next-line security/detect-non-literal-fs-filename -- CLI tool with validated worktree path
         if (existsSync(worktreePath)) {
             try {
                 rmSync(worktreePath, { recursive: true, force: true });

package/dist/git-context-extractor.js

@@ -90,7 +90,6 @@ function safeGitExec(args, cwd) {
         // 1. 'git' is a fixed command from PATH (trusted)
         // 2. args are internally constructed, not from user input
         // 3. cwd is validated by the caller (projectRoot from CLI)
-        // eslint-disable-next-line sonarjs/os-command -- safe: git is trusted, args are static
         const result = execSync(cmd, {
             cwd,
             encoding: 'utf-8',
@@ -124,7 +123,6 @@ export function extractGitContext(projectRoot, options = {}) {
     try {
         // Check if this is a git repo using execSync directly
         // SECURITY: This is a static command with no user input
-        // eslint-disable-next-line sonarjs/no-os-command-from-path -- safe: static command
         execSync('git rev-parse --is-inside-work-tree', {
             cwd: projectRoot,
             encoding: 'utf-8',
@@ -441,7 +439,6 @@ export function getChurnMetrics(projectRoot, options = {}) {
     try {
         /// SECURITY: all args are constructed internally (no user input)
         const cmd = ['git', ...args].join(' ');
-        // eslint-disable-next-line sonarjs/os-command -- safe: git is trusted, args are static
         output = execSync(cmd, {
             cwd: projectRoot,
             encoding: 'utf-8',

package/dist/lane-checker.js

@@ -200,7 +200,6 @@ function validateParentOnlyFormat(trimmed, configPath, strict) {
             throw createError(ErrorCodes.INVALID_LANE, message, { lane: trimmed, validSubLanes });
         }
         // Non-strict mode: warn only for existing WU validation
-        // eslint-disable-next-line no-console -- Intentional operational logging
         console.warn(`${PREFIX} ⚠️  ${message}`);
     }
     return { valid: true, parent: trimmed, error: null };
@@ -514,7 +513,6 @@ function checkWuLaneMatch(activeWuid, wuid, projectRoot, targetLane) {
     }
     const wuPath = path.join(projectRoot, WU_PATHS.WU(activeWuid));
     if (!existsSync(wuPath)) {
-        // eslint-disable-next-line no-console -- Intentional operational logging
         console.warn(`${PREFIX} Warning: ${activeWuid} referenced in status.md but ${wuPath} not found`);
         return null;
     }
@@ -522,7 +520,6 @@ function checkWuLaneMatch(activeWuid, wuid, projectRoot, targetLane) {
         const wuContent = readFileSync(wuPath, { encoding: 'utf-8' });
         const wuDoc = parseYAML(wuContent);
         if (!wuDoc || !wuDoc.lane) {
-            // eslint-disable-next-line no-console -- Intentional operational logging
             console.warn(`${PREFIX} Warning: ${activeWuid} has no lane field`);
             return null;
         }
@@ -534,7 +531,6 @@ function checkWuLaneMatch(activeWuid, wuid, projectRoot, targetLane) {
     }
     catch (e) {
         const errMessage = e instanceof Error ? e.message : String(e);
-        // eslint-disable-next-line no-console -- Intentional operational logging
         console.warn(`${PREFIX} Warning: Failed to parse ${activeWuid} YAML: ${errMessage}`);
     }
     return null;
@@ -692,12 +688,10 @@ export function checkWipJustification(lane, options = {}) {
         const projectRoot = findProjectRoot();
         resolvedConfigPath = path.join(projectRoot, CONFIG_FILES.LUMENFLOW_CONFIG);
     }
-    // eslint-disable-next-line security/detect-non-literal-fs-filename -- Config path is validated
     if (!existsSync(resolvedConfigPath)) {
         return NO_JUSTIFICATION_REQUIRED;
     }
     try {
-        // eslint-disable-next-line security/detect-non-literal-fs-filename -- Config path is validated
         const configContent = readFileSync(resolvedConfigPath, { encoding: 'utf-8' });
         const config = parseYAML(configContent);
         const allLanes = extractAllLanesFromConfig(config);

package/dist/lane-lock.js

@@ -180,7 +180,6 @@ export function acquireLaneLock(lane, wuId, options = {}) {
     // WU-1325: Check lock policy before acquiring
     const lockPolicy = getLockPolicyForLane(lane);
     if (lockPolicy === 'none') {
-        // eslint-disable-next-line no-console -- CLI tool status message
         console.log(`${LOG_PREFIX} Skipping lock acquisition for "${lane}" (lock_policy=none)`);
         return {
             acquired: true,

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

@@ -347,12 +347,40 @@ export declare const ClientSkillsSchema: z.ZodObject<{
     recommended: z.ZodDefault<z.ZodArray<z.ZodString>>;
     byLane: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>>;
 }, z.core.$strip>;
+/**
+ * WU-1367: Client enforcement configuration
+ *
+ * Configures workflow compliance enforcement via Claude Code hooks.
+ * When enabled, hooks block non-compliant operations instead of relying
+ * on agents to remember workflow rules.
+ *
+ * @example
+ * ```yaml
+ * agents:
+ *   clients:
+ *     claude-code:
+ *       enforcement:
+ *         hooks: true
+ *         block_outside_worktree: true
+ *         require_wu_for_edits: true
+ *         warn_on_stop_without_wu_done: true
+ * ```
+ */
+export declare const ClientEnforcementSchema: z.ZodObject<{
+    hooks: z.ZodDefault<z.ZodBoolean>;
+    block_outside_worktree: z.ZodDefault<z.ZodBoolean>;
+    require_wu_for_edits: z.ZodDefault<z.ZodBoolean>;
+    warn_on_stop_without_wu_done: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
+/** WU-1367: TypeScript type for client enforcement config */
+export type ClientEnforcement = z.infer<typeof ClientEnforcementSchema>;
 /**
  * Client configuration (per-client settings)
  */
 export declare const ClientConfigSchema: z.ZodObject<{
     preamble: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodBoolean]>>;
     skillsDir: z.ZodOptional<z.ZodString>;
+    agentsDir: z.ZodOptional<z.ZodString>;
     blocks: z.ZodDefault<z.ZodArray<z.ZodObject<{
         title: z.ZodString;
         content: z.ZodString;
@@ -362,6 +390,12 @@ export declare const ClientConfigSchema: z.ZodObject<{
         recommended: z.ZodDefault<z.ZodArray<z.ZodString>>;
         byLane: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>>;
     }, z.core.$strip>>;
+    enforcement: z.ZodOptional<z.ZodObject<{
+        hooks: z.ZodDefault<z.ZodBoolean>;
+        block_outside_worktree: z.ZodDefault<z.ZodBoolean>;
+        require_wu_for_edits: z.ZodDefault<z.ZodBoolean>;
+        warn_on_stop_without_wu_done: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strip>>;
 }, z.core.$strip>;
 /**
  * Agents configuration
@@ -371,6 +405,7 @@ export declare const AgentsConfigSchema: z.ZodObject<{
     clients: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
         preamble: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodBoolean]>>;
         skillsDir: z.ZodOptional<z.ZodString>;
+        agentsDir: z.ZodOptional<z.ZodString>;
         blocks: z.ZodDefault<z.ZodArray<z.ZodObject<{
             title: z.ZodString;
             content: z.ZodString;
@@ -380,6 +415,12 @@ export declare const AgentsConfigSchema: z.ZodObject<{
             recommended: z.ZodDefault<z.ZodArray<z.ZodString>>;
             byLane: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>>;
         }, z.core.$strip>>;
+        enforcement: z.ZodOptional<z.ZodObject<{
+            hooks: z.ZodDefault<z.ZodBoolean>;
+            block_outside_worktree: z.ZodDefault<z.ZodBoolean>;
+            require_wu_for_edits: z.ZodDefault<z.ZodBoolean>;
+            warn_on_stop_without_wu_done: z.ZodDefault<z.ZodBoolean>;
+        }, z.core.$strip>>;
     }, z.core.$strip>>>;
     methodology: z.ZodDefault<z.ZodObject<{
         enabled: z.ZodDefault<z.ZodBoolean>;
@@ -433,6 +474,41 @@ export declare const TelemetryConfigSchema: z.ZodObject<{
         enabled: z.ZodDefault<z.ZodBoolean>;
     }, z.core.$strip>>;
 }, z.core.$strip>;
+/**
+ * WU-1366: Cleanup trigger options
+ *
+ * Controls when automatic state cleanup runs:
+ * - 'on_done': Run after wu:done success (default)
+ * - 'on_init': Run during lumenflow init
+ * - 'manual': Only run via pnpm state:cleanup
+ */
+export declare const CleanupTriggerSchema: z.ZodDefault<z.ZodEnum<{
+    manual: "manual";
+    on_done: "on_done";
+    on_init: "on_init";
+}>>;
+/** WU-1366: TypeScript type for cleanup trigger */
+export type CleanupTrigger = z.infer<typeof CleanupTriggerSchema>;
+/**
+ * WU-1366: Cleanup configuration schema
+ *
+ * Controls when and how automatic state cleanup runs.
+ *
+ * @example
+ * ```yaml
+ * cleanup:
+ *   trigger: on_done  # on_done | on_init | manual
+ * ```
+ */
+export declare const CleanupConfigSchema: z.ZodObject<{
+    trigger: z.ZodDefault<z.ZodEnum<{
+        manual: "manual";
+        on_done: "on_done";
+        on_init: "on_init";
+    }>>;
+}, z.core.$strip>;
+/** WU-1366: TypeScript type for cleanup config */
+export type CleanupConfig = z.infer<typeof CleanupConfigSchema>;
 /**
  * WU-1345: Lane enforcement configuration schema
  *
@@ -675,6 +751,7 @@ export declare const LumenFlowConfigSchema: z.ZodObject<{
         clients: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
             preamble: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodBoolean]>>;
             skillsDir: z.ZodOptional<z.ZodString>;
+            agentsDir: z.ZodOptional<z.ZodString>;
             blocks: z.ZodDefault<z.ZodArray<z.ZodObject<{
                 title: z.ZodString;
                 content: z.ZodString;
@@ -684,6 +761,12 @@ export declare const LumenFlowConfigSchema: z.ZodObject<{
                 recommended: z.ZodDefault<z.ZodArray<z.ZodString>>;
                 byLane: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>>;
             }, z.core.$strip>>;
+            enforcement: z.ZodOptional<z.ZodObject<{
+                hooks: z.ZodDefault<z.ZodBoolean>;
+                block_outside_worktree: z.ZodDefault<z.ZodBoolean>;
+                require_wu_for_edits: z.ZodDefault<z.ZodBoolean>;
+                warn_on_stop_without_wu_done: z.ZodDefault<z.ZodBoolean>;
+            }, z.core.$strip>>;
         }, z.core.$strip>>>;
         methodology: z.ZodDefault<z.ZodObject<{
             enabled: z.ZodDefault<z.ZodBoolean>;
@@ -705,6 +788,13 @@ export declare const LumenFlowConfigSchema: z.ZodObject<{
         show_next_steps: z.ZodDefault<z.ZodBoolean>;
         recovery_command: z.ZodDefault<z.ZodBoolean>;
     }, z.core.$strip>>;
+    cleanup: z.ZodDefault<z.ZodObject<{
+        trigger: z.ZodDefault<z.ZodEnum<{
+            manual: "manual";
+            on_done: "on_done";
+            on_init: "on_init";
+        }>>;
+    }, z.core.$strip>>;
     telemetry: z.ZodDefault<z.ZodObject<{
         methodology: z.ZodDefault<z.ZodObject<{
             enabled: z.ZodDefault<z.ZodBoolean>;
@@ -970,11 +1060,18 @@ export declare function validateConfig(data: unknown): z.ZodSafeParseResult<{
             }[];
             preamble?: string | boolean;
             skillsDir?: string;
+            agentsDir?: string;
             skills?: {
                 recommended: string[];
                 instructions?: string;
                 byLane?: Record<string, string[]>;
             };
+            enforcement?: {
+                hooks: boolean;
+                block_outside_worktree: boolean;
+                require_wu_for_edits: boolean;
+                warn_on_stop_without_wu_done: boolean;
+            };
         }>;
         methodology: {
             enabled: boolean;
@@ -989,6 +1086,9 @@ export declare function validateConfig(data: unknown): z.ZodSafeParseResult<{
         show_next_steps: boolean;
         recovery_command: boolean;
     };
+    cleanup: {
+        trigger: "manual" | "on_done" | "on_init";
+    };
     telemetry: {
         methodology: {
             enabled: boolean;

package/dist/lumenflow-config-schema.js

@@ -587,6 +587,51 @@ export const ClientSkillsSchema = z.object({
      */
     byLane: z.record(z.string(), z.array(z.string())).optional(),
 });
+/**
+ * WU-1367: Client enforcement configuration
+ *
+ * Configures workflow compliance enforcement via Claude Code hooks.
+ * When enabled, hooks block non-compliant operations instead of relying
+ * on agents to remember workflow rules.
+ *
+ * @example
+ * ```yaml
+ * agents:
+ *   clients:
+ *     claude-code:
+ *       enforcement:
+ *         hooks: true
+ *         block_outside_worktree: true
+ *         require_wu_for_edits: true
+ *         warn_on_stop_without_wu_done: true
+ * ```
+ */
+export const ClientEnforcementSchema = z.object({
+    /**
+     * Enable enforcement hooks.
+     * When true, hooks are generated in .claude/hooks/
+     * @default false
+     */
+    hooks: z.boolean().default(false),
+    /**
+     * Block Write/Edit operations when cwd is not a worktree.
+     * Prevents accidental edits to main checkout.
+     * @default false
+     */
+    block_outside_worktree: z.boolean().default(false),
+    /**
+     * Require a claimed WU for Write/Edit operations.
+     * Ensures all edits are associated with tracked work.
+     * @default false
+     */
+    require_wu_for_edits: z.boolean().default(false),
+    /**
+     * Warn when session ends without wu:done being called.
+     * Reminds agents to complete their work properly.
+     * @default false
+     */
+    warn_on_stop_without_wu_done: z.boolean().default(false),
+});
 /**
  * Client configuration (per-client settings)
  */
@@ -595,10 +640,17 @@ export const ClientConfigSchema = z.object({
     preamble: z.union([z.string(), z.boolean()]).optional(),
     /** Skills directory path */
     skillsDir: z.string().optional(),
+    /** Agents directory path */
+    agentsDir: z.string().optional(),
     /** Client-specific blocks injected into wu:spawn output */
     blocks: z.array(ClientBlockSchema).default([]),
     /** Client-specific skills guidance for wu:spawn */
     skills: ClientSkillsSchema.optional(),
+    /**
+     * WU-1367: Enforcement configuration for Claude Code hooks.
+     * When enabled, generates hooks that enforce workflow compliance.
+     */
+    enforcement: ClientEnforcementSchema.optional(),
 });
 /**
  * Agents configuration
@@ -673,6 +725,37 @@ export const TelemetryConfigSchema = z.object({
      */
     methodology: MethodologyTelemetryConfigSchema.default(() => MethodologyTelemetryConfigSchema.parse({})),
 });
+/**
+ * WU-1366: Cleanup trigger options
+ *
+ * Controls when automatic state cleanup runs:
+ * - 'on_done': Run after wu:done success (default)
+ * - 'on_init': Run during lumenflow init
+ * - 'manual': Only run via pnpm state:cleanup
+ */
+export const CleanupTriggerSchema = z.enum(['on_done', 'on_init', 'manual']).default('on_done');
+/**
+ * WU-1366: Cleanup configuration schema
+ *
+ * Controls when and how automatic state cleanup runs.
+ *
+ * @example
+ * ```yaml
+ * cleanup:
+ *   trigger: on_done  # on_done | on_init | manual
+ * ```
+ */
+export const CleanupConfigSchema = z.object({
+    /**
+     * When to trigger automatic state cleanup.
+     * - 'on_done': Run after wu:done success (default)
+     * - 'on_init': Run during lumenflow init
+     * - 'manual': Only run via pnpm state:cleanup
+     *
+     * @default 'on_done'
+     */
+    trigger: CleanupTriggerSchema,
+});
 /**
  * WU-1345: Lane enforcement configuration schema
  *
@@ -782,6 +865,17 @@ export const LumenFlowConfigSchema = z.object({
     agents: AgentsConfigSchema.default(() => AgentsConfigSchema.parse({})),
     /** Experimental features (WU-1090) */
     experimental: ExperimentalConfigSchema.default(() => ExperimentalConfigSchema.parse({})),
+    /**
+     * WU-1366: Cleanup configuration
+     * Controls when automatic state cleanup runs.
+     *
+     * @example
+     * ```yaml
+     * cleanup:
+     *   trigger: on_done  # on_done | on_init | manual
+     * ```
+     */
+    cleanup: CleanupConfigSchema.default(() => CleanupConfigSchema.parse({})),
     /**
      * WU-1270: Telemetry configuration
      * Opt-in telemetry features for adoption tracking.
@@ -866,7 +960,6 @@ export const LumenFlowConfigSchema = z.object({
  * @param data - Configuration data to validate
  * @returns Validation result with parsed config or errors
  */
-// eslint-disable-next-line @typescript-eslint/explicit-function-return-type -- Zod v4 return type inference
 export function validateConfig(data) {
     return LumenFlowConfigSchema.safeParse(data);
 }

package/dist/lumenflow-config.js

@@ -55,7 +55,6 @@ 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;
     }

package/dist/micro-worktree.d.ts

@@ -105,6 +105,15 @@ export declare const LUMENFLOW_FORCE_ENV = "LUMENFLOW_FORCE";
  * WU-1081: Exported for use in micro-worktree push operations.
  */
 export declare const LUMENFLOW_FORCE_REASON_ENV = "LUMENFLOW_FORCE_REASON";
+/**
+ * Environment variable name for LUMENFLOW_WU_TOOL
+ *
+ * WU-1365: Exported for use by CLI commands that use micro-worktree operations.
+ * The pre-push hook checks this env var to allow micro-worktree pushes to main.
+ * Valid values are: wu-create, wu-edit, wu-done, wu-delete, wu-claim, wu-block,
+ * wu-unblock, initiative-create, initiative-edit, release
+ */
+export declare const LUMENFLOW_WU_TOOL_ENV = "LUMENFLOW_WU_TOOL";
 /**
  * Default log prefix for micro-worktree operations
  *
@@ -279,10 +288,24 @@ export declare function cleanupMicroWorktree(worktreePath: string, branchName: s
  * @returns {Promise<void>}
  */
 export declare function stageChangesWithDeletions(gitWorktree: GitAdapter, files: string[] | undefined): Promise<void>;
+/**
+ * WU-1365: Check if prettier is available in the project
+ *
+ * Checks if prettier is installed and executable. Returns false if:
+ * - prettier is not in node_modules
+ * - pnpm prettier command is not available
+ *
+ * This allows micro-worktree operations to skip formatting gracefully
+ * when prettier is not installed (e.g., in bootstrap or minimal setups).
+ *
+ * @returns {boolean} True if prettier is available, false otherwise
+ */
+export declare function isPrettierAvailable(): boolean;
 /**
  * Format files using prettier before committing
  *
  * WU-1435: Ensures committed files pass format gates.
+ * WU-1365: Gracefully handles missing prettier installation.
  * Runs prettier --write on specified files within the micro-worktree.
  *
  * @param {string[]} files - Relative file paths to format

package/dist/micro-worktree.js

@@ -77,6 +77,15 @@ export const LUMENFLOW_FORCE_ENV = 'LUMENFLOW_FORCE';
  * WU-1081: Exported for use in micro-worktree push operations.
  */
 export const LUMENFLOW_FORCE_REASON_ENV = 'LUMENFLOW_FORCE_REASON';
+/**
+ * Environment variable name for LUMENFLOW_WU_TOOL
+ *
+ * WU-1365: Exported for use by CLI commands that use micro-worktree operations.
+ * The pre-push hook checks this env var to allow micro-worktree pushes to main.
+ * Valid values are: wu-create, wu-edit, wu-done, wu-delete, wu-claim, wu-block,
+ * wu-unblock, initiative-create, initiative-edit, release
+ */
+export const LUMENFLOW_WU_TOOL_ENV = 'LUMENFLOW_WU_TOOL';
 /**
  * Default log prefix for micro-worktree operations
  *
@@ -322,7 +331,6 @@ export async function cleanupOrphanedMicroWorktree(operation, id, gitAdapter, lo
  */
 function tryFilesystemCleanup(worktreePath) {
     try {
-        // eslint-disable-next-line security/detect-non-literal-fs-filename -- CLI tool with validated worktree path
         if (existsSync(worktreePath)) {
             rmSync(worktreePath, { recursive: true, force: true });
         }
@@ -372,7 +380,6 @@ export async function cleanupMicroWorktree(worktreePath, branchName, logPrefix =
     console.log(`${logPrefix} Cleaning up micro-worktree...`);
     const mainGit = getGitForCwd();
     // Remove the known worktree path first (must be done before deleting branch)
-    // eslint-disable-next-line security/detect-non-literal-fs-filename -- CLI tool with validated worktree path
     if (existsSync(worktreePath)) {
         await removeWorktreeSafe(mainGit, worktreePath, logPrefix);
     }
@@ -443,10 +450,56 @@ export async function stageChangesWithDeletions(gitWorktree, files) {
     const filesToStage = files || [];
     await gitWorktree.addWithDeletions(filesToStage);
 }
+/**
+ * WU-1365: Check if prettier is available in the project
+ *
+ * Checks if prettier is installed and executable. Returns false if:
+ * - prettier is not in node_modules
+ * - pnpm prettier command is not available
+ *
+ * This allows micro-worktree operations to skip formatting gracefully
+ * when prettier is not installed (e.g., in bootstrap or minimal setups).
+ *
+ * @returns {boolean} True if prettier is available, false otherwise
+ */
+export function isPrettierAvailable() {
+    try {
+        // Check if prettier is available by running pnpm prettier --version
+        // Note: This uses execSync with a known-safe command (no user input)
+        execSync(`${PKG_MANAGER} ${SCRIPTS.PRETTIER} --version`, {
+            encoding: 'utf-8',
+            stdio: STDIO_MODES.PIPE,
+        });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * WU-1365: Pattern to detect prettier not found errors
+ */
+const PRETTIER_NOT_FOUND_PATTERNS = [
+    /ERR_PNPM_RECURSIVE_EXEC_FIRST_FAIL/,
+    /prettier.*not found/i,
+    /Cannot find module.*prettier/i,
+    /Command failed.*prettier/i,
+    /No script.*prettier/i,
+];
+/**
+ * WU-1365: Check if an error indicates prettier is not available
+ *
+ * @param {string} errMsg - Error message to check
+ * @returns {boolean} True if the error indicates prettier is not installed/available
+ */
+function isPrettierNotFoundError(errMsg) {
+    return PRETTIER_NOT_FOUND_PATTERNS.some((pattern) => pattern.test(errMsg));
+}
 /**
  * Format files using prettier before committing
  *
  * WU-1435: Ensures committed files pass format gates.
+ * WU-1365: Gracefully handles missing prettier installation.
  * Runs prettier --write on specified files within the micro-worktree.
  *
  * @param {string[]} files - Relative file paths to format
@@ -462,7 +515,7 @@ export async function formatFiles(files, worktreePath, logPrefix = DEFAULT_LOG_P
     const absolutePaths = files.map((f) => join(worktreePath, f));
     const pathArgs = absolutePaths.map((p) => JSON.stringify(p)).join(' ');
     try {
-        // eslint-disable-next-line sonarjs/os-command -- CLI tool executing known safe prettier command with validated paths
+        // Note: This uses execSync with validated paths (built from worktreePath and file list)
         execSync(`${PKG_MANAGER} ${SCRIPTS.PRETTIER} ${PRETTIER_FLAGS.WRITE} ${pathArgs}`, {
             encoding: 'utf-8',
             stdio: STDIO_MODES.PIPE,
@@ -471,8 +524,15 @@ export async function formatFiles(files, worktreePath, logPrefix = DEFAULT_LOG_P
         console.log(`${logPrefix} ✅ Files formatted`);
     }
     catch (err) {
-        // Log warning but don't fail - some files may not need formatting
         const errMsg = err instanceof Error ? err.message : String(err);
+        // WU-1365: Check if the error is due to prettier not being available
+        if (isPrettierNotFoundError(errMsg)) {
+            console.warn(`${logPrefix} ⚠️  Skipping formatting: prettier not available.\n` +
+                `    To enable formatting, install prettier: pnpm add -D prettier\n` +
+                `    Files will be committed without formatting.`);
+            return;
+        }
+        // Log warning but don't fail - some files may not need formatting
         console.warn(`${logPrefix} ⚠️  Formatting warning: ${errMsg}`);
     }
 }
@@ -538,7 +598,6 @@ export async function mergeWithRetry(tempBranchName, microWorktreePath, logPrefi
  * @throws {Error} If push fails after all retries
  */
 export async function pushWithRetry(mainGit, worktreeGit, remote, branch, tempBranchName, logPrefix = DEFAULT_LOG_PREFIX) {
-    // eslint-disable-next-line sonarjs/deprecation -- Using deprecated constant for backwards compatibility
     const maxRetries = MAX_PUSH_RETRIES;
     for (let attempt = 1; attempt <= maxRetries; attempt++) {
         try {

package/dist/piped-command-detector.js

@@ -58,7 +58,6 @@ export function containsPnpmDependencyCommand(command) {
     if (!command || typeof command !== 'string') {
         return false;
     }
-    // eslint-disable-next-line security/detect-non-literal-regexp -- Pattern built from const array, not user input
     const pattern = new RegExp(`pnpm\\s+(${DEPENDENCY_COMMANDS.join('|')})\\b`, 'i');
     return pattern.test(command);
 }

package/dist/rollback-utils.js

@@ -7,7 +7,6 @@
  *
  * @see {@link packages/@lumenflow/cli/src/wu-done.ts} - Consumer (rollbackTransaction function)
  */
-/* eslint-disable security/detect-non-literal-fs-filename */
 import { writeFileSync, unlinkSync } from 'node:fs';
 /**
  * Result of a rollback operation.

package/dist/stamp-utils.js

@@ -9,7 +9,6 @@
  * Stamp files (.lumenflow/stamps/WU-{id}.done) serve as completion markers
  * Used by wu:done, wu:recovery, and validation tools
  */
-/* eslint-disable security/detect-non-literal-fs-filename */
 import { existsSync, writeFileSync, mkdirSync } from 'node:fs';
 import { readFile, access } from 'node:fs/promises';
 import { constants } from 'node:fs';

package/dist/worktree-symlink.js

@@ -74,7 +74,6 @@ function checkSymlinkTarget(linkTarget, basePath) {
         ? linkTarget
         : path.resolve(basePath, linkTarget);
     const isWorktreePath = absoluteTarget.includes(WORKTREES_PATH_SEGMENT);
-    // eslint-disable-next-line security/detect-non-literal-fs-filename -- validated path from symlink
     const isBroken = isWorktreePath && !fs.existsSync(absoluteTarget);
     return { isWorktreePath, absoluteTarget, isBroken };
 }
@@ -86,7 +85,6 @@ function checkSymlinkTarget(linkTarget, basePath) {
  * @param {{hasWorktreeSymlinks: boolean, brokenSymlinks: string[]}} result - Result object to mutate
  */
 function processSymlinkEntry(entryPath, basePath, result) {
-    // eslint-disable-next-line security/detect-non-literal-fs-filename -- validated path from directory scan
     const linkTarget = fs.readlinkSync(entryPath);
     const check = checkSymlinkTarget(linkTarget, basePath);
     if (check.isWorktreePath) {
@@ -105,7 +103,6 @@ function processSymlinkEntry(entryPath, basePath, result) {
  */
 function scanPnpmForWorktreeSymlinks(pnpmPath) {
     const result = { hasWorktreeSymlinks: false, brokenSymlinks: [] };
-    // eslint-disable-next-line security/detect-non-literal-fs-filename -- validated path
     const entries = fs.readdirSync(pnpmPath, { withFileTypes: true });
     for (const entry of entries) {
         if (entry.isSymbolicLink()) {
@@ -127,11 +124,9 @@ function scanPnpmForWorktreeSymlinks(pnpmPath) {
  */
 export function hasWorktreePathSymlinks(nodeModulesPath) {
     const result = { hasWorktreeSymlinks: false, brokenSymlinks: [] };
-    // eslint-disable-next-line security/detect-non-literal-fs-filename -- validated path
     if (!fs.existsSync(nodeModulesPath)) {
         return result;
     }
-    // eslint-disable-next-line security/detect-non-literal-fs-filename -- validated path
     const entries = fs.readdirSync(nodeModulesPath, { withFileTypes: true });
     for (const entry of entries) {
         const entryPath = path.join(nodeModulesPath, entry.name);
@@ -156,7 +151,6 @@ export function hasWorktreePathSymlinks(nodeModulesPath) {
  */
 function nodeModulesExists(targetPath) {
     try {
-        // eslint-disable-next-line security/detect-non-literal-fs-filename -- validated worktree path
         fs.lstatSync(targetPath);
         return true;
     }
@@ -219,7 +213,6 @@ export function symlinkNodeModules(worktreePath, logger = console, mainRepoPath
         }
     }
     try {
-        // eslint-disable-next-line security/detect-non-literal-fs-filename -- validated worktree path
         fs.symlinkSync(RELATIVE_NODE_MODULES_PATH, targetPath);
         if (logger.info) {
             logger.info(`${LOG_PREFIX.CLAIM} node_modules symlink created -> ${RELATIVE_NODE_MODULES_PATH}`);
@@ -241,11 +234,9 @@ export function symlinkNodeModules(worktreePath, logger = console, mainRepoPath
  * @returns {boolean} True if should skip
  */
 function shouldSkipNestedPackage(targetDir, sourceNodeModules) {
-    // eslint-disable-next-line security/detect-non-literal-fs-filename -- validated paths
     if (!fs.existsSync(targetDir)) {
         return true;
     }
-    // eslint-disable-next-line security/detect-non-literal-fs-filename -- validated paths
     if (!fs.existsSync(sourceNodeModules)) {
         return true;
     }
@@ -263,7 +254,6 @@ function shouldSkipNestedPackage(targetDir, sourceNodeModules) {
 function handleExistingNestedNodeModules(targetNodeModules, pkgPath, logger, errors) {
     let targetStat;
     try {
-        // eslint-disable-next-line security/detect-non-literal-fs-filename -- validated paths
         targetStat = fs.lstatSync(targetNodeModules);
     }
     catch {
@@ -278,7 +268,6 @@ function handleExistingNestedNodeModules(targetNodeModules, pkgPath, logger, err
         return 'skip';
     }
     // Check if directory has meaningful content
-    // eslint-disable-next-line security/detect-non-literal-fs-filename -- validated paths
     const contents = fs.readdirSync(targetNodeModules);
     const hasMeaningfulContent = contents.some((item) => !item.startsWith('.') && item !== '.vite' && item !== '.turbo');
     if (hasMeaningfulContent) {
@@ -335,7 +324,6 @@ export function symlinkNestedNodeModules(worktreePath, mainRepoPath, logger = nu
         }
         try {
             const relativePath = path.relative(targetDir, sourceNodeModules);
-            // eslint-disable-next-line security/detect-non-literal-fs-filename -- validated paths
             fs.symlinkSync(relativePath, targetNodeModules);
             created++;
             if (logger?.info) {

package/dist/wu-consistency-checker.d.ts

@@ -102,6 +102,11 @@ interface ConsistencyError {
  * in a micro-worktree, then committed and pushed to origin/main.
  * This prevents direct writes to the main checkout.
  *
+ * WU-1370: When projectRoot is explicitly provided (not process.cwd()), the caller
+ * is already inside a micro-worktree context (e.g., handleOrphanCheck during wu:claim).
+ * In this case, skip creating a nested micro-worktree and work directly in projectRoot.
+ * This prevents local main drift from nested micro-worktrees merging before pushing.
+ *
  * @param {object} report - Report from checkWUConsistency()
  * @param {RepairWUInconsistencyOptions} [options={}] - Repair options
  * @returns {Promise<object>} Result with repaired, skipped, and failed counts

package/dist/wu-consistency-checker.js

@@ -271,12 +271,21 @@ function categorizeErrors(errors) {
  * in a micro-worktree, then committed and pushed to origin/main.
  * This prevents direct writes to the main checkout.
  *
+ * WU-1370: When projectRoot is explicitly provided (not process.cwd()), the caller
+ * is already inside a micro-worktree context (e.g., handleOrphanCheck during wu:claim).
+ * In this case, skip creating a nested micro-worktree and work directly in projectRoot.
+ * This prevents local main drift from nested micro-worktrees merging before pushing.
+ *
  * @param {object} report - Report from checkWUConsistency()
  * @param {RepairWUInconsistencyOptions} [options={}] - Repair options
  * @returns {Promise<object>} Result with repaired, skipped, and failed counts
  */
 export async function repairWUInconsistency(report, options = {}) {
-    const { dryRun = false, projectRoot = process.cwd() } = options;
+    const { dryRun = false, projectRoot } = options;
+    // WU-1370: Detect if projectRoot was explicitly provided
+    // If provided, we're inside a micro-worktree and should work directly in projectRoot
+    const isInsideMicroWorktree = projectRoot !== undefined;
+    const effectiveProjectRoot = projectRoot ?? process.cwd();
     if (report.valid) {
         return { repaired: 0, skipped: 0, failed: 0 };
     }
@@ -292,60 +301,93 @@ export async function repairWUInconsistency(report, options = {}) {
             failed: 0,
         };
     }
-    // Step 1: Process file-based repairs via micro-worktree (batched)
+    // Step 1: Process file-based repairs
     if (fileRepairs.length > 0) {
-        try {
-            // Generate a batch ID from the WU IDs being repaired
-            const batchId = `batch-${fileRepairs.map((e) => e.wuId).join('-')}`.slice(0, 50);
-            await withMicroWorktree({
-                operation: 'wu-repair',
-                id: batchId,
-                logPrefix: LOG_PREFIX.REPAIR,
-                execute: async ({ worktreePath }) => {
-                    const filesModified = [];
-                    for (const error of fileRepairs) {
-                        try {
-                            const result = await repairSingleErrorInWorktree(error, worktreePath, projectRoot);
-                            if (result.success && result.files) {
-                                filesModified.push(...result.files);
-                                repaired++;
-                            }
-                            else if (result.skipped) {
-                                skipped++;
-                                if (result.reason) {
-                                    console.warn(`${LOG_PREFIX.REPAIR} Skipped ${error.type}: ${result.reason}`);
+        // WU-1370: When projectRoot is provided, we're already in a micro-worktree context
+        // (e.g., called from handleOrphanCheck during wu:claim). Work directly in projectRoot
+        // instead of creating a nested micro-worktree.
+        if (isInsideMicroWorktree) {
+            // Direct repair mode: work in the provided projectRoot
+            for (const error of fileRepairs) {
+                try {
+                    // When inside a micro-worktree, worktreePath === projectRoot
+                    // We're both reading from and writing to the same location
+                    const result = await repairSingleErrorInWorktree(error, effectiveProjectRoot, effectiveProjectRoot);
+                    if (result.success && result.files) {
+                        repaired++;
+                    }
+                    else if (result.skipped) {
+                        skipped++;
+                        if (result.reason) {
+                            console.warn(`${LOG_PREFIX.REPAIR} Skipped ${error.type}: ${result.reason}`);
+                        }
+                    }
+                    else {
+                        failed++;
+                    }
+                }
+                catch (err) {
+                    const errMessage = err instanceof Error ? err.message : String(err);
+                    console.error(`${LOG_PREFIX.REPAIR} Failed to repair ${error.type}: ${errMessage}`);
+                    failed++;
+                }
+            }
+        }
+        else {
+            // Standard mode: create micro-worktree for isolation
+            try {
+                // Generate a batch ID from the WU IDs being repaired
+                const batchId = `batch-${fileRepairs.map((e) => e.wuId).join('-')}`.slice(0, 50);
+                await withMicroWorktree({
+                    operation: 'wu-repair',
+                    id: batchId,
+                    logPrefix: LOG_PREFIX.REPAIR,
+                    execute: async ({ worktreePath }) => {
+                        const filesModified = [];
+                        for (const error of fileRepairs) {
+                            try {
+                                const result = await repairSingleErrorInWorktree(error, worktreePath, effectiveProjectRoot);
+                                if (result.success && result.files) {
+                                    filesModified.push(...result.files);
+                                    repaired++;
+                                }
+                                else if (result.skipped) {
+                                    skipped++;
+                                    if (result.reason) {
+                                        console.warn(`${LOG_PREFIX.REPAIR} Skipped ${error.type}: ${result.reason}`);
+                                    }
+                                }
+                                else {
+                                    failed++;
                                 }
                             }
-                            else {
+                            catch (err) {
+                                const errMessage = err instanceof Error ? err.message : String(err);
+                                console.error(`${LOG_PREFIX.REPAIR} Failed to repair ${error.type}: ${errMessage}`);
                                 failed++;
                             }
                         }
-                        catch (err) {
-                            const errMessage = err instanceof Error ? err.message : String(err);
-                            console.error(`${LOG_PREFIX.REPAIR} Failed to repair ${error.type}: ${errMessage}`);
-                            failed++;
-                        }
-                    }
-                    // Deduplicate files
-                    const uniqueFiles = [...new Set(filesModified)];
-                    return {
-                        commitMessage: `fix: repair ${repaired} WU inconsistencies`,
-                        files: uniqueFiles,
-                    };
-                },
-            });
-        }
-        catch (err) {
-            // If micro-worktree fails, mark all file repairs as failed
-            const errMessage = err instanceof Error ? err.message : String(err);
-            console.error(`${LOG_PREFIX.REPAIR} Micro-worktree operation failed: ${errMessage}`);
-            failed += fileRepairs.length - repaired;
+                        // Deduplicate files
+                        const uniqueFiles = [...new Set(filesModified)];
+                        return {
+                            commitMessage: `fix: repair ${repaired} WU inconsistencies`,
+                            files: uniqueFiles,
+                        };
+                    },
+                });
+            }
+            catch (err) {
+                // If micro-worktree fails, mark all file repairs as failed
+                const errMessage = err instanceof Error ? err.message : String(err);
+                console.error(`${LOG_PREFIX.REPAIR} Micro-worktree operation failed: ${errMessage}`);
+                failed += fileRepairs.length - repaired;
+            }
         }
     }
     // Step 2: Process git-only repairs (worktree/branch cleanup) directly
     for (const error of gitOnlyRepairs) {
         try {
-            const result = await repairGitOnlyError(error, projectRoot);
+            const result = await repairGitOnlyError(error, effectiveProjectRoot);
             if (result.success) {
                 repaired++;
             }

package/dist/wu-constants.js

@@ -1400,7 +1400,6 @@ export const PATH_LITERALS = {
     /** Plan file suffix for WU plans */
     PLAN_FILE_SUFFIX: '-plan.md',
     /** Trailing slash regex pattern */
-    // eslint-disable-next-line sonarjs/slow-regex -- False positive: simple end-anchor regex, no catastrophic backtracking possible
     TRAILING_SLASH_REGEX: /\/+$/,
 };
 /**

package/dist/wu-done-worktree.js

@@ -590,7 +590,6 @@ const WU_EVENTS_PATH = path.join('.lumenflow', 'state', WU_EVENTS_FILE_NAME);
 function normalizeEventForKey(event) {
     const normalized = {};
     for (const key of Object.keys(event).sort()) {
-        // eslint-disable-next-line security/detect-object-injection -- keys derived from object keys
         normalized[key] = event[key];
     }
     return normalized;

package/dist/wu-events-cleanup.js

@@ -141,7 +141,6 @@ export function shouldArchiveEvent(event, config, context) {
 async function loadAllEvents(baseDir) {
     const eventsPath = path.join(baseDir, LUMENFLOW_PATHS.STATE_DIR, WU_EVENTS_FILE_NAME);
     try {
-        // eslint-disable-next-line security/detect-non-literal-fs-filename -- CLI tool reads known path
         const content = await fs.readFile(eventsPath, { encoding: 'utf-8' });
         const lines = content.split('\n').filter((line) => line.trim());
         return lines.map((line) => {
@@ -311,7 +310,6 @@ async function appendToArchive(baseDir, archivePath, events) {
     mkdirSync(dirPath, { recursive: true });
     const content = events.map((e) => JSON.stringify(e)).join('\n') + '\n';
     // Append to archive file (creates if doesn't exist)
-    // eslint-disable-next-line security/detect-non-literal-fs-filename -- CLI tool writes known path
     await fs.appendFile(fullPath, content, 'utf-8');
 }
 /**

package/dist/wu-preflight-validators.js

@@ -18,7 +18,6 @@
  * - Clear error messages pointing to missing files
  * - Reusable by wu:done for early validation
  */
-/* eslint-disable security/detect-non-literal-fs-filename, security/detect-object-injection */
 import { existsSync } from 'node:fs';
 import path from 'node:path';
 import { WU_PATHS } from './wu-paths.js';
@@ -184,7 +183,8 @@ export async function validatePreflight(id, options = {}) {
     const wuPath = path.join(worktreePath, WU_PATHS.WU(id));
     // Debug logging for YAML source (WU-1830)
     if (options.worktreePath && options.worktreePath !== rootDir) {
-        process.env.DEBUG && console.log(`[wu-preflight] Reading WU YAML from worktree: ${wuPath}`);
+        if (process.env.DEBUG)
+            console.log(`[wu-preflight] Reading WU YAML from worktree: ${wuPath}`);
     }
     let doc;
     try {
@@ -224,7 +224,8 @@ export async function validatePreflight(id, options = {}) {
             suggestedTestPaths = await findSuggestedTestPaths(missingTestPaths, searchRoot);
         }
         catch (err) {
-            process.env.DEBUG && console.log(`[wu-preflight] Failed to find suggestions: ${err.message}`);
+            if (process.env.DEBUG)
+                console.log(`[wu-preflight] Failed to find suggestions: ${err.message}`);
         }
     }
     return createPreflightResult({

package/dist/wu-schema.js

@@ -860,7 +860,6 @@ function detectNormalizationChanges(original, normalized) {
         return true;
     }
     for (let i = 0; i < origPaths.length; i++) {
-        // eslint-disable-next-line security/detect-object-injection
         if (origPaths[i] !== normPaths[i]) {
             return true;
         }
@@ -871,7 +870,6 @@ function detectNormalizationChanges(original, normalized) {
             return true;
         }
         for (let i = 0; i < original.acceptance.length; i++) {
-            // eslint-disable-next-line security/detect-object-injection
             if (original.acceptance[i] !== normalized.acceptance[i]) {
                 return true;
             }

package/dist/wu-status-updater.js

@@ -6,7 +6,6 @@
  *
  * Used by both main wu:done flow AND recovery mode (DRY principle)
  */
-/* eslint-disable security/detect-non-literal-fs-filename, security/detect-object-injection */
 import { existsSync, readFileSync, writeFileSync } from 'node:fs';
 import { parseBacklogFrontmatter } from './backlog-parser.js';
 import { getSectionHeadingsWithDefaults } from './section-headings.js';

package/dist/wu-transaction-collectors.js

@@ -22,7 +22,6 @@
  * tx.commit();
  * ```
  */
-/* eslint-disable security/detect-non-literal-fs-filename, security/detect-object-injection */
 import { existsSync, readFileSync } from 'node:fs';
 import { stringifyYAML } from './wu-yaml.js';
 import { parseBacklogFrontmatter } from './backlog-parser.js';

package/package.json

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