import type { AgentGoal, GoalBudget, GoalCheckpoint, GoalBudgetUpdate, GoalContinuation, GoalContinuationClaim, GoalContinuationKind, GoalEvaluator, GoalEventSink, GoalProgress, GoalRetryPolicy, GoalStatus, GoalStorage, GoalTerminalCandidate, GoalTerminalCandidateRecord, GoalWakeScheduler } from "./domain.js";
/**
 * Evaluator calls hit a remote model; rate limits and auth refreshes need seconds, not
 * milliseconds. Waits of 2s, 4s, 8s, 16s, 30s give about a minute of resilience.
 */
export declare const DEFAULT_EVALUATOR_RETRY_POLICY: GoalRetryPolicy;
export declare const EVALUATION_UNAVAILABLE_PREFIX = "Goal evaluation unavailable";
export interface GoalRuntimeOptions {
    defaultBudget?: GoalBudget;
    retryPolicy?: GoalRetryPolicy;
    evaluatorRetryPolicy?: GoalRetryPolicy;
    eventSink?: GoalEventSink;
    claimTtlMs?: number;
    delay?: (milliseconds: number) => Promise<void>;
    /** @deprecated Every settled run is evaluated. Retained for configuration compatibility. */
    evaluationInterval?: number;
    wakeScheduler?: GoalWakeScheduler;
}
export declare class GoalRuntime {
    private readonly storage;
    private readonly evaluator;
    private readonly continuation;
    private readonly now;
    private readonly evaluatingScopes;
    private readonly recoveringScopes;
    private readonly budget;
    private readonly retryPolicy;
    private readonly evaluatorRetryPolicy;
    private readonly eventSink?;
    private readonly claimTtlMs;
    private readonly delay;
    private readonly wakeScheduler;
    private closed;
    constructor(storage: GoalStorage, evaluator: GoalEvaluator, continuation: GoalContinuation, now?: () => Date, options?: GoalRuntimeOptions);
    close(closeStorage?: boolean): void;
    get(scopeId: string): Promise<AgentGoal | undefined>;
    listUnfinished(): Promise<AgentGoal[]>;
    getContinuationClaim(scopeId: string): Promise<GoalContinuationClaim | undefined>;
    getTerminalCandidate(scopeId: string): Promise<GoalTerminalCandidateRecord | undefined>;
    listCheckpoints(scopeId: string): Promise<GoalCheckpoint[]>;
    create(scopeId: string, objective: string, budget?: GoalBudget, name?: string): Promise<AgentGoal>;
    updateBudget(scopeId: string, update: GoalBudgetUpdate): Promise<AgentGoal>;
    updateDetails(scopeId: string, update: {
        name?: string;
        objective?: string;
    }): Promise<AgentGoal>;
    addCheckpoint(scopeId: string, input: {
        summary: string;
        evidence?: string;
        nextStep?: string;
        blocker?: string;
    }): Promise<GoalCheckpoint>;
    snooze(scopeId: string, durationMs: number): Promise<AgentGoal>;
    closeGoal(scopeId: string): Promise<AgentGoal>;
    setStatus(scopeId: string, status: Extract<GoalStatus, "active" | "paused" | "complete">): Promise<AgentGoal>;
    clear(scopeId: string): Promise<boolean>;
    requestTerminalCandidate(scopeId: string, candidate: GoalTerminalCandidate): Promise<GoalTerminalCandidateRecord>;
    start(scopeId: string, reason?: string, kind?: GoalContinuationKind): Promise<void>;
    acknowledgeContinuation(scopeId: string): Promise<void>;
    recover(scopeId: string): Promise<void>;
    settle(scopeId: string, progress: GoalProgress, options?: {
        accountUsage?: boolean;
    }): Promise<void>;
    private processPendingEvaluation;
    private continueWithClaim;
    private runContinuationClaim;
    private blockAfterRetryExhaustion;
    private budgetExhausted;
    private markBudgetLimited;
    private scheduleRecovery;
    private retryDelay;
    private record;
    private requireGoal;
}