import { z } from 'zod';
import { S as StageId, a as StageStatus } from '../stage-zMHyjRAs.js';
import { ValidationSummary as ValidationSummary$1 } from '../hooks/output-validator.js';

/**
 * Configuration type definitions and Zod schemas
 * With .describe() annotations for JSON Schema generation
 */

/**
 * Stage config.yaml schema
 */
declare const StageConfigSchema: z.ZodObject<{
    stage: z.ZodObject<{
        id: z.ZodEnum<["01-brainstorm", "02-research", "03-planning", "04-ui-ux", "05-task-management", "06-implementation", "07-qa", "08-deployment"]>;
        name: z.ZodString;
        description: z.ZodOptional<z.ZodString>;
    }, "strip", z.ZodTypeAny, {
        id: "01-brainstorm" | "02-research" | "03-planning" | "04-ui-ux" | "05-task-management" | "06-implementation" | "07-qa" | "08-deployment";
        name: string;
        description?: string | undefined;
    }, {
        id: "01-brainstorm" | "02-research" | "03-planning" | "04-ui-ux" | "05-task-management" | "06-implementation" | "07-qa" | "08-deployment";
        name: string;
        description?: string | undefined;
    }>;
    models: z.ZodObject<{
        primary: z.ZodEnum<["claudecode", "claude", "gemini", "codex"]>;
        secondary: z.ZodOptional<z.ZodEnum<["claudecode", "claude", "gemini", "codex"]>>;
        collaboration: z.ZodOptional<z.ZodEnum<["parallel", "sequential", "debate"]>>;
    }, "strip", z.ZodTypeAny, {
        primary: "claudecode" | "claude" | "gemini" | "codex";
        secondary?: "claudecode" | "claude" | "gemini" | "codex" | undefined;
        collaboration?: "parallel" | "sequential" | "debate" | undefined;
    }, {
        primary: "claudecode" | "claude" | "gemini" | "codex";
        secondary?: "claudecode" | "claude" | "gemini" | "codex" | undefined;
        collaboration?: "parallel" | "sequential" | "debate" | undefined;
    }>;
    execution: z.ZodOptional<z.ZodObject<{
        mode: z.ZodEnum<["yolo", "plan", "plan_sandbox", "deep_dive", "headless", "sandbox_playwright"]>;
        timeout: z.ZodOptional<z.ZodNumber>;
    }, "strip", z.ZodTypeAny, {
        mode: "yolo" | "plan" | "plan_sandbox" | "deep_dive" | "headless" | "sandbox_playwright";
        timeout?: number | undefined;
    }, {
        mode: "yolo" | "plan" | "plan_sandbox" | "deep_dive" | "headless" | "sandbox_playwright";
        timeout?: number | undefined;
    }>>;
    inputs: z.ZodOptional<z.ZodObject<{
        required: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
        optional: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    }, "strip", z.ZodTypeAny, {
        required?: string[] | undefined;
        optional?: string[] | undefined;
    }, {
        required?: string[] | undefined;
        optional?: string[] | undefined;
    }>>;
    outputs: z.ZodOptional<z.ZodObject<{
        required: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
        templates: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    }, "strip", z.ZodTypeAny, {
        required?: string[] | undefined;
        templates?: string[] | undefined;
    }, {
        required?: string[] | undefined;
        templates?: string[] | undefined;
    }>>;
    auto_invoke: z.ZodOptional<z.ZodObject<{
        enabled: z.ZodBoolean;
        model: z.ZodOptional<z.ZodEnum<["claudecode", "claude", "gemini", "codex"]>>;
        wrapper: z.ZodOptional<z.ZodString>;
        prompt_file: z.ZodOptional<z.ZodString>;
        fallback: z.ZodOptional<z.ZodObject<{
            enabled: z.ZodBoolean;
            model: z.ZodOptional<z.ZodEnum<["claudecode", "claude", "gemini", "codex"]>>;
        }, "strip", z.ZodTypeAny, {
            enabled: boolean;
            model?: "claudecode" | "claude" | "gemini" | "codex" | undefined;
        }, {
            enabled: boolean;
            model?: "claudecode" | "claude" | "gemini" | "codex" | undefined;
        }>>;
    }, "strip", z.ZodTypeAny, {
        enabled: boolean;
        model?: "claudecode" | "claude" | "gemini" | "codex" | undefined;
        wrapper?: string | undefined;
        prompt_file?: string | undefined;
        fallback?: {
            enabled: boolean;
            model?: "claudecode" | "claude" | "gemini" | "codex" | undefined;
        } | undefined;
    }, {
        enabled: boolean;
        model?: "claudecode" | "claude" | "gemini" | "codex" | undefined;
        wrapper?: string | undefined;
        prompt_file?: string | undefined;
        fallback?: {
            enabled: boolean;
            model?: "claudecode" | "claude" | "gemini" | "codex" | undefined;
        } | undefined;
    }>>;
    transition: z.ZodOptional<z.ZodObject<{
        prerequisites: z.ZodOptional<z.ZodArray<z.ZodEnum<["01-brainstorm", "02-research", "03-planning", "04-ui-ux", "05-task-management", "06-implementation", "07-qa", "08-deployment"]>, "many">>;
        require_handoff: z.ZodOptional<z.ZodBoolean>;
        require_checkpoint: z.ZodOptional<z.ZodBoolean>;
    }, "strip", z.ZodTypeAny, {
        prerequisites?: ("01-brainstorm" | "02-research" | "03-planning" | "04-ui-ux" | "05-task-management" | "06-implementation" | "07-qa" | "08-deployment")[] | undefined;
        require_handoff?: boolean | undefined;
        require_checkpoint?: boolean | undefined;
    }, {
        prerequisites?: ("01-brainstorm" | "02-research" | "03-planning" | "04-ui-ux" | "05-task-management" | "06-implementation" | "07-qa" | "08-deployment")[] | undefined;
        require_handoff?: boolean | undefined;
        require_checkpoint?: boolean | undefined;
    }>>;
    mcp_servers: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
}, "strip", z.ZodTypeAny, {
    stage: {
        id: "01-brainstorm" | "02-research" | "03-planning" | "04-ui-ux" | "05-task-management" | "06-implementation" | "07-qa" | "08-deployment";
        name: string;
        description?: string | undefined;
    };
    models: {
        primary: "claudecode" | "claude" | "gemini" | "codex";
        secondary?: "claudecode" | "claude" | "gemini" | "codex" | undefined;
        collaboration?: "parallel" | "sequential" | "debate" | undefined;
    };
    execution?: {
        mode: "yolo" | "plan" | "plan_sandbox" | "deep_dive" | "headless" | "sandbox_playwright";
        timeout?: number | undefined;
    } | undefined;
    inputs?: {
        required?: string[] | undefined;
        optional?: string[] | undefined;
    } | undefined;
    outputs?: {
        required?: string[] | undefined;
        templates?: string[] | undefined;
    } | undefined;
    auto_invoke?: {
        enabled: boolean;
        model?: "claudecode" | "claude" | "gemini" | "codex" | undefined;
        wrapper?: string | undefined;
        prompt_file?: string | undefined;
        fallback?: {
            enabled: boolean;
            model?: "claudecode" | "claude" | "gemini" | "codex" | undefined;
        } | undefined;
    } | undefined;
    transition?: {
        prerequisites?: ("01-brainstorm" | "02-research" | "03-planning" | "04-ui-ux" | "05-task-management" | "06-implementation" | "07-qa" | "08-deployment")[] | undefined;
        require_handoff?: boolean | undefined;
        require_checkpoint?: boolean | undefined;
    } | undefined;
    mcp_servers?: string[] | undefined;
}, {
    stage: {
        id: "01-brainstorm" | "02-research" | "03-planning" | "04-ui-ux" | "05-task-management" | "06-implementation" | "07-qa" | "08-deployment";
        name: string;
        description?: string | undefined;
    };
    models: {
        primary: "claudecode" | "claude" | "gemini" | "codex";
        secondary?: "claudecode" | "claude" | "gemini" | "codex" | undefined;
        collaboration?: "parallel" | "sequential" | "debate" | undefined;
    };
    execution?: {
        mode: "yolo" | "plan" | "plan_sandbox" | "deep_dive" | "headless" | "sandbox_playwright";
        timeout?: number | undefined;
    } | undefined;
    inputs?: {
        required?: string[] | undefined;
        optional?: string[] | undefined;
    } | undefined;
    outputs?: {
        required?: string[] | undefined;
        templates?: string[] | undefined;
    } | undefined;
    auto_invoke?: {
        enabled: boolean;
        model?: "claudecode" | "claude" | "gemini" | "codex" | undefined;
        wrapper?: string | undefined;
        prompt_file?: string | undefined;
        fallback?: {
            enabled: boolean;
            model?: "claudecode" | "claude" | "gemini" | "codex" | undefined;
        } | undefined;
    } | undefined;
    transition?: {
        prerequisites?: ("01-brainstorm" | "02-research" | "03-planning" | "04-ui-ux" | "05-task-management" | "06-implementation" | "07-qa" | "08-deployment")[] | undefined;
        require_handoff?: boolean | undefined;
        require_checkpoint?: boolean | undefined;
    } | undefined;
    mcp_servers?: string[] | undefined;
}>;
type StageConfig = z.infer<typeof StageConfigSchema>;
/**
 * Pipeline config schema
 */
declare const PipelineConfigSchema: z.ZodObject<{
    pipeline: z.ZodObject<{
        name: z.ZodString;
        version: z.ZodString;
        description: z.ZodOptional<z.ZodString>;
    }, "strip", z.ZodTypeAny, {
        name: string;
        version: string;
        description?: string | undefined;
    }, {
        name: string;
        version: string;
        description?: string | undefined;
    }>;
    stages: z.ZodArray<z.ZodObject<{
        id: z.ZodEnum<["01-brainstorm", "02-research", "03-planning", "04-ui-ux", "05-task-management", "06-implementation", "07-qa", "08-deployment"]>;
        name: z.ZodString;
        description: z.ZodOptional<z.ZodString>;
    }, "strip", z.ZodTypeAny, {
        id: "01-brainstorm" | "02-research" | "03-planning" | "04-ui-ux" | "05-task-management" | "06-implementation" | "07-qa" | "08-deployment";
        name: string;
        description?: string | undefined;
    }, {
        id: "01-brainstorm" | "02-research" | "03-planning" | "04-ui-ux" | "05-task-management" | "06-implementation" | "07-qa" | "08-deployment";
        name: string;
        description?: string | undefined;
    }>, "many">;
    sprint_mode: z.ZodOptional<z.ZodObject<{
        enabled: z.ZodBoolean;
        sprint_config: z.ZodObject<{
            default_sprints: z.ZodNumber;
            max_sprints: z.ZodOptional<z.ZodNumber>;
        }, "strip", z.ZodTypeAny, {
            default_sprints: number;
            max_sprints?: number | undefined;
        }, {
            default_sprints: number;
            max_sprints?: number | undefined;
        }>;
    }, "strip", z.ZodTypeAny, {
        enabled: boolean;
        sprint_config: {
            default_sprints: number;
            max_sprints?: number | undefined;
        };
    }, {
        enabled: boolean;
        sprint_config: {
            default_sprints: number;
            max_sprints?: number | undefined;
        };
    }>>;
    context_management: z.ZodOptional<z.ZodObject<{
        warning_threshold: z.ZodNumber;
        action_threshold: z.ZodNumber;
        critical_threshold: z.ZodNumber;
        auto_save_interval: z.ZodNumber;
    }, "strip", z.ZodTypeAny, {
        warning_threshold: number;
        action_threshold: number;
        critical_threshold: number;
        auto_save_interval: number;
    }, {
        warning_threshold: number;
        action_threshold: number;
        critical_threshold: number;
        auto_save_interval: number;
    }>>;
}, "strip", z.ZodTypeAny, {
    pipeline: {
        name: string;
        version: string;
        description?: string | undefined;
    };
    stages: {
        id: "01-brainstorm" | "02-research" | "03-planning" | "04-ui-ux" | "05-task-management" | "06-implementation" | "07-qa" | "08-deployment";
        name: string;
        description?: string | undefined;
    }[];
    sprint_mode?: {
        enabled: boolean;
        sprint_config: {
            default_sprints: number;
            max_sprints?: number | undefined;
        };
    } | undefined;
    context_management?: {
        warning_threshold: number;
        action_threshold: number;
        critical_threshold: number;
        auto_save_interval: number;
    } | undefined;
}, {
    pipeline: {
        name: string;
        version: string;
        description?: string | undefined;
    };
    stages: {
        id: "01-brainstorm" | "02-research" | "03-planning" | "04-ui-ux" | "05-task-management" | "06-implementation" | "07-qa" | "08-deployment";
        name: string;
        description?: string | undefined;
    }[];
    sprint_mode?: {
        enabled: boolean;
        sprint_config: {
            default_sprints: number;
            max_sprints?: number | undefined;
        };
    } | undefined;
    context_management?: {
        warning_threshold: number;
        action_threshold: number;
        critical_threshold: number;
        auto_save_interval: number;
    } | undefined;
}>;
type PipelineConfig = z.infer<typeof PipelineConfigSchema>;
/**
 * Models config schema
 */
declare const ModelsConfigSchema: z.ZodObject<{
    models: z.ZodRecord<z.ZodString, z.ZodObject<{
        name: z.ZodString;
        cli_command: z.ZodOptional<z.ZodString>;
        wrapper: z.ZodOptional<z.ZodString>;
        modes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
            enabled: z.ZodBoolean;
            description: z.ZodOptional<z.ZodString>;
        }, "strip", z.ZodTypeAny, {
            enabled: boolean;
            description?: string | undefined;
        }, {
            enabled: boolean;
            description?: string | undefined;
        }>>>;
        fallback_to: z.ZodOptional<z.ZodString>;
    }, "strip", z.ZodTypeAny, {
        name: string;
        wrapper?: string | undefined;
        cli_command?: string | undefined;
        modes?: Record<string, {
            enabled: boolean;
            description?: string | undefined;
        }> | undefined;
        fallback_to?: string | undefined;
    }, {
        name: string;
        wrapper?: string | undefined;
        cli_command?: string | undefined;
        modes?: Record<string, {
            enabled: boolean;
            description?: string | undefined;
        }> | undefined;
        fallback_to?: string | undefined;
    }>>;
}, "strip", z.ZodTypeAny, {
    models: Record<string, {
        name: string;
        wrapper?: string | undefined;
        cli_command?: string | undefined;
        modes?: Record<string, {
            enabled: boolean;
            description?: string | undefined;
        }> | undefined;
        fallback_to?: string | undefined;
    }>;
}, {
    models: Record<string, {
        name: string;
        wrapper?: string | undefined;
        cli_command?: string | undefined;
        modes?: Record<string, {
            enabled: boolean;
            description?: string | undefined;
        }> | undefined;
        fallback_to?: string | undefined;
    }>;
}>;
type ModelsConfig = z.infer<typeof ModelsConfigSchema>;
/**
 * AI collaboration config schema
 */
declare const AICollaborationConfigSchema: z.ZodObject<{
    execution_policy: z.ZodObject<{
        default_mode: z.ZodEnum<["parallel", "sequential", "debate"]>;
        stage_classification: z.ZodObject<{
            parallel_capable: z.ZodArray<z.ZodEnum<["01-brainstorm", "02-research", "03-planning", "04-ui-ux", "05-task-management", "06-implementation", "07-qa", "08-deployment"]>, "many">;
            sequential_only: z.ZodArray<z.ZodEnum<["01-brainstorm", "02-research", "03-planning", "04-ui-ux", "05-task-management", "06-implementation", "07-qa", "08-deployment"]>, "many">;
        }, "strip", z.ZodTypeAny, {
            parallel_capable: ("01-brainstorm" | "02-research" | "03-planning" | "04-ui-ux" | "05-task-management" | "06-implementation" | "07-qa" | "08-deployment")[];
            sequential_only: ("01-brainstorm" | "02-research" | "03-planning" | "04-ui-ux" | "05-task-management" | "06-implementation" | "07-qa" | "08-deployment")[];
        }, {
            parallel_capable: ("01-brainstorm" | "02-research" | "03-planning" | "04-ui-ux" | "05-task-management" | "06-implementation" | "07-qa" | "08-deployment")[];
            sequential_only: ("01-brainstorm" | "02-research" | "03-planning" | "04-ui-ux" | "05-task-management" | "06-implementation" | "07-qa" | "08-deployment")[];
        }>;
    }, "strip", z.ZodTypeAny, {
        default_mode: "parallel" | "sequential" | "debate";
        stage_classification: {
            parallel_capable: ("01-brainstorm" | "02-research" | "03-planning" | "04-ui-ux" | "05-task-management" | "06-implementation" | "07-qa" | "08-deployment")[];
            sequential_only: ("01-brainstorm" | "02-research" | "03-planning" | "04-ui-ux" | "05-task-management" | "06-implementation" | "07-qa" | "08-deployment")[];
        };
    }, {
        default_mode: "parallel" | "sequential" | "debate";
        stage_classification: {
            parallel_capable: ("01-brainstorm" | "02-research" | "03-planning" | "04-ui-ux" | "05-task-management" | "06-implementation" | "07-qa" | "08-deployment")[];
            sequential_only: ("01-brainstorm" | "02-research" | "03-planning" | "04-ui-ux" | "05-task-management" | "06-implementation" | "07-qa" | "08-deployment")[];
        };
    }>;
    consolidation: z.ZodOptional<z.ZodObject<{
        default_strategy: z.ZodString;
        quality_threshold: z.ZodNumber;
    }, "strip", z.ZodTypeAny, {
        default_strategy: string;
        quality_threshold: number;
    }, {
        default_strategy: string;
        quality_threshold: number;
    }>>;
}, "strip", z.ZodTypeAny, {
    execution_policy: {
        default_mode: "parallel" | "sequential" | "debate";
        stage_classification: {
            parallel_capable: ("01-brainstorm" | "02-research" | "03-planning" | "04-ui-ux" | "05-task-management" | "06-implementation" | "07-qa" | "08-deployment")[];
            sequential_only: ("01-brainstorm" | "02-research" | "03-planning" | "04-ui-ux" | "05-task-management" | "06-implementation" | "07-qa" | "08-deployment")[];
        };
    };
    consolidation?: {
        default_strategy: string;
        quality_threshold: number;
    } | undefined;
}, {
    execution_policy: {
        default_mode: "parallel" | "sequential" | "debate";
        stage_classification: {
            parallel_capable: ("01-brainstorm" | "02-research" | "03-planning" | "04-ui-ux" | "05-task-management" | "06-implementation" | "07-qa" | "08-deployment")[];
            sequential_only: ("01-brainstorm" | "02-research" | "03-planning" | "04-ui-ux" | "05-task-management" | "06-implementation" | "07-qa" | "08-deployment")[];
        };
    };
    consolidation?: {
        default_strategy: string;
        quality_threshold: number;
    } | undefined;
}>;
type AICollaborationConfig = z.infer<typeof AICollaborationConfigSchema>;

interface ProjectPaths {
    root: string;
    config: string;
    stages: string;
    state: string;
    scripts: string;
}
/**
 * Get project paths from root directory
 */
declare function getProjectPaths(projectRoot: string): ProjectPaths;
/**
 * Load pipeline configuration
 */
declare function loadPipelineConfig(projectRoot: string): Promise<PipelineConfig | null>;
/**
 * Load models configuration
 */
declare function loadModelsConfig(projectRoot: string): Promise<ModelsConfig | null>;
/**
 * Load AI collaboration configuration
 */
declare function loadAICollaborationConfig(projectRoot: string): Promise<AICollaborationConfig | null>;
/**
 * Load stage configuration
 */
declare function loadStageConfig(projectRoot: string, stageId: StageId): Promise<StageConfig | null>;
/**
 * Load any config file without schema validation (JSONC priority, YAML fallback)
 */
declare function loadConfig<T>(projectRoot: string, configName: string): Promise<T | null>;
/**
 * Check if a config file exists (checks both .jsonc and .yaml)
 */
declare function configExists(projectRoot: string, configName: string): boolean;
/**
 * Check if a stage config exists (checks both .jsonc and .yaml)
 */
declare function stageConfigExists(projectRoot: string, stageId: StageId): boolean;
/**
 * Get all available config file names (supports .jsonc and .yaml)
 */
declare function getAvailableConfigs(projectRoot: string): string[];
/**
 * Config loader class for managing multiple configurations
 */
declare class ConfigLoader {
    private projectRoot;
    private cache;
    constructor(projectRoot: string);
    /**
     * Load config with caching
     */
    load<T>(configName: string): Promise<T | null>;
    /**
     * Load pipeline config
     */
    loadPipeline(): Promise<PipelineConfig | null>;
    /**
     * Load models config
     */
    loadModels(): Promise<ModelsConfig | null>;
    /**
     * Load AI collaboration config
     */
    loadAICollaboration(): Promise<AICollaborationConfig | null>;
    /**
     * Load stage config
     */
    loadStage(stageId: StageId): Promise<StageConfig | null>;
    /**
     * Clear cache
     */
    clearCache(): void;
    /**
     * Get project paths
     */
    getPaths(): ProjectPaths;
}

/**
 * Validation severity levels
 */
type Severity = 'critical' | 'high' | 'medium';
/**
 * Validation result entry
 */
interface ValidationResult {
    severity: Severity;
    rule: string;
    stage?: string;
    message: string;
    fixable: boolean;
    fixed?: boolean;
}
/**
 * Validation summary
 */
interface ValidationSummary {
    critical: number;
    high: number;
    medium: number;
    passed: number;
    fixed: number;
    results: ValidationResult[];
}
/**
 * Validator options
 */
interface ValidatorOptions {
    fix?: boolean;
    verbose?: boolean;
    stage?: string;
    rule?: string;
}
/**
 * Available validation rules
 */
declare const VALIDATION_RULES: readonly ["model_references", "parallel_alignment", "collaboration_consistency", "file_references", "auto_invoke", "execution_mode", "ai_wrapper_health", "mcp_servers", "epic_cycles", "requirements_refinement", "implementation_order", "notion_integration", "prerequisites"];
type ValidationRule = (typeof VALIDATION_RULES)[number];
/**
 * Configuration Validator class
 */
declare class ConfigValidator {
    private projectRoot;
    private configDir;
    private stagesDir;
    private options;
    private summary;
    constructor(projectRoot: string, options?: ValidatorOptions);
    /**
     * Add a validation result
     */
    private addResult;
    /**
     * Add a pass result
     */
    private addPass;
    /**
     * Get stages to validate
     */
    private getStagesToValidate;
    /**
     * Get defined models from models.yaml
     */
    private getDefinedModels;
    /**
     * Get parallel capable stages from ai_collaboration.yaml
     */
    private getParallelStages;
    /**
     * Rule 1: Model References (CRITICAL)
     * Every model in stage config must exist in models.yaml
     */
    validateModelReferences(): Promise<void>;
    /**
     * Rule 2: Parallel Alignment (CRITICAL)
     * parallel_capable stages must match config.yaml collaboration settings
     */
    validateParallelAlignment(): Promise<void>;
    /**
     * Rule 3: Collaboration Consistency (CRITICAL)
     * Parallel stages need 2+ models configured
     */
    validateCollaborationConsistency(): Promise<void>;
    /**
     * Rule 4: File References (HIGH)
     * Required input/output files exist
     */
    validateFileReferences(): Promise<void>;
    /**
     * Rule 5: Auto-Invoke (HIGH)
     * Wrapper scripts exist, fallback model defined
     */
    validateAutoInvoke(): Promise<void>;
    /**
     * Rule 6: Execution Mode (HIGH)
     * Stage mode aligns with model capabilities
     */
    validateExecutionMode(): Promise<void>;
    /**
     * Rule 7: AI Wrapper Health (HIGH)
     * AI wrapper scripts are executable and functional
     */
    validateAIWrapperHealth(): Promise<void>;
    /**
     * Rule 8: MCP Servers (MEDIUM)
     * Referenced MCP servers have fallback configs
     */
    validateMCPServers(): Promise<void>;
    /**
     * Rule 9: Epic Cycles (MEDIUM)
     * Validate epic_cycles.yaml structure and settings
     */
    validateEpicCycles(): Promise<void>;
    /**
     * Rule 10: Requirements Refinement (MEDIUM)
     */
    validateRequirementsRefinement(): Promise<void>;
    /**
     * Rule 11: Implementation Order (MEDIUM)
     */
    validateImplementationOrder(): Promise<void>;
    /**
     * Rule 12: Notion Integration (MEDIUM)
     */
    validateNotionIntegration(): Promise<void>;
    /**
     * Rule 13: Prerequisites (MEDIUM)
     */
    validatePrerequisites(): Promise<void>;
    /**
     * Run all validations
     */
    validate(): Promise<ValidationSummary>;
    /**
     * Get exit code based on results
     */
    getExitCode(): number;
}
/**
 * Print validation summary
 */
declare function printValidationSummary(summary: ValidationSummary): void;
/**
 * Print recovery guide
 */
declare function printRecoveryGuide(): void;
/**
 * Validate configuration (convenience function)
 */
declare function validateConfig(projectRoot: string, options?: ValidatorOptions): Promise<ValidationSummary>;

/**
 * State type definitions
 */

/**
 * Progress JSON schema
 */
/**
 * Multi-model execution tracking for a stage
 */
declare const MultiModelStatusSchema: z.ZodObject<{
    executed: z.ZodBoolean;
    quality_status: z.ZodEnum<["passed", "failed", "bypassed"]>;
    synthesis_verified: z.ZodBoolean;
}, "strip", z.ZodTypeAny, {
    executed: boolean;
    quality_status: "passed" | "failed" | "bypassed";
    synthesis_verified: boolean;
}, {
    executed: boolean;
    quality_status: "passed" | "failed" | "bypassed";
    synthesis_verified: boolean;
}>;
type MultiModelStatus = z.infer<typeof MultiModelStatusSchema>;
declare const ProgressSchema: z.ZodObject<{
    project_name: z.ZodString;
    current_stage: z.ZodEnum<["01-brainstorm", "02-research", "03-planning", "04-ui-ux", "05-task-management", "06-implementation", "07-qa", "08-deployment"]>;
    stage_status: z.ZodEnum<["pending", "in_progress", "completed", "skipped"]>;
    started_at: z.ZodString;
    last_updated: z.ZodString;
    pipeline: z.ZodOptional<z.ZodObject<{
        name: z.ZodString;
        version: z.ZodString;
        started_at: z.ZodString;
        updated_at: z.ZodString;
    }, "strip", z.ZodTypeAny, {
        name: string;
        version: string;
        started_at: string;
        updated_at: string;
    }, {
        name: string;
        version: string;
        started_at: string;
        updated_at: string;
    }>>;
    stages: z.ZodRecord<z.ZodEnum<["01-brainstorm", "02-research", "03-planning", "04-ui-ux", "05-task-management", "06-implementation", "07-qa", "08-deployment"]>, z.ZodObject<{
        status: z.ZodEnum<["pending", "in_progress", "completed", "skipped"]>;
        started_at: z.ZodNullable<z.ZodString>;
        completed_at: z.ZodNullable<z.ZodString>;
        checkpoint_id: z.ZodNullable<z.ZodString>;
        multi_model: z.ZodOptional<z.ZodObject<{
            executed: z.ZodBoolean;
            quality_status: z.ZodEnum<["passed", "failed", "bypassed"]>;
            synthesis_verified: z.ZodBoolean;
        }, "strip", z.ZodTypeAny, {
            executed: boolean;
            quality_status: "passed" | "failed" | "bypassed";
            synthesis_verified: boolean;
        }, {
            executed: boolean;
            quality_status: "passed" | "failed" | "bypassed";
            synthesis_verified: boolean;
        }>>;
        refactoring_metrics: z.ZodOptional<z.ZodObject<{
            files_reviewed: z.ZodArray<z.ZodString, "many">;
            violations: z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString, "many">>;
            violations_fixed: z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString, "many">>;
            duplication_removed: z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString, "many">>;
            complexity_hotspots: z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString, "many">>;
        }, "strip", z.ZodTypeAny, {
            files_reviewed: string[];
            violations: Record<string, string[]>;
            violations_fixed: Record<string, string[]>;
            duplication_removed: Record<string, string[]>;
            complexity_hotspots: Record<string, string[]>;
        }, {
            files_reviewed: string[];
            violations: Record<string, string[]>;
            violations_fixed: Record<string, string[]>;
            duplication_removed: Record<string, string[]>;
            complexity_hotspots: Record<string, string[]>;
        }>>;
    }, "strip", z.ZodTypeAny, {
        status: "pending" | "in_progress" | "completed" | "skipped";
        checkpoint_id: string | null;
        started_at: string | null;
        completed_at: string | null;
        multi_model?: {
            executed: boolean;
            quality_status: "passed" | "failed" | "bypassed";
            synthesis_verified: boolean;
        } | undefined;
        refactoring_metrics?: {
            files_reviewed: string[];
            violations: Record<string, string[]>;
            violations_fixed: Record<string, string[]>;
            duplication_removed: Record<string, string[]>;
            complexity_hotspots: Record<string, string[]>;
        } | undefined;
    }, {
        status: "pending" | "in_progress" | "completed" | "skipped";
        checkpoint_id: string | null;
        started_at: string | null;
        completed_at: string | null;
        multi_model?: {
            executed: boolean;
            quality_status: "passed" | "failed" | "bypassed";
            synthesis_verified: boolean;
        } | undefined;
        refactoring_metrics?: {
            files_reviewed: string[];
            violations: Record<string, string[]>;
            violations_fixed: Record<string, string[]>;
            duplication_removed: Record<string, string[]>;
            complexity_hotspots: Record<string, string[]>;
        } | undefined;
    }>>;
    current_iteration: z.ZodOptional<z.ZodObject<{
        current_sprint: z.ZodNumber;
        total_sprints: z.ZodNumber;
        epic_context: z.ZodOptional<z.ZodObject<{
            enabled: z.ZodBoolean;
            current_cycle: z.ZodNumber;
            total_cycles: z.ZodNumber;
        }, "strip", z.ZodTypeAny, {
            enabled: boolean;
            current_cycle: number;
            total_cycles: number;
        }, {
            enabled: boolean;
            current_cycle: number;
            total_cycles: number;
        }>>;
    }, "strip", z.ZodTypeAny, {
        current_sprint: number;
        total_sprints: number;
        epic_context?: {
            enabled: boolean;
            current_cycle: number;
            total_cycles: number;
        } | undefined;
    }, {
        current_sprint: number;
        total_sprints: number;
        epic_context?: {
            enabled: boolean;
            current_cycle: number;
            total_cycles: number;
        } | undefined;
    }>>;
    sprints: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
        status: z.ZodEnum<["pending", "in_progress", "completed"]>;
        tasks_total: z.ZodNumber;
        tasks_completed: z.ZodNumber;
        checkpoint_id: z.ZodNullable<z.ZodString>;
        milestones: z.ZodOptional<z.ZodObject<{
            pre_sprint: z.ZodEnum<["pending", "done"]>;
            mid_sprint: z.ZodEnum<["pending", "done"]>;
            sprint_review: z.ZodEnum<["pending", "done"]>;
        }, "strip", z.ZodTypeAny, {
            pre_sprint: "pending" | "done";
            mid_sprint: "pending" | "done";
            sprint_review: "pending" | "done";
        }, {
            pre_sprint: "pending" | "done";
            mid_sprint: "pending" | "done";
            sprint_review: "pending" | "done";
        }>>;
    }, "strip", z.ZodTypeAny, {
        status: "pending" | "in_progress" | "completed";
        tasks_total: number;
        tasks_completed: number;
        checkpoint_id: string | null;
        milestones?: {
            pre_sprint: "pending" | "done";
            mid_sprint: "pending" | "done";
            sprint_review: "pending" | "done";
        } | undefined;
    }, {
        status: "pending" | "in_progress" | "completed";
        tasks_total: number;
        tasks_completed: number;
        checkpoint_id: string | null;
        milestones?: {
            pre_sprint: "pending" | "done";
            mid_sprint: "pending" | "done";
            sprint_review: "pending" | "done";
        } | undefined;
    }>>>;
    epic_cycle: z.ZodOptional<z.ZodObject<{
        enabled: z.ZodBoolean;
        current_cycle: z.ZodNumber;
        total_cycles: z.ZodNumber;
        scope: z.ZodObject<{
            start_stage: z.ZodEnum<["01-brainstorm", "02-research", "03-planning", "04-ui-ux", "05-task-management", "06-implementation", "07-qa", "08-deployment"]>;
            end_stage: z.ZodEnum<["01-brainstorm", "02-research", "03-planning", "04-ui-ux", "05-task-management", "06-implementation", "07-qa", "08-deployment"]>;
        }, "strip", z.ZodTypeAny, {
            start_stage: "01-brainstorm" | "02-research" | "03-planning" | "04-ui-ux" | "05-task-management" | "06-implementation" | "07-qa" | "08-deployment";
            end_stage: "01-brainstorm" | "02-research" | "03-planning" | "04-ui-ux" | "05-task-management" | "06-implementation" | "07-qa" | "08-deployment";
        }, {
            start_stage: "01-brainstorm" | "02-research" | "03-planning" | "04-ui-ux" | "05-task-management" | "06-implementation" | "07-qa" | "08-deployment";
            end_stage: "01-brainstorm" | "02-research" | "03-planning" | "04-ui-ux" | "05-task-management" | "06-implementation" | "07-qa" | "08-deployment";
        }>;
    }, "strip", z.ZodTypeAny, {
        enabled: boolean;
        current_cycle: number;
        total_cycles: number;
        scope: {
            start_stage: "01-brainstorm" | "02-research" | "03-planning" | "04-ui-ux" | "05-task-management" | "06-implementation" | "07-qa" | "08-deployment";
            end_stage: "01-brainstorm" | "02-research" | "03-planning" | "04-ui-ux" | "05-task-management" | "06-implementation" | "07-qa" | "08-deployment";
        };
    }, {
        enabled: boolean;
        current_cycle: number;
        total_cycles: number;
        scope: {
            start_stage: "01-brainstorm" | "02-research" | "03-planning" | "04-ui-ux" | "05-task-management" | "06-implementation" | "07-qa" | "08-deployment";
            end_stage: "01-brainstorm" | "02-research" | "03-planning" | "04-ui-ux" | "05-task-management" | "06-implementation" | "07-qa" | "08-deployment";
        };
    }>>;
    implementation_order: z.ZodOptional<z.ZodObject<{
        selected: z.ZodNullable<z.ZodString>;
    }, "strip", z.ZodTypeAny, {
        selected: string | null;
    }, {
        selected: string | null;
    }>>;
    requirements_refinement: z.ZodOptional<z.ZodObject<{
        active: z.ZodBoolean;
    }, "strip", z.ZodTypeAny, {
        active: boolean;
    }, {
        active: boolean;
    }>>;
    checkpoints: z.ZodOptional<z.ZodArray<z.ZodObject<{
        id: z.ZodString;
        stage: z.ZodEnum<["01-brainstorm", "02-research", "03-planning", "04-ui-ux", "05-task-management", "06-implementation", "07-qa", "08-deployment"]>;
        created_at: z.ZodString;
        description: z.ZodOptional<z.ZodString>;
    }, "strip", z.ZodTypeAny, {
        id: string;
        stage: "01-brainstorm" | "02-research" | "03-planning" | "04-ui-ux" | "05-task-management" | "06-implementation" | "07-qa" | "08-deployment";
        created_at: string;
        description?: string | undefined;
    }, {
        id: string;
        stage: "01-brainstorm" | "02-research" | "03-planning" | "04-ui-ux" | "05-task-management" | "06-implementation" | "07-qa" | "08-deployment";
        created_at: string;
        description?: string | undefined;
    }>, "many">>;
}, "strip", z.ZodTypeAny, {
    stages: Partial<Record<"01-brainstorm" | "02-research" | "03-planning" | "04-ui-ux" | "05-task-management" | "06-implementation" | "07-qa" | "08-deployment", {
        status: "pending" | "in_progress" | "completed" | "skipped";
        checkpoint_id: string | null;
        started_at: string | null;
        completed_at: string | null;
        multi_model?: {
            executed: boolean;
            quality_status: "passed" | "failed" | "bypassed";
            synthesis_verified: boolean;
        } | undefined;
        refactoring_metrics?: {
            files_reviewed: string[];
            violations: Record<string, string[]>;
            violations_fixed: Record<string, string[]>;
            duplication_removed: Record<string, string[]>;
            complexity_hotspots: Record<string, string[]>;
        } | undefined;
    }>>;
    project_name: string;
    current_stage: "01-brainstorm" | "02-research" | "03-planning" | "04-ui-ux" | "05-task-management" | "06-implementation" | "07-qa" | "08-deployment";
    stage_status: "pending" | "in_progress" | "completed" | "skipped";
    started_at: string;
    last_updated: string;
    pipeline?: {
        name: string;
        version: string;
        started_at: string;
        updated_at: string;
    } | undefined;
    requirements_refinement?: {
        active: boolean;
    } | undefined;
    implementation_order?: {
        selected: string | null;
    } | undefined;
    current_iteration?: {
        current_sprint: number;
        total_sprints: number;
        epic_context?: {
            enabled: boolean;
            current_cycle: number;
            total_cycles: number;
        } | undefined;
    } | undefined;
    sprints?: Record<string, {
        status: "pending" | "in_progress" | "completed";
        tasks_total: number;
        tasks_completed: number;
        checkpoint_id: string | null;
        milestones?: {
            pre_sprint: "pending" | "done";
            mid_sprint: "pending" | "done";
            sprint_review: "pending" | "done";
        } | undefined;
    }> | undefined;
    epic_cycle?: {
        enabled: boolean;
        current_cycle: number;
        total_cycles: number;
        scope: {
            start_stage: "01-brainstorm" | "02-research" | "03-planning" | "04-ui-ux" | "05-task-management" | "06-implementation" | "07-qa" | "08-deployment";
            end_stage: "01-brainstorm" | "02-research" | "03-planning" | "04-ui-ux" | "05-task-management" | "06-implementation" | "07-qa" | "08-deployment";
        };
    } | undefined;
    checkpoints?: {
        id: string;
        stage: "01-brainstorm" | "02-research" | "03-planning" | "04-ui-ux" | "05-task-management" | "06-implementation" | "07-qa" | "08-deployment";
        created_at: string;
        description?: string | undefined;
    }[] | undefined;
}, {
    stages: Partial<Record<"01-brainstorm" | "02-research" | "03-planning" | "04-ui-ux" | "05-task-management" | "06-implementation" | "07-qa" | "08-deployment", {
        status: "pending" | "in_progress" | "completed" | "skipped";
        checkpoint_id: string | null;
        started_at: string | null;
        completed_at: string | null;
        multi_model?: {
            executed: boolean;
            quality_status: "passed" | "failed" | "bypassed";
            synthesis_verified: boolean;
        } | undefined;
        refactoring_metrics?: {
            files_reviewed: string[];
            violations: Record<string, string[]>;
            violations_fixed: Record<string, string[]>;
            duplication_removed: Record<string, string[]>;
            complexity_hotspots: Record<string, string[]>;
        } | undefined;
    }>>;
    project_name: string;
    current_stage: "01-brainstorm" | "02-research" | "03-planning" | "04-ui-ux" | "05-task-management" | "06-implementation" | "07-qa" | "08-deployment";
    stage_status: "pending" | "in_progress" | "completed" | "skipped";
    started_at: string;
    last_updated: string;
    pipeline?: {
        name: string;
        version: string;
        started_at: string;
        updated_at: string;
    } | undefined;
    requirements_refinement?: {
        active: boolean;
    } | undefined;
    implementation_order?: {
        selected: string | null;
    } | undefined;
    current_iteration?: {
        current_sprint: number;
        total_sprints: number;
        epic_context?: {
            enabled: boolean;
            current_cycle: number;
            total_cycles: number;
        } | undefined;
    } | undefined;
    sprints?: Record<string, {
        status: "pending" | "in_progress" | "completed";
        tasks_total: number;
        tasks_completed: number;
        checkpoint_id: string | null;
        milestones?: {
            pre_sprint: "pending" | "done";
            mid_sprint: "pending" | "done";
            sprint_review: "pending" | "done";
        } | undefined;
    }> | undefined;
    epic_cycle?: {
        enabled: boolean;
        current_cycle: number;
        total_cycles: number;
        scope: {
            start_stage: "01-brainstorm" | "02-research" | "03-planning" | "04-ui-ux" | "05-task-management" | "06-implementation" | "07-qa" | "08-deployment";
            end_stage: "01-brainstorm" | "02-research" | "03-planning" | "04-ui-ux" | "05-task-management" | "06-implementation" | "07-qa" | "08-deployment";
        };
    } | undefined;
    checkpoints?: {
        id: string;
        stage: "01-brainstorm" | "02-research" | "03-planning" | "04-ui-ux" | "05-task-management" | "06-implementation" | "07-qa" | "08-deployment";
        created_at: string;
        description?: string | undefined;
    }[] | undefined;
}>;
type Progress = z.infer<typeof ProgressSchema>;
/**
 * Checkpoint metadata
 */
interface CheckpointMetadata {
    id: string;
    stage: string;
    createdAt: string;
    description?: string;
    files: string[];
}

/**
 * Get the path to progress.json
 */
declare function getProgressPath(projectRoot: string): string;
/**
 * Load progress from file
 */
declare function loadProgress(projectRoot: string): Promise<Progress | null>;
/**
 * Save progress to file
 */
declare function saveProgress(projectRoot: string, progress: Progress): Promise<boolean>;
/**
 * Initialize progress for a new project
 */
declare function initProgress(projectRoot: string, projectName: string): Promise<Progress>;
/**
 * Check if progress exists
 */
declare function progressExists(projectRoot: string): boolean;
/**
 * Get current stage from progress
 */
declare function getCurrentStage(projectRoot: string): Promise<StageId | null>;
/**
 * Update current stage
 */
declare function updateCurrentStage(projectRoot: string, stageId: StageId, status?: StageStatus): Promise<boolean>;
/**
 * Mark stage as completed
 */
declare function completeStage(projectRoot: string, stageId: StageId, checkpointId?: string, multiModel?: MultiModelStatus): Promise<boolean>;
/**
 * Get stage status
 */
declare function getStageStatus(projectRoot: string, stageId: StageId): Promise<StageStatus | null>;
/**
 * Update sprint status
 */
declare function updateSprintStatus(projectRoot: string, sprintName: string, status: 'pending' | 'in_progress' | 'completed', tasksCompleted?: number, tasksTotal?: number): Promise<boolean>;
/**
 * Get current sprint
 */
declare function getCurrentSprint(projectRoot: string): Promise<{
    name: string;
    number: number;
    total: number;
} | null>;
/**
 * Advance to next sprint
 */
declare function advanceToNextSprint(projectRoot: string): Promise<boolean>;
/**
 * Add checkpoint to progress
 */
declare function addCheckpointToProgress(projectRoot: string, checkpoint: {
    id: string;
    stage: StageId;
    description?: string;
}): Promise<boolean>;
/**
 * Progress manager class
 */
declare class ProgressManager {
    private projectRoot;
    private progress;
    constructor(projectRoot: string);
    /**
     * Load progress (cached)
     */
    load(): Promise<Progress | null>;
    /**
     * Save progress
     */
    save(): Promise<boolean>;
    /**
     * Reload progress from disk
     */
    reload(): Promise<Progress | null>;
    /**
     * Get current stage
     */
    getCurrentStage(): Promise<StageId | null>;
    /**
     * Set current stage
     */
    setCurrentStage(stageId: StageId, status?: StageStatus): Promise<boolean>;
    /**
     * Complete current stage
     */
    completeCurrentStage(checkpointId?: string): Promise<boolean>;
    /**
     * Get the next stage after the current one.
     * Returns the next StageId or null if pipeline is complete.
     */
    getNextStage(): Promise<StageId | null>;
    /**
     * Check if all stages are completed.
     */
    isComplete(): Promise<boolean>;
    /**
     * Get all stages with their statuses.
     */
    getStageStatuses(): Promise<Array<{
        id: StageId;
        status: StageStatus;
    }>>;
}

/**
 * Generate checkpoint ID
 */
declare function generateCheckpointId(stageId: StageId): string;
/**
 * Get checkpoints directory path
 */
declare function getCheckpointsDir(projectRoot: string): string;
/**
 * Get checkpoint path
 */
declare function getCheckpointPath(projectRoot: string, checkpointId: string): string;
/**
 * List all checkpoints
 */
declare function listCheckpoints(projectRoot: string): Promise<CheckpointMetadata[]>;
/**
 * Get checkpoint metadata
 */
declare function getCheckpointMetadata(projectRoot: string, checkpointId: string): Promise<CheckpointMetadata | null>;
/**
 * Create a checkpoint
 */
declare function createCheckpoint(projectRoot: string, stageId: StageId, options?: {
    description?: string;
    includeStages?: boolean;
    includeState?: boolean;
    includeConfig?: boolean;
}): Promise<CheckpointMetadata | null>;
/**
 * Restore a checkpoint
 */
declare function restoreCheckpoint(projectRoot: string, checkpointId: string, options?: {
    restoreStages?: boolean;
    restoreState?: boolean;
    restoreConfig?: boolean;
    partial?: boolean;
    files?: string[];
}): Promise<boolean>;
/**
 * Delete a checkpoint
 */
declare function deleteCheckpoint(projectRoot: string, checkpointId: string): Promise<boolean>;
/**
 * Clean up old checkpoints based on retention policy
 */
declare function cleanupCheckpoints(projectRoot: string, maxRetention?: number, preserveMilestones?: boolean): Promise<number>;
/**
 * Checkpoint manager class
 */
declare class CheckpointManager {
    private projectRoot;
    constructor(projectRoot: string);
    /**
     * Create a checkpoint
     */
    create(stageId: StageId, description?: string): Promise<CheckpointMetadata | null>;
    /**
     * Restore a checkpoint
     */
    restore(checkpointId: string): Promise<boolean>;
    /**
     * List all checkpoints
     */
    list(): Promise<CheckpointMetadata[]>;
    /**
     * Get checkpoint metadata
     */
    get(checkpointId: string): Promise<CheckpointMetadata | null>;
    /**
     * Delete a checkpoint
     */
    delete(checkpointId: string): Promise<boolean>;
    /**
     * Clean up old checkpoints
     */
    cleanup(maxRetention?: number): Promise<number>;
}

/**
 * Stage persona configuration loaded from stage_personas.jsonc
 */
interface StagePersona {
    role: string;
    temperature: number;
    model: string;
    focus: string;
}
/**
 * Reference files found for a stage
 */
interface StageReferences {
    files: Array<{
        name: string;
        path: string;
        content: string;
    }>;
}
/**
 * Result of a single stage execution
 */
interface StageExecutionResult {
    stageId: StageId;
    success: boolean;
    attempts: number;
    validationScore: number;
    duration_ms: number;
    error?: string;
}
/**
 * Pipeline execution result
 */
interface PipelineResult {
    completed: boolean;
    stagesRun: number;
    stagesCompleted: number;
    stagesFailed: number;
    results: StageExecutionResult[];
    stoppedAt?: StageId;
    error?: string;
}
/**
 * Retry state for a stage attempt
 */
interface StageRetryState {
    stageId: StageId;
    attempt: number;
    maxAttempts: number;
    validationErrors: string[];
    lastScore: number;
}
/**
 * Pipeline state (persisted for pause/resume)
 */
interface PipelineState {
    status: 'running' | 'paused' | 'completed' | 'failed';
    currentStage: StageId | null;
    retryState: StageRetryState | null;
    startedAt: string;
    pausedAt?: string;
}
/**
 * Orchestrator configuration
 */
interface OrchestratorConfig {
    projectRoot: string;
    maxRetries: number;
    startFromStage?: StageId;
    stopAfterStage?: StageId;
    dryRun?: boolean;
}
/**
 * Load stage persona from config
 */
declare function loadStagePersona(projectRoot: string, stageId: StageId): StagePersona | null;
/**
 * Load reference files for a stage
 */
declare function loadStageReferences(projectRoot: string, stageId: StageId): StageReferences;
/**
 * Load stage CLAUDE.md instructions
 */
declare function loadStageInstructions(projectRoot: string, stageId: StageId): string;
/**
 * Load previous stage HANDOFF
 */
declare function loadPreviousHandoff(projectRoot: string, stageId: StageId): string | null;
/**
 * Build the prompt for a stage agent.
 * Combines: stage instructions + persona + previous handoff + references + project brief
 */
declare function buildStagePrompt(projectRoot: string, stageId: StageId): string;
/**
 * Validate stage outputs. Returns validation summary.
 */
declare function validateStage(projectRoot: string, stageId: StageId): Promise<ValidationSummary$1>;
/**
 * Generate HANDOFF for completed stage
 */
declare function generateStageHandoff(projectRoot: string, _stageId: StageId): Promise<boolean>;
/**
 * Get pipeline status summary for display
 */
declare function getPipelineStatus(projectRoot: string): Promise<{
    currentStage: StageId | null;
    stages: Array<{
        id: StageId;
        name: string;
        status: StageStatus;
    }>;
    isComplete: boolean;
    progress: number;
}>;
/**
 * Run the full auto-pilot pipeline.
 *
 * Note: This function manages state transitions and validation.
 * The actual agent execution (Task tool calls) must be handled by
 * the calling context (Claude Code session via /auto-pilot command).
 *
 * This function is designed to be called step-by-step from the
 * auto-pilot command, not as a single blocking call.
 */
declare function prepareStageExecution(projectRoot: string, stageId: StageId): Promise<{
    prompt: string;
    persona: StagePersona | null;
    model: string;
}>;
/**
 * Finalize a stage after agent execution.
 * Validates outputs, generates HANDOFF, creates checkpoint, updates progress.
 */
declare function finalizeStage(projectRoot: string, stageId: StageId): Promise<{
    success: boolean;
    validation: ValidationSummary$1;
    nextStage: StageId | null;
}>;
/**
 * Build a retry prompt that includes validation feedback from the failed attempt.
 */
declare function buildRetryPrompt(projectRoot: string, stageId: StageId, retryState: StageRetryState): string;
/**
 * Finalize a stage with retry support.
 * Returns updated retry state if validation fails within retry budget.
 */
declare function finalizeStageWithRetry(projectRoot: string, stageId: StageId, retryState: StageRetryState | null): Promise<{
    success: boolean;
    validation: ValidationSummary$1;
    nextStage: StageId | null;
    retryState: StageRetryState | null;
    shouldRetry: boolean;
}>;
/**
 * Load pipeline state from disk
 */
declare function loadPipelineState(projectRoot: string): PipelineState | null;
/**
 * Save pipeline state to disk
 */
declare function savePipelineState(projectRoot: string, state: PipelineState): void;
/**
 * Pause the pipeline
 */
declare function pausePipeline(projectRoot: string): PipelineState;
/**
 * Resume a paused pipeline
 */
declare function resumePipeline(projectRoot: string): PipelineState | null;
/**
 * Skip the current stage
 */
declare function skipStage(projectRoot: string, stageId: StageId): Promise<StageId | null>;

/**
 * Built-in model registry — offline fallback when GitHub manifest is unreachable
 * Update these values before each npm publish to reflect the latest Claude models.
 */
/** User-facing model role names */
type ModelRole = 'reasoning' | 'balanced' | 'fast';
/** Internal tier names consumed by the Task tool */
type ModelTierName = 'opus' | 'sonnet' | 'haiku';
/**
 * Single mapping from role → tier.
 * Change ONLY this constant to swap every model in the pipeline.
 */
declare const ROLE_TO_TIER: Record<ModelRole, ModelTierName>;
/** All valid values for a `model` field in user-facing config */
declare const MODEL_ROLES: readonly ["reasoning", "balanced", "fast", "inherit"];
/**
 * Resolve a user-facing role name to the Task tool tier.
 * Returns `undefined` for `'inherit'`, `undefined`/`null`, or unknown values.
 */
declare function resolveToTier(model?: string): string | undefined;
interface ModelTier {
    id: string;
    available: boolean;
}
interface ResolvedModels {
    source: 'manifest' | 'builtin';
    tiers: Record<'opus' | 'sonnet' | 'haiku', ModelTier>;
    timestamp: string;
}
declare const BUILTIN_MODEL_REGISTRY: ResolvedModels;

/**
 * Model resolver with 2-tier fallback:
 * 1. GitHub manifest (public URL, no API key needed) — 3s timeout
 * 2. Built-in registry (always succeeds, offline-safe)
 */

/**
 * Resolve available models using 2-tier fallback.
 * Manifest failure silently falls back to the built-in registry.
 */
declare function resolveModels(): Promise<ResolvedModels>;

/**
 * Model assigner — maps resolved model tiers to debate roles and stage personas.
 *
 * Each role has an "ideal" tier. If that tier is unavailable, it falls back to sonnet.
 * Output values use user-facing role names (reasoning/balanced/fast).
 */

interface ModelAssignment {
    /** stage → role-index → user-facing role name */
    stageRoles: Record<string, Record<string, ModelRole>>;
    /** stage → default_model role name */
    stageDefaults: Record<string, ModelRole>;
    /** stage → persona role name */
    personas: Record<string, ModelRole>;
}
/**
 * Assign optimal model tiers based on resolved availability.
 * Returns user-facing role names (reasoning/balanced/fast).
 */
declare function assignModelsToRoles(resolved: ResolvedModels): ModelAssignment;

export { BUILTIN_MODEL_REGISTRY, CheckpointManager, ConfigLoader, ConfigValidator, MODEL_ROLES, type ModelAssignment, type ModelRole, type ModelTier, type OrchestratorConfig, type PipelineResult, type PipelineState, ProgressManager, type ProjectPaths, ROLE_TO_TIER, type ResolvedModels, type Severity, type StageExecutionResult, type StagePersona, type StageReferences, type StageRetryState, VALIDATION_RULES, type ValidationResult, type ValidationRule, type ValidationSummary, type ValidatorOptions, addCheckpointToProgress, advanceToNextSprint, assignModelsToRoles, buildRetryPrompt, buildStagePrompt, cleanupCheckpoints, completeStage, configExists, createCheckpoint, deleteCheckpoint, finalizeStage, finalizeStageWithRetry, generateCheckpointId, generateStageHandoff, getAvailableConfigs, getCheckpointMetadata, getCheckpointPath, getCheckpointsDir, getCurrentSprint, getCurrentStage, getPipelineStatus, getProgressPath, getProjectPaths, getStageStatus, initProgress, listCheckpoints, loadAICollaborationConfig, loadConfig, loadModelsConfig, loadPipelineConfig, loadPipelineState, loadPreviousHandoff, loadProgress, loadStageConfig, loadStageInstructions, loadStagePersona, loadStageReferences, pausePipeline, prepareStageExecution, printRecoveryGuide, printValidationSummary, progressExists, resolveModels, resolveToTier, restoreCheckpoint, resumePipeline, savePipelineState, saveProgress, skipStage, stageConfigExists, updateCurrentStage, updateSprintStatus, validateConfig, validateStage };