@lumenflow/core 3.2.0 → 3.2.1

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

@@ -0,0 +1,643 @@
+/**
+ * LumenFlow Configuration Schema - Composition File
+ *
+ * WU-2016: Split into per-section schemas under schemas/.
+ * This file composes the full LumenFlowConfigSchema from section schemas
+ * and re-exports all symbols for backward compatibility.
+ *
+ * Per-section schemas (independently importable):
+ * - schemas/workspace-config.ts    - Workspace V2, control plane
+ * - schemas/directories-config.ts  - Directories, state paths, event archival
+ * - schemas/git-config.ts          - Git, push retry
+ * - schemas/wu-config.ts           - WU configuration
+ * - schemas/gates-section-config.ts - Gates, commands
+ * - schemas/memory-config.ts       - Memory, signals, checkpoint, decay
+ * - schemas/agents-config.ts       - Agents, clients, skills, enforcement
+ * - schemas/lanes-config.ts        - Lanes, definitions, lock policy
+ * - schemas/cloud-config.ts        - Cloud auto-detection
+ * - schemas/operational-config.ts  - Experimental, cleanup, telemetry, UI, YAML
+ *
+ * @module lumenflow-config-schema
+ */
+import { z } from 'zod';
+export * from './schemas/workspace-config.js';
+export * from './schemas/directories-config.js';
+export * from './schemas/git-config.js';
+export * from './schemas/wu-config.js';
+export * from './schemas/gates-section-config.js';
+export * from './schemas/memory-config.js';
+export * from './schemas/agents-config.js';
+export * from './schemas/lanes-config.js';
+export * from './schemas/cloud-config.js';
+export * from './schemas/operational-config.js';
+export type { MethodologyConfig, MethodologyOverrides, WorkClassificationUi, WorkClassificationSchemaConfig, } from './resolve-policy.js';
+/**
+ * Complete LumenFlow configuration schema
+ *
+ * Composed from per-section schemas via z.object composition.
+ */
+export declare const LumenFlowConfigSchema: z.ZodObject<{
+    version: z.ZodDefault<z.ZodString>;
+    directories: z.ZodDefault<z.ZodObject<{
+        appsWeb: z.ZodDefault<z.ZodString>;
+        worktrees: z.ZodDefault<z.ZodString>;
+        ai: z.ZodDefault<z.ZodString>;
+        claude: z.ZodDefault<z.ZodString>;
+        docs: z.ZodDefault<z.ZodString>;
+        packages: z.ZodDefault<z.ZodString>;
+        tools: z.ZodDefault<z.ZodString>;
+        memoryBank: z.ZodDefault<z.ZodString>;
+        wuDir: z.ZodDefault<z.ZodString>;
+        initiativesDir: z.ZodDefault<z.ZodString>;
+        backlogPath: z.ZodDefault<z.ZodString>;
+        statusPath: z.ZodDefault<z.ZodString>;
+        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>;
+        safeGitPath: z.ZodDefault<z.ZodString>;
+    }, z.core.$strip>>;
+    state: z.ZodDefault<z.ZodObject<{
+        base: z.ZodDefault<z.ZodString>;
+        stateDir: z.ZodDefault<z.ZodString>;
+        archiveDir: z.ZodDefault<z.ZodString>;
+        stampsDir: z.ZodDefault<z.ZodString>;
+        mergeLock: z.ZodDefault<z.ZodString>;
+        telemetry: z.ZodDefault<z.ZodString>;
+        flowLog: z.ZodDefault<z.ZodString>;
+        sessions: z.ZodDefault<z.ZodString>;
+        incidents: z.ZodDefault<z.ZodString>;
+        commandsLog: z.ZodDefault<z.ZodString>;
+        eventArchival: z.ZodDefault<z.ZodObject<{
+            archiveAfter: z.ZodDefault<z.ZodNumber>;
+            keepArchives: z.ZodDefault<z.ZodBoolean>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    git: z.ZodDefault<z.ZodObject<{
+        mainBranch: z.ZodDefault<z.ZodString>;
+        defaultRemote: z.ZodDefault<z.ZodString>;
+        laneBranchPrefix: z.ZodDefault<z.ZodString>;
+        tempBranchPrefix: z.ZodDefault<z.ZodString>;
+        realGitPath: z.ZodDefault<z.ZodString>;
+        maxBranchDrift: z.ZodDefault<z.ZodNumber>;
+        branchDriftWarning: z.ZodDefault<z.ZodNumber>;
+        branchDriftInfo: z.ZodDefault<z.ZodNumber>;
+        requireRemote: z.ZodDefault<z.ZodBoolean>;
+        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>;
+        minDescriptionLength: z.ZodDefault<z.ZodNumber>;
+        maxCommitSubject: z.ZodDefault<z.ZodNumber>;
+        defaultPriority: z.ZodDefault<z.ZodString>;
+        defaultStatus: z.ZodDefault<z.ZodString>;
+        defaultType: z.ZodDefault<z.ZodString>;
+    }, z.core.$strip>>;
+    gates: z.ZodDefault<z.ZodObject<{
+        maxEslintWarnings: z.ZodDefault<z.ZodNumber>;
+        enableCoverage: z.ZodDefault<z.ZodBoolean>;
+        minCoverage: z.ZodDefault<z.ZodNumber>;
+        enableSafetyCriticalTests: z.ZodDefault<z.ZodBoolean>;
+        enableInvariants: z.ZodDefault<z.ZodBoolean>;
+        execution: z.ZodOptional<z.ZodObject<{
+            preset: z.ZodOptional<z.ZodString>;
+            setup: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                command: z.ZodString;
+                continueOnError: z.ZodOptional<z.ZodBoolean>;
+                timeout: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>]>>;
+            format: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                command: z.ZodString;
+                continueOnError: z.ZodOptional<z.ZodBoolean>;
+                timeout: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>]>>;
+            lint: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                command: z.ZodString;
+                continueOnError: z.ZodOptional<z.ZodBoolean>;
+                timeout: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>]>>;
+            typecheck: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                command: z.ZodString;
+                continueOnError: z.ZodOptional<z.ZodBoolean>;
+                timeout: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>]>>;
+            test: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                command: z.ZodString;
+                continueOnError: z.ZodOptional<z.ZodBoolean>;
+                timeout: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>]>>;
+            coverage: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                command: z.ZodString;
+                threshold: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>]>>;
+        }, z.core.$strip>>;
+        commands: z.ZodDefault<z.ZodObject<{
+            test_full: z.ZodDefault<z.ZodString>;
+            test_docs_only: z.ZodDefault<z.ZodString>;
+            test_incremental: z.ZodDefault<z.ZodString>;
+            lint: z.ZodOptional<z.ZodString>;
+            typecheck: z.ZodOptional<z.ZodString>;
+            format: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        ignore_patterns: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        lane_health: z.ZodDefault<z.ZodEnum<{
+            error: "error";
+            off: "off";
+            warn: "warn";
+        }>>;
+    }, z.core.$strip>>;
+    memory: z.ZodDefault<z.ZodObject<{
+        directory: z.ZodDefault<z.ZodString>;
+        sessionTtl: z.ZodDefault<z.ZodNumber>;
+        checkpointTtl: z.ZodDefault<z.ZodNumber>;
+        enableAutoCleanup: z.ZodDefault<z.ZodBoolean>;
+        progress_signals: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            frequency: z.ZodDefault<z.ZodNumber>;
+            on_milestone: z.ZodDefault<z.ZodBoolean>;
+            on_tests_pass: z.ZodDefault<z.ZodBoolean>;
+            before_gates: z.ZodDefault<z.ZodBoolean>;
+            on_blocked: z.ZodDefault<z.ZodBoolean>;
+            auto_checkpoint: z.ZodDefault<z.ZodBoolean>;
+        }, z.core.$strip>>;
+        signalCleanup: z.ZodDefault<z.ZodObject<{
+            ttl: z.ZodDefault<z.ZodNumber>;
+            unreadTtl: z.ZodDefault<z.ZodNumber>;
+            maxEntries: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strip>>;
+        delegation_context_max_size: z.ZodDefault<z.ZodNumber>;
+        spawn_context_max_size: z.ZodOptional<z.ZodUnknown> & z.ZodType<undefined, unknown, z.core.$ZodTypeInternals<undefined, unknown>>;
+        enforcement: z.ZodOptional<z.ZodObject<{
+            auto_checkpoint: z.ZodDefault<z.ZodObject<{
+                enabled: z.ZodDefault<z.ZodBoolean>;
+                interval_tool_calls: z.ZodDefault<z.ZodNumber>;
+            }, z.core.$strip>>;
+            require_checkpoint_for_done: z.ZodDefault<z.ZodEnum<{
+                off: "off";
+                warn: "warn";
+                block: "block";
+            }>>;
+        }, z.core.$strip>>;
+        decay: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            threshold: z.ZodDefault<z.ZodNumber>;
+            half_life_days: z.ZodDefault<z.ZodNumber>;
+            trigger: z.ZodDefault<z.ZodEnum<{
+                manual: "manual";
+                on_done: "on_done";
+            }>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    ui: z.ZodDefault<z.ZodObject<{
+        errorBoxWidth: z.ZodDefault<z.ZodNumber>;
+        statusPreviewLines: z.ZodDefault<z.ZodNumber>;
+        readinessBoxWidth: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>>;
+    yaml: z.ZodDefault<z.ZodObject<{
+        lineWidth: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>>;
+    agents: z.ZodDefault<z.ZodObject<{
+        defaultClient: z.ZodDefault<z.ZodString>;
+        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;
+            }, z.core.$strip>>>;
+            skills: z.ZodOptional<z.ZodObject<{
+                instructions: z.ZodOptional<z.ZodString>;
+                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>>;
+            capabilities_map: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        }, z.core.$strip>>>;
+        methodology: z.ZodDefault<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            enforcement: z.ZodDefault<z.ZodEnum<{
+                required: "required";
+                recommended: "recommended";
+            }>>;
+            principles: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            notes: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    experimental: z.ZodDefault<z.ZodObject<{
+        context_validation: z.ZodDefault<z.ZodBoolean>;
+        validation_mode: z.ZodDefault<z.ZodEnum<{
+            error: "error";
+            off: "off";
+            warn: "warn";
+        }>>;
+        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";
+        }>>;
+        commit_message: z.ZodDefault<z.ZodString>;
+    }, z.core.$strip>>;
+    telemetry: z.ZodDefault<z.ZodObject<{
+        methodology: z.ZodDefault<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    methodology: z.ZodOptional<z.ZodObject<{
+        testing: z.ZodDefault<z.ZodEnum<{
+            tdd: "tdd";
+            "test-after": "test-after";
+            none: "none";
+        }>>;
+        architecture: z.ZodDefault<z.ZodEnum<{
+            none: "none";
+            hexagonal: "hexagonal";
+            layered: "layered";
+        }>>;
+        overrides: z.ZodOptional<z.ZodObject<{
+            coverage_threshold: z.ZodOptional<z.ZodNumber>;
+            coverage_mode: z.ZodOptional<z.ZodEnum<{
+                off: "off";
+                warn: "warn";
+                block: "block";
+            }>>;
+        }, z.core.$strip>>;
+        work_classification: z.ZodOptional<z.ZodObject<{
+            ui: z.ZodOptional<z.ZodObject<{
+                code_path_patterns: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                lane_hints: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    cloud: z.ZodDefault<z.ZodObject<{
+        auto_detect: z.ZodDefault<z.ZodBoolean>;
+        env_signals: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            equals: z.ZodOptional<z.ZodString>;
+        }, 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>>;
+        lifecycle: z.ZodOptional<z.ZodObject<{
+            status: z.ZodEnum<{
+                unconfigured: "unconfigured";
+                draft: "draft";
+                locked: "locked";
+            }>;
+            updated_at: z.ZodOptional<z.ZodString>;
+            migrated_at: z.ZodOptional<z.ZodString>;
+            migration_reason: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        definitions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            wip_limit: z.ZodOptional<z.ZodNumber>;
+            wip_justification: z.ZodOptional<z.ZodString>;
+            lock_policy: z.ZodDefault<z.ZodDefault<z.ZodEnum<{
+                none: "none";
+                all: "all";
+                active: "active";
+            }>>>;
+            code_paths: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>>>;
+        engineering: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            wip_limit: z.ZodOptional<z.ZodNumber>;
+            wip_justification: z.ZodOptional<z.ZodString>;
+            lock_policy: z.ZodDefault<z.ZodDefault<z.ZodEnum<{
+                none: "none";
+                all: "all";
+                active: "active";
+            }>>>;
+            code_paths: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>>>;
+        business: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            wip_limit: z.ZodOptional<z.ZodNumber>;
+            wip_justification: z.ZodOptional<z.ZodString>;
+            lock_policy: z.ZodDefault<z.ZodDefault<z.ZodEnum<{
+                none: "none";
+                all: "all";
+                active: "active";
+            }>>>;
+            code_paths: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
+    package_manager: z.ZodDefault<z.ZodEnum<{
+        pnpm: "pnpm";
+        npm: "npm";
+        yarn: "yarn";
+        bun: "bun";
+    }>>;
+    test_runner: z.ZodDefault<z.ZodEnum<{
+        vitest: "vitest";
+        jest: "jest";
+        mocha: "mocha";
+    }>>;
+    build_command: z.ZodDefault<z.ZodString>;
+}, z.core.$strip>;
+export type LumenFlowConfig = z.infer<typeof LumenFlowConfigSchema>;
+/**
+ * Validate configuration data
+ *
+ * @param data - Configuration data to validate
+ * @returns Validation result with parsed config or errors
+ */
+export declare function validateConfig(data: unknown): z.ZodSafeParseResult<{
+    version: string;
+    directories: {
+        appsWeb: string;
+        worktrees: string;
+        ai: string;
+        claude: string;
+        docs: string;
+        packages: string;
+        tools: string;
+        memoryBank: string;
+        wuDir: string;
+        initiativesDir: string;
+        backlogPath: string;
+        statusPath: string;
+        skillsDir: string;
+        agentsDir: string;
+        plansDir: string;
+        templatesDir: string;
+        onboardingDir: string;
+        safeGitPath: string;
+    };
+    state: {
+        base: string;
+        stateDir: string;
+        archiveDir: string;
+        stampsDir: string;
+        mergeLock: string;
+        telemetry: string;
+        flowLog: string;
+        sessions: string;
+        incidents: string;
+        commandsLog: string;
+        eventArchival: {
+            archiveAfter: number;
+            keepArchives: boolean;
+        };
+    };
+    git: {
+        mainBranch: string;
+        defaultRemote: string;
+        laneBranchPrefix: string;
+        tempBranchPrefix: string;
+        realGitPath: string;
+        maxBranchDrift: number;
+        branchDriftWarning: number;
+        branchDriftInfo: number;
+        requireRemote: boolean;
+        agentBranchPatterns: string[];
+        disableAgentPatternRegistry: boolean;
+        push_retry: {
+            enabled: boolean;
+            retries: number;
+            min_delay_ms: number;
+            max_delay_ms: number;
+            jitter: boolean;
+        };
+        agentBranchPatternsOverride?: string[] | undefined;
+    };
+    wu: {
+        idPattern: string;
+        minDescriptionLength: number;
+        maxCommitSubject: number;
+        defaultPriority: string;
+        defaultStatus: string;
+        defaultType: string;
+    };
+    gates: {
+        maxEslintWarnings: number;
+        enableCoverage: boolean;
+        minCoverage: number;
+        enableSafetyCriticalTests: boolean;
+        enableInvariants: boolean;
+        commands: {
+            test_full: string;
+            test_docs_only: string;
+            test_incremental: string;
+            lint?: string | undefined;
+            typecheck?: string | undefined;
+            format?: string | undefined;
+        };
+        lane_health: "error" | "off" | "warn";
+        execution?: {
+            preset?: string | undefined;
+            setup?: string | {
+                command: string;
+                continueOnError?: boolean | undefined;
+                timeout?: number | undefined;
+            } | undefined;
+            format?: string | {
+                command: string;
+                continueOnError?: boolean | undefined;
+                timeout?: number | undefined;
+            } | undefined;
+            lint?: string | {
+                command: string;
+                continueOnError?: boolean | undefined;
+                timeout?: number | undefined;
+            } | undefined;
+            typecheck?: string | {
+                command: string;
+                continueOnError?: boolean | undefined;
+                timeout?: number | undefined;
+            } | undefined;
+            test?: string | {
+                command: string;
+                continueOnError?: boolean | undefined;
+                timeout?: number | undefined;
+            } | undefined;
+            coverage?: string | {
+                command: string;
+                threshold?: number | undefined;
+            } | undefined;
+        } | undefined;
+        ignore_patterns?: string[] | undefined;
+    };
+    memory: {
+        directory: string;
+        sessionTtl: number;
+        checkpointTtl: number;
+        enableAutoCleanup: boolean;
+        signalCleanup: {
+            ttl: number;
+            unreadTtl: number;
+            maxEntries: number;
+        };
+        delegation_context_max_size: number;
+        progress_signals?: {
+            enabled: boolean;
+            frequency: number;
+            on_milestone: boolean;
+            on_tests_pass: boolean;
+            before_gates: boolean;
+            on_blocked: boolean;
+            auto_checkpoint: boolean;
+        } | undefined;
+        spawn_context_max_size?: undefined;
+        enforcement?: {
+            auto_checkpoint: {
+                enabled: boolean;
+                interval_tool_calls: number;
+            };
+            require_checkpoint_for_done: "off" | "warn" | "block";
+        } | undefined;
+        decay?: {
+            enabled: boolean;
+            threshold: number;
+            half_life_days: number;
+            trigger: "manual" | "on_done";
+        } | undefined;
+    };
+    ui: {
+        errorBoxWidth: number;
+        statusPreviewLines: number;
+        readinessBoxWidth: number;
+    };
+    yaml: {
+        lineWidth: number;
+    };
+    agents: {
+        defaultClient: string;
+        clients: Record<string, {
+            blocks: {
+                title: string;
+                content: string;
+            }[];
+            preamble?: string | boolean | undefined;
+            skillsDir?: string | undefined;
+            agentsDir?: string | undefined;
+            skills?: {
+                recommended: string[];
+                instructions?: string | undefined;
+                byLane?: Record<string, string[]> | undefined;
+            } | undefined;
+            enforcement?: {
+                hooks: boolean;
+                block_outside_worktree: boolean;
+                require_wu_for_edits: boolean;
+                warn_on_stop_without_wu_done: boolean;
+            } | undefined;
+            capabilities_map?: Record<string, string> | undefined;
+        }>;
+        methodology: {
+            enabled: boolean;
+            enforcement: "required" | "recommended";
+            principles: string[];
+            notes?: string | undefined;
+        };
+    };
+    experimental: {
+        context_validation: boolean;
+        validation_mode: "error" | "off" | "warn";
+        show_next_steps: boolean;
+        recovery_command: boolean;
+    };
+    cleanup: {
+        trigger: "manual" | "on_done" | "on_init";
+        commit_message: string;
+    };
+    telemetry: {
+        methodology: {
+            enabled: boolean;
+        };
+    };
+    cloud: {
+        auto_detect: boolean;
+        env_signals: {
+            name: string;
+            equals?: string | undefined;
+        }[];
+    };
+    package_manager: "pnpm" | "npm" | "yarn" | "bun";
+    test_runner: "vitest" | "jest" | "mocha";
+    build_command: string;
+    methodology?: {
+        testing: "tdd" | "test-after" | "none";
+        architecture: "none" | "hexagonal" | "layered";
+        overrides?: {
+            coverage_threshold?: number | undefined;
+            coverage_mode?: "off" | "warn" | "block" | undefined;
+        } | undefined;
+        work_classification?: {
+            ui?: {
+                code_path_patterns?: string[] | undefined;
+                lane_hints?: string[] | undefined;
+            } | undefined;
+        } | undefined;
+    } | undefined;
+    lanes?: {
+        enforcement?: {
+            require_parent: boolean;
+            allow_custom: boolean;
+        } | undefined;
+        lifecycle?: {
+            status: "unconfigured" | "draft" | "locked";
+            updated_at?: string | undefined;
+            migrated_at?: string | undefined;
+            migration_reason?: string | undefined;
+        } | undefined;
+        definitions?: {
+            name: string;
+            lock_policy: "none" | "all" | "active";
+            wip_limit?: number | undefined;
+            wip_justification?: string | undefined;
+            code_paths?: string[] | undefined;
+        }[] | undefined;
+        engineering?: {
+            name: string;
+            lock_policy: "none" | "all" | "active";
+            wip_limit?: number | undefined;
+            wip_justification?: string | undefined;
+            code_paths?: string[] | undefined;
+        }[] | undefined;
+        business?: {
+            name: string;
+            lock_policy: "none" | "all" | "active";
+            wip_limit?: number | undefined;
+            wip_justification?: string | undefined;
+            code_paths?: string[] | undefined;
+        }[] | undefined;
+    } | undefined;
+}>;
+/**
+ * Parse configuration with defaults
+ *
+ * @param data - Partial configuration data
+ * @returns Complete configuration with defaults applied
+ * @throws ZodError if validation fails
+ */
+export declare function parseConfig(data?: unknown): LumenFlowConfig;
+/**
+ * Get default configuration
+ *
+ * @returns Default LumenFlow configuration
+ */
+export declare function getDefaultConfig(): LumenFlowConfig;
+//# sourceMappingURL=lumenflow-config-schema.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"lumenflow-config-schema.d.ts","sourceRoot":"","sources":["../src/lumenflow-config-schema.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAOxB,cAAc,+BAA+B,CAAC;AAC9C,cAAc,iCAAiC,CAAC;AAChD,cAAc,yBAAyB,CAAC;AACxC,cAAc,wBAAwB,CAAC;AACvC,cAAc,mCAAmC,CAAC;AAClD,cAAc,4BAA4B,CAAC;AAC3C,cAAc,4BAA4B,CAAC;AAC3C,cAAc,2BAA2B,CAAC;AAC1C,cAAc,2BAA2B,CAAC;AAC1C,cAAc,iCAAiC,CAAC;AAwBhD,YAAY,EACV,iBAAiB,EACjB,oBAAoB,EACpB,oBAAoB,EACpB,8BAA8B,GAC/B,MAAM,qBAAqB,CAAC;AAE7B;;;;GAIG;AACH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAyDhC,CAAC;AAEH,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAEpE;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAE3C;AAED;;;;;;GAMG;AACH,wBAAgB,WAAW,CAAC,IAAI,GAAE,OAAY,GAAG,eAAe,CAE/D;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,IAAI,eAAe,CAElD"}