import { type AdaptiveEligibilityInput } from "./adaptive-eligibility.js";
import { RunFlightLedger } from "./run-flight-ledger.js";
import type { AdaptiveRemediationCommand, AdaptiveRemediationContract, AdaptiveRemediationProbeCommand, AdaptiveRemediationSignal, AdaptiveRemediationValidationEvidence } from "./types.js";
export interface AdaptiveRemediationRequest {
    readonly task_id: string;
    readonly eligibility: AdaptiveEligibilityInput;
    readonly target_ref: string;
    readonly allowed_paths: {
        readonly read: readonly string[];
        readonly write: readonly string[];
    };
    readonly iteration_budget: 1 | 2 | 3;
    readonly max_changed_paths: number;
    readonly cleanup_timeout_ms: number;
    readonly probe_validation: AdaptiveRemediationProbeCommand;
    readonly canonical_validation: AdaptiveRemediationCommand;
    readonly improvement_signal: AdaptiveRemediationSignal;
    readonly risk_class: "low" | "medium" | "high";
    readonly post_merge_validation: AdaptiveRemediationCommand;
    readonly acceptance: readonly string[];
}
export interface AdaptiveProbeEvidence {
    readonly command: readonly string[];
    readonly exit_code: number | null;
    readonly fingerprint: string;
    readonly signal_id: string;
    readonly value: number | null;
}
export interface AdaptiveCandidate {
    readonly worktree_id: string;
    readonly path: string;
    readonly parent_head: string;
}
export interface AdaptivePatchEvidence {
    readonly candidate: AdaptiveCandidate;
    readonly candidate_head: string;
    readonly hypothesis: string;
    readonly patch_fingerprint: string;
    readonly changed_paths: readonly string[];
    readonly probe: AdaptiveProbeEvidence;
}
export interface AdaptiveRemediationRuntimeHost {
    snapshotTarget(targetRef: string): Promise<{
        readonly head: string;
        readonly tree: string;
    }>;
    openCandidate(parentHead: string, iteration: 1 | 2 | 3): Promise<AdaptiveCandidate>;
    runBaselineProbe(candidate: AdaptiveCandidate, command: AdaptiveRemediationProbeCommand): Promise<AdaptiveProbeEvidence>;
    producePatch(input: {
        readonly candidate: AdaptiveCandidate;
        readonly iteration: 1 | 2 | 3;
        readonly acceptance: readonly string[];
        readonly allowed_paths: AdaptiveRemediationRequest["allowed_paths"];
        readonly probe_validation: AdaptiveRemediationProbeCommand;
    }): Promise<AdaptivePatchEvidence>;
    reserveProbe?(input: {
        readonly task_id: string;
        readonly iteration: 1 | 2 | 3;
        readonly parent_candidate: string;
    }): Promise<string>;
    finishProbe?(input: {
        readonly reservation_id: string;
        readonly patch: AdaptivePatchEvidence;
        readonly duration_ms: number;
    }): Promise<void>;
    failProbe?(input: {
        readonly reservation_id: string;
        readonly duration_ms: number;
        readonly code: string;
    }): Promise<void>;
    inspectCleanup(candidate: AdaptiveCandidate, timeoutMs: number): Promise<{
        readonly ok: boolean;
        readonly remaining_paths: readonly string[];
    }>;
    discardCandidate(candidate: AdaptiveCandidate): Promise<void>;
    runCanonical(candidate: AdaptiveCandidate, command: AdaptiveRemediationCommand): Promise<AdaptiveRemediationValidationEvidence>;
    review(input: {
        readonly candidate: AdaptiveCandidate;
        readonly candidate_head: string;
        readonly risk_class: AdaptiveRemediationRequest["risk_class"];
    }): Promise<{
        readonly status: "pass" | "remediation-required" | "fail";
        readonly fingerprint: string;
    }>;
    promote(input: {
        readonly target_ref: string;
        readonly expected_head: string;
        readonly candidate_head: string;
    }): Promise<{
        readonly status: "promoted" | "cas-drift";
        readonly observed_head: string;
    }>;
    runPostMerge(command: AdaptiveRemediationCommand): Promise<AdaptiveRemediationValidationEvidence>;
    release(candidates: readonly AdaptiveCandidate[]): Promise<{
        readonly ok: boolean;
        readonly remaining_paths: readonly string[];
    }>;
}
export interface AdaptiveLineageOptions {
    readonly ledger: RunFlightLedger;
    readonly unit_id: string;
    readonly route_id: string;
    readonly candidate_id: string;
    readonly selected_model: string;
    readonly selected_variant: string | null;
    readonly predecessor_attempt_id: string | null;
    /** Set only when a model is actually dispatched for each patch. */
    readonly model_attempt_per_patch: boolean;
}
/** Shared RunFlightLedger adapter: probe iterations charge the existing cumulative recovery authority. */
export declare class AdaptiveRunFlightLineage {
    readonly options: AdaptiveLineageOptions;
    private predecessor;
    private readonly reservations;
    constructor(options: AdaptiveLineageOptions);
    reserveProbe(): Promise<string>;
    finishProbe(input: {
        readonly reservation_id: string;
        readonly patch: AdaptivePatchEvidence;
        readonly duration_ms: number;
    }): Promise<void>;
    failProbe(input: {
        readonly reservation_id: string;
        readonly duration_ms: number;
        readonly code: string;
    }): Promise<void>;
}
/** Executes the bounded state machine. Hosts own process/worktree mechanics; evidence cannot skip a stage. */
export declare class AdaptiveRemediationRuntime {
    readonly host: AdaptiveRemediationRuntimeHost;
    constructor(host: AdaptiveRemediationRuntimeHost);
    execute(request: AdaptiveRemediationRequest): Promise<AdaptiveRemediationContract>;
}