import type { Capability, Logger, Mission, MissionInput, Objective, Task, TaskInput } from './types.js';
import type { EventBus } from './event-bus.js';
export declare class Scheduler {
    private eventBus;
    private logger;
    constructor(eventBus: EventBus, logger: Logger);
    planMission(missionId: string, input: MissionInput): {
        objectives: Objective[];
        tasks: Task[];
    };
    /**
     * Build one objective per phase. Capabilities are normalized (natural names
     * allowed), each phase's tasks depend on ALL tasks of the phases it dependsOn
     * (so phases run in order but tasks within a phase can parallelize), and each
     * phase gets its own model benchmark floor → different models per phase.
     */
    private planPhases;
    createTask(missionId: string, objectiveId: string, description: string, capabilities: Capability[], dependencies: string[], input: TaskInput): Task;
    /**
     * Returns the next batch of tasks that are ready to execute:
     * dependencies satisfied, not yet completed/failed/skipped.
     */
    nextReadyTasks(mission: Mission, maxBatch: number): Task[];
    /**
     * Topologically sorts tasks honoring dependency edges.
     * Used for sequential mode.
     */
    topoSort(tasks: Task[]): Task[];
    isMissionComplete(mission: Mission): boolean;
    hasFailed(mission: Mission): boolean;
    allObjectivesComplete(mission: Mission): boolean;
    /**
     * Marks an objective complete when all its tasks complete.
     */
    reconcileObjectives(mission: Mission): void;
    private aggregateCapabilities;
}
/**
 * Per-phase model benchmark floor (0–100). Demanding phases (architecture,
 * verification, review, reasoning-heavy) demand a more capable model; lighter
 * phases (docs, translation, plain search) leave the floor open so the router
 * can pick a cheaper/faster model. This is what lets one large mission spread
 * across models by aspect instead of one-shotting with a single model.
 */
export declare function phaseBenchmarkFloor(caps: Capability[]): number;
/** Human-readable phase label from an objective's dominant capability. */
export declare function phaseLabel(caps: Capability[]): string;