import { type ExtensionAPI } from "@earendil-works/pi-coding-agent";
import { FairAgentScheduler, WorkflowAgentExecutor, type AgentProviderFailure, type AgentProviderRecovery } from "./agent-execution.js";
import { RunStore, type PersistedRun } from "./persistence.js";
import { WorkflowBudgetRuntime } from "./budget.js";
import { WorkflowError, type BudgetApprovalRequest, type JsonValue, type LaunchSnapshot, type ModelSpec, type RunState, type WorkflowMetadata, type WorkflowWorktreeReference } from "./types.js";
import { RunLifecycle, WorkflowEventPublisher, type WorkflowRunRecord, type WorkflowToolUpdate } from "./host-runtime.js";
import { type CompletionDeliveryContext, type CompletionDeliveryResult } from "./host-delivery.js";
export type WorkflowRecoveryContext = {
    model: {
        provider: string;
        id: string;
    } | undefined;
    modelRegistry: {
        getAll?: () => readonly import("@earendil-works/pi-ai").Model<import("@earendil-works/pi-ai").Api>[];
        getAvailable?: () => readonly import("@earendil-works/pi-ai").Model<import("@earendil-works/pi-ai").Api>[];
        find?: (provider: string, model: string) => import("@earendil-works/pi-ai").Model<import("@earendil-works/pi-ai").Api> | undefined;
        refresh?: () => Promise<void>;
        getError?: () => string | undefined;
    } | undefined;
    deliveryContext: CompletionDeliveryContext;
    signal?: AbortSignal;
    resolvedAliases?: Readonly<Record<string, string>>;
    blockedAliases?: ReadonlySet<string>;
    blockedAliasTargets?: Readonly<Record<string, string>>;
};
export type WorkflowRecoveryDependencies = {
    pi: Pick<ExtensionAPI, "getThinkingLevel">;
    home: string | undefined;
    runs: Map<string, WorkflowRunRecord>;
    scheduler: FairAgentScheduler;
    eventPublisher: WorkflowEventPublisher;
    persistRunState: (store: RunStore, metadata: WorkflowMetadata, update: (run: PersistedRun) => PersistedRun | Promise<PersistedRun>) => Promise<PersistedRun>;
    projectTrusted: (context: unknown) => boolean;
    resumeHostContext: (context: unknown) => WorkflowRecoveryContext;
    ensureSessionLease: (cwd: string, sessionId: string) => Promise<void>;
    createAgentExecutor: (root: Omit<import("./agent-execution.js").AgentExecutionRoot, "agentDir" | "agentSetupHooks">) => WorkflowAgentExecutor;
    activeSnapshotTools: (tools: readonly string[], active: ReadonlySet<string> | "session") => Set<string>;
    frozenResourcePolicy: (policy: import("./types.js").AgentResourcePolicy) => () => import("./types.js").AgentResourcePolicy;
    resolveLaunchPrologue: (input: {
        snapshot: Readonly<LaunchSnapshot>;
        cwd: string;
        trustedProject: boolean;
        rootModel: ModelSpec;
        modelRegistry?: WorkflowRecoveryContext["modelRegistry"];
        signal: AbortSignal;
        resolvedAliases?: Readonly<Record<string, string>>;
        blockedAliases?: ReadonlySet<string>;
        blockedAliasTargets?: Readonly<Record<string, string>>;
        withPreflight: boolean;
    }) => Promise<{
        active: Set<string>;
        settingsPath: string;
        currentPolicy: import("./types.js").AgentResourcePolicy;
        previousAliases: Readonly<Record<string, string>>;
        knownModels: ReadonlySet<string>;
        availableModels: ReadonlySet<string>;
        currentAliases: Readonly<Record<string, string>>;
        blockedAliases: ReadonlySet<string>;
        blockedAliasTargets: Readonly<Record<string, string>>;
        snapshot: Readonly<LaunchSnapshot>;
        script: string | undefined;
    }>;
    workflowAgentHandler: (store: RunStore, metadata: WorkflowMetadata, lifecycle: RunLifecycle, executor: WorkflowAgentExecutor, cwd: string, runId: string) => (prompt: string, options: Readonly<Record<string, JsonValue>>, signal: AbortSignal, identity: import("./types.js").AgentIdentity) => Promise<JsonValue>;
    shellForRun: (store: RunStore, metadata: WorkflowMetadata, lifecycle: RunLifecycle, command: string, options: import("./types.js").ShellOptions, signal: AbortSignal, identity: import("./types.js").ShellIdentity) => Promise<import("./types.js").ShellResult>;
    resolveWorktree: (store: RunStore, metadata: WorkflowMetadata, owner: string) => Promise<Readonly<WorkflowWorktreeReference>>;
    checkpointBridge: (runId: string, store: RunStore, metadata: WorkflowMetadata, foreground: boolean, ui?: {
        select?: (prompt: string, options: string[]) => Promise<string | undefined>;
    }, headless?: boolean) => (raw: Readonly<Record<string, JsonValue>>, signal: AbortSignal) => Promise<boolean>;
    phaseBridge: (store: RunStore, metadata: WorkflowMetadata, lifecycle: RunLifecycle) => (phase: string) => Promise<void>;
    logBridge: (store: RunStore, lifecycle: RunLifecycle, workflowName: string) => (message: string) => Promise<void>;
    lifecycleFor: (store: RunStore, state: RunState, budget: WorkflowBudgetRuntime, metadata: WorkflowMetadata) => RunLifecycle;
    createProviderErrorRecovery: (host: unknown, fallbackModels: ReadonlySet<string>, abort: () => void) => ((failure: AgentProviderFailure) => Promise<AgentProviderRecovery>) | undefined;
    cleanupTerminalRun: (runId: string) => Promise<void>;
    deliver: (content: string) => void;
    deliverTerminal: (store: RunStore, content: string | (() => string | Promise<string>), failure?: boolean) => Promise<void>;
    workflowToolUpdate: (run: PersistedRun) => WorkflowToolUpdate;
    registry: import("./registry.js").WorkflowRegistryApi;
    modelSpec: (value: string, fallback: ModelSpec) => ModelSpec;
};
export declare function persistedFailure(run: PersistedRun, error: WorkflowError): PersistedRun;
export declare function createWorkflowRecovery(deps: WorkflowRecoveryDependencies): {
    refreshPausedRunAliases: (run: WorkflowRunRecord, context?: {
        model: {
            provider: string;
            id: string;
        } | undefined;
        modelRegistry: WorkflowRecoveryContext["modelRegistry"];
        projectTrusted?: boolean;
    }) => Promise<void>;
    coldResumeRun: (run: WorkflowRunRecord, hasUI: boolean, ui: {
        select?: (prompt: string, options: string[]) => Promise<string | undefined>;
    }, trustedProject: boolean, context?: {
        model: {
            provider: string;
            id: string;
        } | undefined;
        modelRegistry: WorkflowRecoveryContext["modelRegistry"];
        deliveryContext: CompletionDeliveryContext;
        signal?: AbortSignal | undefined;
        resolvedAliases?: Readonly<Record<string, string>>;
        blockedAliases?: ReadonlySet<string>;
        blockedAliasTargets?: Readonly<Record<string, string>>;
    }, modeOverride?: boolean, waitForCompletion?: boolean) => Promise<{
        value: JsonValue;
        resultPath: string;
        resultBytes: number;
        completion: CompletionDeliveryResult;
    } | undefined>;
    applyBudgetDecision: (request: BudgetApprovalRequest, approved: boolean, context?: unknown, signal?: AbortSignal, waitForCompletion?: boolean) => Promise<{
        state: "running" | "completed" | "budget_exhausted";
        approved: boolean;
        value?: JsonValue;
        run?: PersistedRun;
        completion?: CompletionDeliveryResult;
    }>;
    answerBudgetDecision: (runId: string, proposalId: string, approved: boolean, silent?: boolean, context?: unknown, signal?: AbortSignal, waitForCompletion?: boolean) => Promise<{
        state: "running" | "completed" | "budget_exhausted";
        approved: boolean;
        value?: JsonValue;
        run?: PersistedRun;
        completion?: CompletionDeliveryResult;
    } | undefined>;
    budgetDecisionDelivery: (metadata: WorkflowMetadata, request: BudgetApprovalRequest) => string;
    resumeWorkflowRun: (runId: string, rawPatch?: unknown, context?: unknown, signal?: AbortSignal, modeOverride?: boolean, waitForCompletion?: boolean, expectedState?: string) => Promise<Record<string, JsonValue>>;
    retryWorkflowRun: (runId: string, context: unknown, signal?: AbortSignal, modeOverride?: boolean, expectedState?: string) => Promise<{
        runId: string;
        parentRunId: string;
        state: "running" | "completed";
        value?: JsonValue;
        run?: PersistedRun;
        completion?: CompletionDeliveryResult;
    }>;
};