import { type AdaptiveCandidate, type AdaptivePatchEvidence, type AdaptiveRemediationRequest, type AdaptiveRemediationRuntimeHost } from "../core/adaptive-remediation-runtime.js";
import type { AdaptiveRemediationCommand, AdaptiveRemediationProbeCommand, AdaptiveRemediationValidationEvidence } from "../core/types.js";
import { type OpenCodeModelAvailabilityClient } from "./model-routing-hook.js";
export interface AdaptivePatchProducer {
    apply(input: {
        readonly iteration: 1 | 2 | 3;
        readonly worktree_path: string;
        readonly parent_head: string;
        readonly acceptance: readonly string[];
        readonly allowed_paths: AdaptiveRemediationRequest["allowed_paths"];
    }): Promise<{
        readonly hypothesis: string;
    }>;
}
export interface AdaptiveReviewProvider {
    review(input: {
        readonly worktree_path: string;
        readonly candidate_head: string;
        readonly parent_head: string;
        readonly risk_class: AdaptiveRemediationRequest["risk_class"];
    }): Promise<{
        readonly status: "pass" | "remediation-required" | "fail";
        readonly fingerprint: string;
    }>;
}
export declare const DEFAULT_ADAPTIVE_REMEDIATION_MODEL = "openai/gpt-5.6-sol";
export interface AdaptiveRemediationSessionClient extends OpenCodeModelAvailabilityClient {
    session: {
        create(input: {
            body: {
                parentID: string;
                title: string;
            };
            query: {
                directory: string;
            };
        }): Promise<unknown>;
        prompt(input: {
            path: {
                id: string;
            };
            body: {
                agent: string;
                model: {
                    providerID: string;
                    modelID: string;
                };
                parts: {
                    type: "text";
                    text: string;
                }[];
            };
            query: {
                directory: string;
            };
        }): Promise<unknown>;
        abort(input: {
            path: {
                id: string;
            };
            query: {
                directory: string;
            };
        }): Promise<unknown>;
    };
}
export interface OpenCodeAdaptiveRemediationProviderOptions {
    readonly projectRoot: string;
    readonly ownerSessionID: string;
    readonly runID: string;
    readonly taskID: string;
    readonly scopeRead: readonly string[];
    readonly scopeWrite: readonly string[];
    readonly acceptance: readonly string[];
    readonly improvementSignal: AdaptiveRemediationRequest["improvement_signal"];
    readonly client: AdaptiveRemediationSessionClient;
    readonly model?: string;
    readonly createdChild: (childID: string, callID: string) => void;
    readonly finishedChild: (callID: string) => void;
    readonly releaseWriter: (childID: string) => Promise<void>;
    readonly writerReleased: (childID: string) => Promise<boolean>;
}
/** OpenCode-backed patch and independent review provider used by the plugin entrypoint. */
export declare class OpenCodeAdaptiveRemediationProvider implements AdaptivePatchProducer, AdaptiveReviewProvider {
    readonly options: OpenCodeAdaptiveRemediationProviderOptions;
    constructor(options: OpenCodeAdaptiveRemediationProviderOptions);
    private get model();
    apply(input: Parameters<AdaptivePatchProducer["apply"]>[0]): Promise<{
        readonly hypothesis: string;
    }>;
    review(input: Parameters<AdaptiveReviewProvider["review"]>[0]): Promise<{
        status: "fail" | "pass" | "remediation-required";
        fingerprint: string;
    }>;
}
export interface GitAdaptiveRemediationHostOptions {
    readonly repositoryRoot: string;
    readonly runID: string;
    readonly taskID: string;
    readonly targetRef: string;
    readonly allowedPaths: AdaptiveRemediationRequest["allowed_paths"];
    readonly patchProducer: AdaptivePatchProducer;
    readonly reviewProvider: AdaptiveReviewProvider;
    readonly gitPath?: string;
    readonly reserveProbe?: AdaptiveRemediationRuntimeHost["reserveProbe"];
    readonly finishProbe?: AdaptiveRemediationRuntimeHost["finishProbe"];
    readonly failProbe?: AdaptiveRemediationRuntimeHost["failProbe"];
}
/** Concrete Git/process adapter used by the plugin and cross-platform RPT fixture. */
export declare class GitAdaptiveRemediationHost implements AdaptiveRemediationRuntimeHost {
    readonly options: GitAdaptiveRemediationHostOptions;
    private readonly dispatchRunID;
    private lifecycle;
    private authority;
    private readonly candidates;
    private promotedCandidate;
    constructor(options: GitAdaptiveRemediationHostOptions);
    private get git();
    snapshotTarget(targetRef: string): Promise<{
        head: string;
        tree: string;
    }>;
    openCandidate(parentHead: string, iteration: 1 | 2 | 3): Promise<AdaptiveCandidate>;
    private observationPath;
    private command;
    runBaselineProbe(candidate: AdaptiveCandidate, command: AdaptiveRemediationProbeCommand): Promise<{
        signal_id: string;
        value: number | null;
        command: readonly string[];
        exit_code: number | null;
        fingerprint: string;
    }>;
    private readProbeValue;
    producePatch(input: Parameters<AdaptiveRemediationRuntimeHost["producePatch"]>[0]): Promise<AdaptivePatchEvidence>;
    reserveProbe(input: Parameters<NonNullable<AdaptiveRemediationRuntimeHost["reserveProbe"]>>[0]): Promise<string>;
    finishProbe(input: Parameters<NonNullable<AdaptiveRemediationRuntimeHost["finishProbe"]>>[0]): Promise<void>;
    failProbe(input: Parameters<NonNullable<AdaptiveRemediationRuntimeHost["failProbe"]>>[0]): Promise<void>;
    inspectCleanup(candidate: AdaptiveCandidate): Promise<{
        ok: boolean;
        remaining_paths: string[];
    }>;
    discardCandidate(candidate: AdaptiveCandidate): Promise<void>;
    runCanonical(candidate: AdaptiveCandidate, command: AdaptiveRemediationCommand): Promise<AdaptiveRemediationValidationEvidence>;
    review(input: Parameters<AdaptiveRemediationRuntimeHost["review"]>[0]): Promise<{
        readonly status: "pass" | "remediation-required" | "fail";
        readonly fingerprint: string;
    }>;
    promote(input: Parameters<AdaptiveRemediationRuntimeHost["promote"]>[0]): Promise<{
        status: "cas-drift";
        observed_head: string;
    } | {
        status: "promoted";
        observed_head: string;
    }>;
    runPostMerge(command: AdaptiveRemediationCommand): Promise<AdaptiveRemediationValidationEvidence>;
    release(candidates: readonly AdaptiveCandidate[]): Promise<{
        ok: boolean;
        remaining_paths: string[];
    }>;
}
export declare function executeGitAdaptiveRemediation(request: AdaptiveRemediationRequest, options: GitAdaptiveRemediationHostOptions): Promise<import("../core/types.js").AdaptiveRemediationContract>;