/**
 * Task Manager - Core task management logic
 * @requirement REQ-V2-003
 */
import { type Task, type WorkflowState } from '@shadel/workflow-core';
import { ContextInjector } from './context-injector.js';
import { StateActionHandler, RateLimitingChecker, StateHistoryUpdater, StatePersistenceHandler, StatePrerequisitesValidator } from './task-state-orchestrator.js';
export declare class TaskManager implements StateActionHandler, RateLimitingChecker, StateHistoryUpdater, StatePersistenceHandler, StatePrerequisitesValidator {
    private contextDir;
    private taskFile;
    private contextInjector;
    /**
     * Get context injector (for CLI commands)
     */
    getContextInjector(): ContextInjector;
    private roleSystem;
    private ruleManager;
    private queueManager;
    private migration;
    private migrationChecked;
    private fileSync;
    private validator;
    private fileLock;
    private loaderService;
    private contextService;
    private orchestrator;
    private retrievalService;
    private completionService;
    private creationService;
    private updateService;
    private listService;
    private reviewChecklistService;
    private stateChecklistService;
    private checklistRegistry;
    private workflowAnalysisService;
    private stateEnforcementGenerator;
    constructor(contextDir?: string);
    /**
     * Check and run migration if needed (only once per instance)
     * Cursor Integration: Ensures Cursor can read from new format after migration
     */
    private ensureMigration;
    /**
     * Create a new task
     *
     * REFACTORED: Phase 4 - Delegates to TaskCreationService
     *
     * @param goal Task goal/description
     * @param requirements Optional requirement IDs
     * @param force Force activation if task is queued
     * @returns Created task
     */
    createTask(goal: string, requirements?: string[], force?: boolean): Promise<Task>;
    /**
     * Get current task
     * @requirement REQ-V2-003 - Task status retrieval
     * @requirement FREE-TIER-001 - Use TaskQueueManager for multi-task support
     */
    /**
     * Get current active task
     *
     * REFACTORED: Phase 4 - Delegates to TaskRetrievalService
     *
     * @returns Current task or null if no active task
     */
    getCurrentTask(): Promise<Task | null>;
    /**
     * Sync current-task.json from queue (one-way sync)
     * Only syncs if task is ACTIVE
     * Validates sync succeeded
     * Preserves specified fields (requirements, etc.)
     *
     * NOW PUBLIC: CLI commands need to use this
     *
     * @param queueTask Task from queue to sync (optional, will get active task if not provided)
     * @param preserveFields Fields to preserve from existing file
     */
    /**
     * Sync file from queue task
     * REFACTORED: Now uses TaskFileSync for centralized, consistent file operations
     *
     * This method delegates to TaskFileSync.syncFromQueue() which provides:
     * - File locking (prevents race conditions)
     * - Atomic writes (prevents corruption)
     * - Backup/rollback support
     * - Consistency verification
     * - Proper handling of reviewChecklist and all fields
     *
     * @param queueTask - Task from queue (optional, will fetch active task if not provided)
     * @param preserveFields - Fields to preserve from existing file (default: ['requirements'])
     */
    syncFileFromQueue(queueTask?: any, preserveFields?: string[]): Promise<void>;
    /**
     * Update task state
     * @requirement REQ-V2-002 - State machine integration
     * @requirement REQ-V2-010 - Auto-inject context after state change
     * @requirement BUG-FIX-001 - Validate state transitions
     * @requirement BUG-FIX-009 - Validate state history integrity
     * @requirement REFACTOR-EXTRACT-ORCHESTRATION-SERVICES - Phase 3: Use orchestrator
     */
    updateTaskState(state: WorkflowState): Promise<void>;
    /**
     * Handle state-specific actions after state is saved
     *
     * REFACTORED: Extracted from updateTaskState() to reduce complexity.
     * Executes actions specific to certain states (e.g., initialize checklist for REVIEWING).
     * Called AFTER state is persisted to ensure state is saved first.
     *
     * @param state - New workflow state
     *
     * @requirement REFACTOR-DECOMPOSE-COMPLEX-FUNCTIONS - Phase 2: Extract helper methods
     * @requirement REFACTOR-EXTRACT-ORCHESTRATION-SERVICES - Phase 3: Implements StateActionHandler
     */
    handleStateSpecificActions(state: WorkflowState): Promise<void>;
    /**
     * Persist state update to queue and file
     *
     * REFACTORED: Extracted from updateTaskState() to reduce complexity.
     * Updates queue system with lock, then syncs file atomically.
     * Falls back to direct file write if no queue task (backward compatibility).
     *
     * @param activeQueueTask - Active task from queue (may be null)
     * @param taskData - Task data to persist
     * @param taskId - Task ID
     *
     * @requirement REFACTOR-DECOMPOSE-COMPLEX-FUNCTIONS - Phase 2: Extract helper methods
     * @requirement REFACTOR-EXTRACT-ORCHESTRATION-SERVICES - Phase 3: Implements StatePersistenceHandler
     */
    persistStateUpdate(activeQueueTask: any, taskData: any, taskId: string): Promise<void>;
    /**
     * Update state in history and current state
     *
     * REFACTORED: Extracted from updateTaskState() to reduce complexity.
     * Records OLD state in history before updating to new state.
     * History tracks completed steps, not current step.
     *
     * @param taskData - Task data object to update
     * @param currentState - Current workflow state (will be recorded in history)
     * @param newState - New workflow state (will become current state)
     *
     * @requirement REFACTOR-DECOMPOSE-COMPLEX-FUNCTIONS - Phase 2: Extract helper methods
     * @requirement REFACTOR-EXTRACT-ORCHESTRATION-SERVICES - Phase 3: Implements StateHistoryUpdater
     * @requirement BUG-FIX-012 - Record OLD state in history
     */
    updateStateInHistory(taskData: any, currentState: WorkflowState, newState: WorkflowState): void;
    /**
     * Check rate limiting for state changes
     *
     * REFACTORED: Extracted from updateTaskState() to reduce complexity.
     * Warns if state changes too rapidly. Reloads file data to ensure freshness
     * for rate limiting check.
     *
     * @param fileTaskData - File task data (may be null)
     * @param taskData - Task data (fallback if file data unavailable)
     *
     * @requirement REFACTOR-DECOMPOSE-COMPLEX-FUNCTIONS - Phase 2: Extract helper methods
     * @requirement REFACTOR-EXTRACT-ORCHESTRATION-SERVICES - Phase 3: Implements RateLimitingChecker
     * @requirement BUG-FIX-010 - Rate limiting on state changes
     */
    checkRateLimiting(fileTaskData: any, taskData: any): Promise<void>;
    /**
     * Validate state update operation
     *
     * REFACTORED: Extracted from updateTaskState() to reduce complexity.
     * Performs all validation checks before allowing state transition:
     * - State history integrity
     * - State transition validity
     * - State prerequisites
     *
     * @param validationData - Task data for validation (prefer file data to catch corruption)
     * @param currentState - Current workflow state
     * @param newState - Target workflow state
     * @throws Error if validation fails
     *
     * @requirement REFACTOR-DECOMPOSE-COMPLEX-FUNCTIONS - Phase 2: Extract helper methods
     */
    /**
     * Validate state history integrity
     *
     * REFACTORED: Phase 8 - Delegates to TaskValidator
     *
     * @requirement BUG-FIX-009 - Prevent state forgery
     * @requirement BUG-FIX-009-AI - Public API for AI flow correction
     * @public API for reuse across commands and hooks
     */
    validateStateHistory(taskData?: any): Promise<void>;
    /**
     * Analyze workflow completeness for AI users
     *
     * REFACTORED: Phase 6 - Delegates to WorkflowAnalysisService
     *
     * @returns Workflow completeness analysis result
     */
    analyzeWorkflowCompleteness(): Promise<{
        complete: boolean;
        currentState: WorkflowState;
        missingPhases: WorkflowState[];
        instructions?: string;
    }>;
    /**
     * Check for rapid state changes (quality indicator)
     * @requirement BUG-FIX-010 - Detect suspiciously fast progression
     * @note For AI users, this is informational only (AI is fast!)
     */
    private checkRapidStateChange;
    /**
     * Validate prerequisites for entering a state
     * @requirement BUG-FIX-001 - Quality gates
     * @requirement REFACTOR-EXTRACT-ORCHESTRATION-SERVICES - Phase 3: Implements StatePrerequisitesValidator
     * Phase 3.2: Enhanced with checklist blocking for all states
     */
    validateStatePrerequisites(state: WorkflowState): Promise<void>;
    /**
     * Initialize review checklist when entering REVIEWING state
     *
     * REFACTORED: Phase 5 - Delegates to ReviewChecklistService
     */
    private initializeReviewChecklist;
    /**
     * Validate that review checklist is complete before allowing READY_TO_COMMIT
     *
     * REFACTORED: Phase 5 - Delegates to ReviewChecklistService
     */
    private validateReviewChecklistComplete;
    /**
     * Save review checklist to task
     *
     * REFACTORED: Phase 5 - Delegates to ReviewChecklistService
     */
    private saveReviewChecklist;
    /**
     * Load review checklist from task
     *
     * REFACTORED: Phase 5 - Delegates to ReviewChecklistService
     */
    private loadReviewChecklist;
    /**
     * Complete task
     * @requirement REQ-V2-003 - Task lifecycle completion
     * @requirement REQ-V2-010 - Auto-inject context after completion
     * @requirement BUG-FIX-003 - Require READY_TO_COMMIT state
     * @requirement FREE-TIER-001 - Use TaskQueueManager for multi-task support
     */
    /**
     * Complete the current active task
     *
     * REFACTORED: Phase 4 - Delegates to TaskCompletionService
     *
     * @returns Completion result with alreadyCompleted flag
     */
    completeTask(options?: {
        autoActivateNext?: boolean;
        noCommit?: boolean;
    }): Promise<{
        alreadyCompleted: boolean;
        commitResult?: {
            success: boolean;
            commitHash?: string;
            error?: string;
        };
    }>;
    /**
     * Get workflow progress
     *
     * REFACTORED: Now uses TaskStateEngine.getProgress() instead of WorkflowEngine.
     * Gets current state from active task and calculates progress.
     *
     * Note: Changed from sync to async to load current task state.
     */
    getProgress(): Promise<number>;
    /**
     * List tasks (current + history)
     *
     * REFACTORED: Phase 4 - Delegates to TaskListService
     *
     * @param statusFilter Optional workflow state filter
     * @param limit Maximum number of tasks to return (default: 10)
     * @returns Array of tasks
     */
    listTasks(statusFilter?: string, limit?: number): Promise<Task[]>;
    /**
     * Update task details
     *
     * REFACTORED: Phase 4 - Delegates to TaskUpdateService
     *
     * @param taskId Task ID to update
     * @param updates Update options (goal, addReq)
     */
    updateTask(taskId: string, updates: {
        goal?: string;
        addReq?: string;
    }): Promise<void>;
    /**
     * Generate state enforcement .mdc file
     *
     * REFACTORED: Phase 7 - Delegates to StateEnforcementGenerator
     *
     * @param state Current workflow state
     */
    private generateStateEnforcementMDC;
}