@lumenflow/core 1.0.0 → 1.3.2

package/dist/lumenflow-home.js

@@ -0,0 +1,208 @@
+/**
+ * LumenFlow Home Directory Resolution
+ *
+ * WU-1062: External plan storage and no-main-write mode
+ *
+ * Provides helpers for resolving the $LUMENFLOW_HOME directory and related paths.
+ * Plans are stored externally in $LUMENFLOW_HOME/plans/ instead of in the repo.
+ *
+ * Default: ~/.lumenflow/
+ * Override: Set $LUMENFLOW_HOME environment variable
+ *
+ * @module
+ */
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+/**
+ * Environment variable name for LumenFlow home directory
+ */
+export const LUMENFLOW_HOME_ENV = 'LUMENFLOW_HOME';
+/**
+ * Default LumenFlow home directory name
+ */
+export const DEFAULT_LUMENFLOW_DIR = '.lumenflow';
+/**
+ * Plans subdirectory name
+ */
+export const PLANS_SUBDIR = 'plans';
+/**
+ * Custom protocol for external LumenFlow paths
+ */
+export const LUMENFLOW_PROTOCOL = 'lumenflow://';
+/**
+ * Environment variable prefix for spec_refs
+ */
+export const LUMENFLOW_HOME_VAR_PREFIX = '$LUMENFLOW_HOME';
+/**
+ * Expand ~ to user's home directory
+ *
+ * @param {string} path - Path that may contain ~
+ * @returns {string} Expanded path
+ */
+function expandTilde(path) {
+    if (path.startsWith('~/')) {
+        return join(homedir(), path.slice(2));
+    }
+    if (path === '~') {
+        return homedir();
+    }
+    return path;
+}
+/**
+ * Remove trailing slashes from path
+ *
+ * @param {string} path - Path that may have trailing slashes
+ * @returns {string} Path without trailing slashes
+ */
+function removeTrailingSlash(path) {
+    return path.replace(/\/+$/, '');
+}
+/**
+ * Get the LumenFlow home directory path
+ *
+ * Resolution order:
+ * 1. $LUMENFLOW_HOME environment variable (with ~ expansion)
+ * 2. ~/.lumenflow/ default
+ *
+ * @returns {string} Absolute path to LumenFlow home directory
+ *
+ * @example
+ * // With LUMENFLOW_HOME=/custom/path
+ * getLumenflowHome() // '/custom/path'
+ *
+ * @example
+ * // With LUMENFLOW_HOME=~/.custom-lumenflow
+ * getLumenflowHome() // '/home/user/.custom-lumenflow'
+ *
+ * @example
+ * // Without LUMENFLOW_HOME set
+ * getLumenflowHome() // '/home/user/.lumenflow'
+ */
+export function getLumenflowHome() {
+    const envValue = process.env[LUMENFLOW_HOME_ENV];
+    if (envValue) {
+        const expanded = expandTilde(envValue);
+        return removeTrailingSlash(expanded);
+    }
+    return join(homedir(), DEFAULT_LUMENFLOW_DIR);
+}
+/**
+ * Get the plans directory path
+ *
+ * Plans are stored in $LUMENFLOW_HOME/plans/
+ *
+ * @returns {string} Absolute path to plans directory
+ *
+ * @example
+ * getPlansDir() // '/home/user/.lumenflow/plans'
+ */
+export function getPlansDir() {
+    return join(getLumenflowHome(), PLANS_SUBDIR);
+}
+/**
+ * Check if a path is an external (non-repo) path
+ *
+ * External paths include:
+ * - Paths starting with ~/
+ * - Paths starting with $LUMENFLOW_HOME
+ * - Paths using lumenflow:// protocol
+ * - Absolute paths (starting with /)
+ *
+ * @param {string} path - Path to check
+ * @returns {boolean} True if path is external
+ *
+ * @example
+ * isExternalPath('~/.lumenflow/plans/plan.md') // true
+ * isExternalPath('$LUMENFLOW_HOME/plans/plan.md') // true
+ * isExternalPath('lumenflow://plans/plan.md') // true
+ * isExternalPath('/home/user/.lumenflow/plans/plan.md') // true
+ * isExternalPath('docs/04-operations/plans/plan.md') // false
+ */
+export function isExternalPath(path) {
+    // Check for tilde-prefixed paths
+    if (path.startsWith('~/')) {
+        return true;
+    }
+    // Check for environment variable reference
+    if (path.startsWith(LUMENFLOW_HOME_VAR_PREFIX)) {
+        return true;
+    }
+    // Check for lumenflow:// protocol
+    if (path.startsWith(LUMENFLOW_PROTOCOL)) {
+        return true;
+    }
+    // Check for absolute paths (starting with /)
+    if (path.startsWith('/')) {
+        return true;
+    }
+    return false;
+}
+/**
+ * Normalize a spec_ref path by expanding variables and protocols
+ *
+ * Expands:
+ * - lumenflow://path -> $LUMENFLOW_HOME/path
+ * - ~/path -> /home/user/path
+ * - $LUMENFLOW_HOME/path -> actual LUMENFLOW_HOME value
+ *
+ * Repo-relative paths are returned unchanged.
+ *
+ * @param {string} specRef - Spec reference path
+ * @returns {string} Normalized absolute path or unchanged relative path
+ *
+ * @example
+ * normalizeSpecRef('lumenflow://plans/WU-1062-plan.md')
+ * // '/home/user/.lumenflow/plans/WU-1062-plan.md'
+ *
+ * @example
+ * normalizeSpecRef('docs/04-operations/plans/plan.md')
+ * // 'docs/04-operations/plans/plan.md' (unchanged)
+ */
+export function normalizeSpecRef(specRef) {
+    // Handle lumenflow:// protocol
+    if (specRef.startsWith(LUMENFLOW_PROTOCOL)) {
+        const relativePath = specRef.slice(LUMENFLOW_PROTOCOL.length);
+        return join(getLumenflowHome(), relativePath);
+    }
+    // Handle $LUMENFLOW_HOME variable
+    if (specRef.startsWith(LUMENFLOW_HOME_VAR_PREFIX)) {
+        const relativePath = specRef.slice(LUMENFLOW_HOME_VAR_PREFIX.length);
+        // Remove leading slash if present
+        const cleanPath = relativePath.startsWith('/') ? relativePath.slice(1) : relativePath;
+        return join(getLumenflowHome(), cleanPath);
+    }
+    // Handle tilde expansion
+    if (specRef.startsWith('~/')) {
+        return expandTilde(specRef);
+    }
+    // Return relative paths unchanged
+    return specRef;
+}
+/**
+ * Get the full path for a plan file given a WU ID
+ *
+ * @param {string} wuId - Work Unit ID (e.g., 'WU-1062')
+ * @returns {string} Full path to the plan file
+ *
+ * @example
+ * getPlanPath('WU-1062')
+ * // '/home/user/.lumenflow/plans/WU-1062-plan.md'
+ */
+export function getPlanPath(wuId) {
+    const filename = `${wuId}-plan.md`;
+    return join(getPlansDir(), filename);
+}
+/**
+ * Get the lumenflow:// protocol reference for a plan
+ *
+ * @param {string} wuId - Work Unit ID (e.g., 'WU-1062')
+ * @returns {string} Protocol reference (e.g., 'lumenflow://plans/WU-1062-plan.md')
+ *
+ * @example
+ * getPlanProtocolRef('WU-1062')
+ * // 'lumenflow://plans/WU-1062-plan.md'
+ */
+export function getPlanProtocolRef(wuId) {
+    const filename = `${wuId}-plan.md`;
+    return `${LUMENFLOW_PROTOCOL}${PLANS_SUBDIR}/${filename}`;
+}

package/dist/manual-test-validator.js

@@ -20,7 +20,7 @@ import { TEST_TYPES, WU_TYPES } from './wu-constants.js';
  * Code file extensions that require automated tests.
  * @constant {string[]}
  */
-const CODE_EXTENSIONS = Object.freeze(['.js', '.ts', '.tsx', '.js']);
+const CODE_EXTENSIONS = Object.freeze(['.js', '.ts', '.tsx', '.mjs']);
 /**
  * Non-code file extensions (documentation, data, config).
  * @constant {string[]}

package/dist/orchestration-rules.d.ts

@@ -6,7 +6,7 @@
  *
  * @module orchestration-rules
  * @see {@link ./domain/orchestration.constants.mjs} - MANDATORY_TRIGGERS patterns
- * @see {@link ../../../ai/onboarding/agent-selection-guide.md} - Agent selection rules
+ * @see {@link ../../../docs/04-operations/_frameworks/lumenflow/agent/onboarding/agent-selection-guide.md} - Agent selection rules
  */
 import { type MandatoryAgentName } from './domain/orchestration.constants.js';
 /**

package/dist/orchestration-rules.js

@@ -6,7 +6,7 @@
  *
  * @module orchestration-rules
  * @see {@link ./domain/orchestration.constants.mjs} - MANDATORY_TRIGGERS patterns
- * @see {@link ../../../ai/onboarding/agent-selection-guide.md} - Agent selection rules
+ * @see {@link ../../../docs/04-operations/_frameworks/lumenflow/agent/onboarding/agent-selection-guide.md} - Agent selection rules
  */
 import { minimatch } from 'minimatch';
 import { MANDATORY_TRIGGERS } from './domain/orchestration.constants.js';
@@ -162,7 +162,7 @@ export function buildMandatoryAgentsErrorMessage(wuId, missingAgents, codePaths)
     lines.push('To bypass (NOT RECOMMENDED for PHI/auth work):');
     lines.push('  Remove --require-agents flag from wu:done command');
     lines.push('');
-    lines.push('See: ai/onboarding/agent-selection-guide.md for agent invocation guidance');
+    lines.push('See: docs/04-operations/_frameworks/lumenflow/agent/onboarding/agent-selection-guide.md for agent invocation guidance');
     lines.push('='.repeat(70));
     return lines.join('\n');
 }

package/dist/orphan-detector.d.ts

@@ -18,6 +18,7 @@
  * @see {@link tools/wu-claim.mjs} - Pre-flight orphan check
  * @see {@link tools/lib/git-adapter.mjs} - worktreeRemove with cleanup
  */
+import { existsSync } from 'node:fs';
 /**
  * Result of orphan detection
  * @typedef {object} OrphanDetectionResult
@@ -50,6 +51,21 @@ export declare function parseWorktreeList(porcelainOutput: string): WorktreeEntr
  * @returns {Promise<Set<string>>} Set of absolute paths tracked by git worktree
  */
 export declare function getTrackedWorktreePaths(projectRoot: any): Promise<Set<string>>;
+/**
+ * Identify tracked worktrees that are missing on disk
+ *
+ * @param {string[]} trackedPaths - Absolute paths from git worktree list
+ * @param {(path: string) => boolean} [existsFn] - Optional fs.existsSync override
+ * @returns {string[]} Missing worktree paths
+ */
+export declare function getMissingWorktreesFromTracked(trackedPaths: any, existsFn?: typeof existsSync): any[];
+/**
+ * Detect tracked worktrees that are missing on disk
+ *
+ * @param {string} [projectRoot] - Project root directory (defaults to cwd)
+ * @returns {Promise<string[]>} Missing tracked worktree paths
+ */
+export declare function detectMissingTrackedWorktrees(projectRoot: any): Promise<any[]>;
 /**
  * Get list of directories in worktrees/ folder
  *

package/dist/orphan-detector.js

@@ -75,6 +75,30 @@ export async function getTrackedWorktreePaths(projectRoot) {
     const entries = parseWorktreeList(output);
     return new Set(entries.map((e) => e.path));
 }
+/**
+ * Identify tracked worktrees that are missing on disk
+ *
+ * @param {string[]} trackedPaths - Absolute paths from git worktree list
+ * @param {(path: string) => boolean} [existsFn] - Optional fs.existsSync override
+ * @returns {string[]} Missing worktree paths
+ */
+export function getMissingWorktreesFromTracked(trackedPaths, existsFn = existsSync) {
+    if (!Array.isArray(trackedPaths)) {
+        return [];
+    }
+    return trackedPaths.filter((trackedPath) => !existsFn(trackedPath));
+}
+/**
+ * Detect tracked worktrees that are missing on disk
+ *
+ * @param {string} [projectRoot] - Project root directory (defaults to cwd)
+ * @returns {Promise<string[]>} Missing tracked worktree paths
+ */
+export async function detectMissingTrackedWorktrees(projectRoot) {
+    const root = projectRoot || process.cwd();
+    const tracked = await getTrackedWorktreePaths(root);
+    return getMissingWorktreesFromTracked([...tracked]);
+}
 /**
  * Get list of directories in worktrees/ folder
  *

package/dist/path-classifiers.d.ts

@@ -9,7 +9,7 @@
  * - Documentation: docs/, ai/, .claude/, README*, CLAUDE*.md
  * - Tooling: tools/, scripts/
  *
- * @see {@link tools/lib/wu-done-validators.mjs} - Consumer for detectDocsOnlyByPaths
+ * @see {@link ./wu-done-paths.js} - Consumer for detectDocsOnlyByPaths
  */
 /**
  * Prefixes for paths that should skip web app tests.

package/dist/path-classifiers.js

@@ -9,7 +9,7 @@
  * - Documentation: docs/, ai/, .claude/, README*, CLAUDE*.md
  * - Tooling: tools/, scripts/
  *
- * @see {@link tools/lib/wu-done-validators.mjs} - Consumer for detectDocsOnlyByPaths
+ * @see {@link ./wu-done-paths.js} - Consumer for detectDocsOnlyByPaths
  */
 /**
  * Prefixes for paths that should skip web app tests.

package/dist/rebase-artifact-cleanup.d.ts

@@ -143,3 +143,20 @@ export declare function deduplicateBacklogAfterRebase(worktreePath: any, wuId: a
     cleaned: boolean;
     errors: any[];
 }>;
+/**
+ * Clean up build artifacts in a worktree (dist folders + tsbuildinfo files)
+ *
+ * WU-1042: Provide a safe helper for clearing build artifacts that can
+ * trigger TS5055 or stale build issues in worktrees.
+ *
+ * @param {string} worktreePath - Path to the worktree directory
+ * @returns {Promise<object>} Cleanup result
+ * @returns {string[]} result.distDirectories - Removed dist directories (relative paths)
+ * @returns {string[]} result.tsbuildinfoFiles - Removed tsbuildinfo files (relative paths)
+ * @returns {number} result.removedCount - Total removed artifacts
+ */
+export declare function cleanupWorktreeBuildArtifacts(worktreePath: any): Promise<{
+    distDirectories: string[];
+    tsbuildinfoFiles: string[];
+    removedCount: number;
+}>;

package/dist/rebase-artifact-cleanup.js

@@ -15,11 +15,12 @@
  * @see {@link tools/lib/wu-recovery.mjs} - Related zombie state handling
  */
 import { readFile, writeFile, unlink, access } from 'node:fs/promises';
-import { existsSync } from 'node:fs';
-import { join } from 'node:path';
-import yaml from 'js-yaml';
+import { existsSync, rmSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import fg from 'fast-glob';
+import { parseYAML, stringifyYAML } from './wu-yaml.js';
 import { WU_PATHS } from './wu-paths.js';
-import { WU_STATUS, LOG_PREFIX, EMOJI, YAML_OPTIONS, BACKLOG_SECTIONS, STATUS_SECTIONS, REMOTES, BRANCHES, } from './wu-constants.js';
+import { WU_STATUS, LOG_PREFIX, EMOJI, YAML_OPTIONS, BACKLOG_SECTIONS, STATUS_SECTIONS, REMOTES, BRANCHES, BUILD_ARTIFACT_GLOBS, BUILD_ARTIFACT_IGNORES, } from './wu-constants.js';
 import { findSectionBounds, removeBulletFromSection } from './backlog-editor.js';
 /** @constant {string} FRONTMATTER_DELIMITER - YAML frontmatter delimiter */
 const FRONTMATTER_DELIMITER = '---';
@@ -68,7 +69,7 @@ async function yamlIsDoneOnMain(gitAdapter, wuId) {
             'show',
             `${REMOTES.ORIGIN}/${BRANCHES.MAIN}:${WU_PATHS.WU(wuId)}`,
         ]);
-        const doc = yaml.load(content);
+        const doc = parseYAML(content);
         return doc && doc.status === WU_STATUS.DONE;
     }
     catch {
@@ -162,7 +163,7 @@ export async function detectRebasedArtifacts(worktreePath, wuId, gitAdapter) {
     if (await fileExists(wuYamlPath)) {
         try {
             const content = await readFile(wuYamlPath, { encoding: 'utf-8' });
-            const doc = yaml.load(content);
+            const doc = parseYAML(content);
             if (doc && doc.status === WU_STATUS.DONE) {
                 localYamlDone = true;
             }
@@ -236,7 +237,7 @@ export async function cleanupRebasedArtifacts(worktreePath, wuId) {
     try {
         if (await fileExists(wuYamlPath)) {
             const content = await readFile(wuYamlPath, { encoding: 'utf-8' });
-            const doc = yaml.load(content);
+            const doc = parseYAML(content);
             if (doc && doc.status === WU_STATUS.DONE) {
                 // Reset status
                 doc.status = WU_STATUS.IN_PROGRESS;
@@ -244,7 +245,7 @@ export async function cleanupRebasedArtifacts(worktreePath, wuId) {
                 delete doc.locked;
                 delete doc.completed_at;
                 // Write back
-                const updatedContent = yaml.dump(doc, { lineWidth: YAML_OPTIONS.LINE_WIDTH });
+                const updatedContent = stringifyYAML(doc, { lineWidth: YAML_OPTIONS.LINE_WIDTH });
                 await writeFile(wuYamlPath, updatedContent, { encoding: 'utf-8' });
                 yamlReset = true;
                 console.log(LOG_PREFIX.CLEANUP, `${EMOJI.WARNING} Reset YAML status from done to in_progress for ${wuId} (artifact from main rebase)`);
@@ -431,3 +432,43 @@ export async function deduplicateBacklogAfterRebase(worktreePath, wuId) {
         errors,
     };
 }
+/**
+ * Clean up build artifacts in a worktree (dist folders + tsbuildinfo files)
+ *
+ * WU-1042: Provide a safe helper for clearing build artifacts that can
+ * trigger TS5055 or stale build issues in worktrees.
+ *
+ * @param {string} worktreePath - Path to the worktree directory
+ * @returns {Promise<object>} Cleanup result
+ * @returns {string[]} result.distDirectories - Removed dist directories (relative paths)
+ * @returns {string[]} result.tsbuildinfoFiles - Removed tsbuildinfo files (relative paths)
+ * @returns {number} result.removedCount - Total removed artifacts
+ */
+export async function cleanupWorktreeBuildArtifacts(worktreePath) {
+    const root = resolve(worktreePath);
+    const distDirectories = await fg(BUILD_ARTIFACT_GLOBS.DIST_DIRS, {
+        cwd: root,
+        onlyDirectories: true,
+        dot: true,
+        followSymbolicLinks: false,
+        ignore: BUILD_ARTIFACT_IGNORES,
+    });
+    const tsbuildinfoFiles = await fg(BUILD_ARTIFACT_GLOBS.TSBUILDINFO_FILES, {
+        cwd: root,
+        onlyFiles: true,
+        dot: true,
+        followSymbolicLinks: false,
+        ignore: BUILD_ARTIFACT_IGNORES,
+    });
+    for (const dir of distDirectories) {
+        rmSync(join(root, dir), { recursive: true, force: true });
+    }
+    for (const file of tsbuildinfoFiles) {
+        rmSync(join(root, file), { force: true });
+    }
+    return {
+        distDirectories,
+        tsbuildinfoFiles,
+        removedCount: distDirectories.length + tsbuildinfoFiles.length,
+    };
+}

package/dist/spawn-strategy.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Strategy interface for client-specific spawn behavior
+ */
+export interface SpawnStrategy {
+    /**
+     * Get the context loading preamble for the specific client
+     */
+    getPreamble(wuId: string): string;
+    /**
+     * Get instructions for loading agent skills/tools
+     */
+    getSkillLoadingInstruction(): string;
+}
+/**
+ * Base class with shared preamble logic
+ */
+declare abstract class BaseSpawnStrategy implements SpawnStrategy {
+    protected getCorePreamble(wuId: string): string;
+    abstract getPreamble(wuId: string): string;
+    abstract getSkillLoadingInstruction(): string;
+}
+/**
+ * Strategy for Claude Code (Local/Terminal)
+ */
+export declare class ClaudeCodeStrategy extends BaseSpawnStrategy {
+    getPreamble(wuId: string): string;
+    getSkillLoadingInstruction(): string;
+}
+/**
+ * Strategy for Gemini CLI (Multimodal/Ecosystem)
+ */
+export declare class GeminiCliStrategy extends BaseSpawnStrategy {
+    getPreamble(wuId: string): string;
+    getSkillLoadingInstruction(): string;
+}
+/**
+ * Generic Strategy (Unknown/Other clients)
+ */
+export declare class GenericStrategy extends BaseSpawnStrategy {
+    getPreamble(wuId: string): string;
+    getSkillLoadingInstruction(): string;
+}
+/**
+ * Factory for creating strategies
+ */
+export declare class SpawnStrategyFactory {
+    /**
+     * Create a strategy for the given client
+     * @param clientName - Client name (e.g. 'claude-code', 'gemini-cli')
+     */
+    static create(clientName: string): SpawnStrategy;
+}
+export {};

package/dist/spawn-strategy.js

@@ -0,0 +1,106 @@
+import { existsSync } from 'node:fs';
+/**
+ * Base class with shared preamble logic
+ */
+class BaseSpawnStrategy {
+    getCorePreamble(wuId) {
+        return `Load the following context in this order:
+
+1. Read LUMENFLOW.md (workflow fundamentals and critical rules)
+2. Read .lumenflow/constraints.md (non-negotiable constraints)
+3. Read README.md (project structure and tech stack)
+4. Read docs/04-operations/_frameworks/lumenflow/lumenflow-complete.md sections 1-7 (TDD, gates, Definition of Done)
+5. Read docs/04-operations/tasks/wu/${wuId}.yaml (the specific WU you're working on)`;
+    }
+}
+/**
+ * Strategy for Claude Code (Local/Terminal)
+ */
+export class ClaudeCodeStrategy extends BaseSpawnStrategy {
+    getPreamble(wuId) {
+        let preamble = this.getCorePreamble(wuId);
+        // Vendor overlay
+        if (existsSync('.claude/CLAUDE.md')) {
+            // Insert after LUMENFLOW.md if possible, or just append/prepend
+            // For simplicity and clarity, we'll prepend the vendor specific instructions
+            // relying on the user to follow the specific order if stated.
+            // Actually, checking original behavior: CLAUDE.md was #1.
+            // But new plan says LUMENFLOW.md is core.
+            // We will append it as an overlay step.
+            preamble += `\n6. Read .claude/CLAUDE.md (Claude-specific workflow overlay)`;
+        }
+        return preamble;
+    }
+    getSkillLoadingInstruction() {
+        return `## Skills Selection
+    
+1. Check \`.lumenflow/agents\` for available skills.
+2. Check \`.claude/agents\` for Claude-specific overrides or additions.
+3. Select relevant skills for this task.`;
+    }
+}
+/**
+ * Strategy for Gemini CLI (Multimodal/Ecosystem)
+ */
+export class GeminiCliStrategy extends BaseSpawnStrategy {
+    getPreamble(wuId) {
+        let preamble = this.getCorePreamble(wuId);
+        if (existsSync('GEMINI.md')) {
+            preamble += `\n6. Read GEMINI.md (Gemini-specific workflow overlay)`;
+        }
+        return preamble;
+    }
+    getSkillLoadingInstruction() {
+        return `## Skills Selection
+    
+1. Check \`.lumenflow/agents\` for available skills.
+2. Select relevant skills for this task.`;
+    }
+}
+/**
+ * Generic Strategy (Unknown/Other clients)
+ */
+export class GenericStrategy extends BaseSpawnStrategy {
+    getPreamble(wuId) {
+        return this.getCorePreamble(wuId);
+    }
+    getSkillLoadingInstruction() {
+        return `## Skills Selection
+    
+1. Check \`.lumenflow/agents\` for available skills.
+2. Select relevant skills for this task.`;
+    }
+}
+/**
+ * Factory for creating strategies
+ */
+export class SpawnStrategyFactory {
+    /**
+     * Create a strategy for the given client
+     * @param clientName - Client name (e.g. 'claude-code', 'gemini-cli')
+     */
+    static create(clientName) {
+        switch (clientName.toLowerCase()) {
+            case 'claude': // Legacy alias
+            case 'claude-code':
+                return new ClaudeCodeStrategy();
+            case 'gemini': // Alias
+            case 'gemini-cli':
+                return new GeminiCliStrategy();
+            case 'codex': // Deprecated alias
+            case 'codex-cli':
+                // Codex might need its own strategy later (sandbox), but for now generic or claude-like?
+                // Plan says: "codex: preamble: false, strategy: cloud-sandbox" -> implies Generic or dedicated.
+                // For now, let's map to Generic but maybe we should add CodexStrategy if it has diff behavior.
+                // Re-reading plan: "CodexStrategy: Emphasizes cloud sandbox constraints"
+                // But for this "Minimal" pass, let's stick to Generic with a comment,
+                // OR essentially treat it as Generic since we don't have constraints logic here yet (it's in wu-spawn).
+                // Actually, let's return GenericStrategy but we might handle constraints elsewhere.
+                return new GenericStrategy();
+            default:
+                // Warn? The factory just creates. The caller should warn if it fell back.
+                // But here we just return Generic.
+                return new GenericStrategy();
+        }
+    }
+}