/**
 * OpenKernel — Mission Planner
 *
 * Decomposes a one-line goal into a sequence of PHASES (each becomes an
 * objective), so a large build spreads across the right models by aspect
 * (architecture → implementation → verification) instead of one model
 * one-shotting the whole thing. Each phase carries the capabilities it needs;
 * the scheduler turns those into a per-phase model benchmark floor.
 *
 * LLM-driven when a capable provider is available, with a deterministic
 * heuristic fallback so planning never blocks on model availability.
 */
import type { Logger, MissionPhaseInput, Policy } from './types.js';
import type { ProviderManager } from './provider-manager.js';
import type { CapabilityRouter } from './router.js';
import { normalizeCapabilities } from './capability-map.js';
export interface MissionPlannerDeps {
    providerManager: ProviderManager;
    router: CapabilityRouter;
    logger: Logger;
}
export interface PlanOptions {
    description?: string;
    policy?: Policy;
    /** Max phases to request (default 6). */
    maxPhases?: number;
}
export declare class MissionPlanner {
    private deps;
    constructor(deps: MissionPlannerDeps);
    plan(goal: string, opts?: PlanOptions): Promise<MissionPhaseInput[]>;
    private planWithLlm;
    /** Extract + validate a phase array from a model's (possibly noisy) response. */
    private parsePhases;
    /**
     * Deterministic fallback plan. Always yields buildable phases; adds a frontend
     * phase for UI-shaped goals. Capabilities are natural — the scheduler
     * normalizes them and derives each phase's model tier.
     */
    private heuristicPhases;
}
export { normalizeCapabilities };