/**
 * OrchestratedMissionExecutor — concrete MissionExecutor that bridges the
 * autonomous queue to the full OrchestrationLoop.
 *
 * Phase 1 (Daemon Wakeup) of the autonomous-agent milestone.
 *
 * The QueueScheduler owns the *queue* (pending → running → terminal) and
 * retry policy. This executor owns the *translation*: a queued MissionSpec
 * (id + goal + context) becomes a classified task and is run through the
 * OrchestrationLoop, which already wires governance, dynamic agent birth,
 * planning, review, and memory curation internally.
 *
 * Result mapping: OrchestrationLoop returns a MissionState whose terminal
 * `status` is 'completed' | 'failed' (set by the ReviewerAgent gate). The
 * judgeOutcome() policy converts that into the queue's
 * MissionExecutionResult, deciding what counts as success and what error
 * surfaces on failure.
 */
import type { MissionExecutor, MissionSpec, MissionExecutionResult } from './QueueScheduler';
import type { Brain } from './Brain';
import type { TaskExecutor } from './TaskExecutor';
import { OrchestrationLoop } from './OrchestrationLoop';
import { IntentClassifier } from './IntentClassifier';
import { MissionGovernor } from './MissionGovernor';
export interface OrchestratedMissionExecutorOptions {
    brain: Brain;
    taskExecutor: TaskExecutor;
    /** Inject a pre-built loop (tests). Default: new OrchestrationLoop(brain, taskExecutor). */
    loop?: OrchestrationLoop;
    /** Inject a classifier (tests). Default: new IntentClassifier(). */
    classifier?: IntentClassifier;
    /** Inject a governor (tests). Default: new MissionGovernor(). */
    governor?: MissionGovernor;
    /**
     * Soft cap on orchestration iterations for a single mission. Forward-compat
     * field — Phase 6 propagates a shared budget across the subagent tree. For
     * now it's recorded on the intent context for observability.
     */
    iterationBudget?: number;
}
export declare class OrchestratedMissionExecutor implements MissionExecutor {
    private readonly loop;
    private readonly classifier;
    private readonly governor;
    private readonly iterationBudget;
    constructor(opts: OrchestratedMissionExecutorOptions);
    execute(mission: MissionSpec): Promise<MissionExecutionResult>;
    /**
     * Decide whether a finished mission counts as success or failure for the
     * queue — which in turn governs the QueueScheduler's retry behavior
     * (a retryable 'failed' result is re-queued until maxAttempts).
     *
     * Policy: STRICT success + TERMINAL failure detection.
     *   - Success only when the ReviewerAgent approved (state.status ===
     *     'completed'). A near-miss does not silently ship.
     *   - A failure caused by a CRITICAL governance event (destructive action
     *     blocked, prompt injection, scope violation, executor blocked) is
     *     TERMINAL — retrying would hit the same wall every time, so we mark
     *     it non-retryable (`retryable: false`) and surface the blocking
     *     event. The QueueScheduler honors this and does not re-queue.
     *   - Any other failure is retryable (transient model/tool error, a
     *     refine loop that ran out of attempts, etc.).
     */
    private judgeOutcome;
}
