import type { Conversation } from "./protocol.js";
import type { TerminalCompletionEvidence, TerminalControlRef } from "./terminal-agent-adapter.js";
import type { TerminalSubmissionAcceptanceEvidence } from "./terminal-submission-facts.js";
import { type BoundTerminalAgentProcessObservation, type VerifiedDeadAgentAuthorityDecision, type VerifiedDeadAgentCompletionObservation, type VerifiedDeadTerminalAgentProcessProof } from "./verified-dead-agent-policy.js";
export interface TerminalBindingLedgerFacts {
    binding_id?: string;
    binding_generation?: number;
    native_thread_id?: string;
    store_dir?: string;
    message_type?: string;
    message_body_hash?: string;
    deferred_foreground_transfer_id?: string;
    executor_kind: string;
    openclaw_session?: string;
}
export interface TerminalSubmissionRecoveryFacts {
    status?: string;
    messageId?: string;
    preparedAt?: string;
    textInjectedAt?: string;
    enterDispatchedAt?: string;
    submittedAt?: string;
    agentAcceptedAt?: string;
    notAcceptedAt?: string;
    uncertainAt?: string;
    abortedAt?: string;
    lastProvenStage?: string;
    acceptanceEvidence?: TerminalSubmissionAcceptanceEvidence;
    callbackRouteFingerprint?: string | null;
}
export interface TerminalDispatchLedgerMutation extends Record<string, unknown> {
    status: string;
    generation_id?: string;
    conversation_id?: string;
    message_id?: string;
    message_type?: string;
    request_hash?: string;
    prepared_at?: string;
    text_injected_at?: string;
    enter_dispatched_at?: string;
    submitted_at?: string;
    agent_accepted_at?: string;
    not_accepted_at?: string;
    uncertain_at?: string;
    aborted_at?: string;
    resolved_at?: string;
    acceptance_evidence?: TerminalSubmissionAcceptanceEvidence;
    last_proven_stage?: string;
    dispatcher_pid?: number | null;
    state_path?: string;
    event_log_path?: string;
    callback_expected?: boolean;
    callback_route_fingerprint?: string | null;
    reason: string;
    binding?: TerminalBindingLedgerFacts;
}
export type PreparedDispatchOwnerFacts = {
    status: "missing";
} | {
    status: "unreadable";
} | {
    status: "mismatch";
} | {
    status: "loaded";
    conversationId: string;
    updatedAt?: string;
    storedMessageId?: string;
    submission: TerminalSubmissionRecoveryFacts;
    binding: TerminalBindingLedgerFacts;
    requestHash?: string;
    statePath: string;
    eventLogPath: string;
    callbackExpected: boolean;
};
export interface PreparedDispatchRecoveryInput {
    ledger: {
        lifecycle: boolean;
        status?: string;
        dispatcherPid?: number;
        dispatcherActive: boolean;
        statePath?: string;
        eventLogPath?: string;
        messageId?: string;
        conversationId?: string;
    };
    owner: PreparedDispatchOwnerFacts;
    now(): string;
}
export type PreparedDispatchRecoveryDecision = {
    action: "keep";
} | {
    action: "reconcile_lagging";
} | {
    action: "save_ledger";
    mutation: TerminalDispatchLedgerMutation;
} | {
    action: "replace_ledger";
    mutation: TerminalDispatchLedgerMutation;
};
/** Decide prepared-ledger crash recovery without reading state or writing I/O. */
export declare function decidePreparedDispatchRecovery(input: PreparedDispatchRecoveryInput): PreparedDispatchRecoveryDecision;
export interface LaggingDispatchRecoveryInput {
    eligible: boolean;
    ledgerStatus?: string;
    stateStatus?: string;
    stateAcceptance?: TerminalSubmissionAcceptanceEvidence;
    ledgerAcceptance?: TerminalSubmissionAcceptanceEvidence;
    ledgerAcceptanceError?: string;
    ledgerAgentAcceptedAt?: string;
    ledgerLastProvenStage?: string;
    submission: TerminalSubmissionRecoveryFacts;
    binding: TerminalBindingLedgerFacts;
    now: string;
}
export type LaggingDispatchRecoveryDecision = {
    action: "keep";
} | {
    action: "save_turn_accepted";
    acceptedAt: string;
    acceptanceEvidence: TerminalSubmissionAcceptanceEvidence;
} | {
    action: "save_turn_uncertain_and_ledger";
    uncertainAt: string;
    reason: string;
    ledger: TerminalDispatchLedgerMutation;
} | {
    action: "save_ledger";
    mutation: TerminalDispatchLedgerMutation;
};
/** Select the strongest durable proof without authorizing terminal replay. */
export declare function decideLaggingDispatchRecovery(input: LaggingDispatchRecoveryInput): LaggingDispatchRecoveryDecision;
export interface VerifiedDeadDispatchAuthorityFacts {
    conversationId: string;
    stateAuthorityExact: boolean;
    ledgerAuthorityExact: boolean;
    ledgerResolved: boolean;
    acceptance: {
        status: "valid";
        allEqual: boolean;
    } | {
        status: "invalid";
        reason: string;
    };
}
export declare function assertVerifiedDeadDispatchAuthorityFacts(facts: VerifiedDeadDispatchAuthorityFacts): {
    resolved: boolean;
};
/** Opaque application-side transaction scope; adapters authenticate it. */
export interface TerminalDispatchRecoveryScope {
}
export interface VerifiedDeadRecoveryContext {
    scope: TerminalDispatchRecoveryScope;
    conversation: Conversation;
    terminalControl: TerminalControlRef;
    messageId: string;
}
export type TerminalCompletionPreparation<Prepared> = {
    claimed: true;
    conversation: Conversation;
    prepared: Prepared;
} | {
    claimed: false;
    conversation: Conversation;
    reason: string;
};
export interface VerifiedDeadRecoveryResult<Prepared> {
    stalled: boolean;
    conversation: Conversation;
    reason: string;
    completionPreparation?: TerminalCompletionPreparation<Prepared>;
}
export interface LocalCompletionRecoveryResult {
    handled: boolean;
    recovered: boolean;
    reason: string;
}
export interface LocalCompletionRecoveryContext {
    scope: TerminalDispatchRecoveryScope;
    conversation: Conversation;
    terminalControl: TerminalControlRef;
    terminalMessageId: string;
    completionId: string;
    callbackMessageId: string;
    outcome: string;
}
export interface TerminalDispatchRecoveryPorts<Prepared> {
    transaction: {
        verifiedDead(request: {
            storeDir: string;
            statePath: string;
            logPath: string;
            expectedConversationId: string;
            expectedMessageId?: string;
        }, operation: (context: VerifiedDeadRecoveryContext) => Promise<VerifiedDeadRecoveryResult<Prepared>>): Promise<VerifiedDeadRecoveryResult<Prepared>>;
        localCompletion(request: {
            storeDir: string;
            statePath: string;
            logPath: string;
        }, operation: (context: LocalCompletionRecoveryContext) => LocalCompletionRecoveryResult): LocalCompletionRecoveryResult;
    };
    authority: {
        assertBinding(context: VerifiedDeadRecoveryContext): void;
        basicAcceptedDispatch(context: VerifiedDeadRecoveryContext): boolean;
        assertAcceptedDispatch(context: VerifiedDeadRecoveryContext): void;
        persistedDeath(context: VerifiedDeadRecoveryContext): VerifiedDeadAgentAuthorityDecision;
        observeDeath(context: VerifiedDeadRecoveryContext): Promise<BoundTerminalAgentProcessObservation>;
        priorStall(input: {
            context: VerifiedDeadRecoveryContext;
            proof: VerifiedDeadTerminalAgentProcessProof;
            evidenceId: string;
            reason: string;
        }): {
            status: "absent";
        } | {
            status: "valid";
            completionObservation: "absent" | "unverifiable";
        } | {
            status: "invalid";
            reason: string;
        };
        durableCompletion(context: VerifiedDeadRecoveryContext): Promise<VerifiedDeadAgentCompletionObservation<TerminalCompletionEvidence>>;
        assertLocalCompletion(context: LocalCompletionRecoveryContext): {
            ledgerResolved: boolean;
            supersededByNewerDispatch?: boolean;
        };
    };
    evidence: {
        ensureDeath(input: {
            context: VerifiedDeadRecoveryContext;
            proof: VerifiedDeadTerminalAgentProcessProof;
        }): {
            proof: VerifiedDeadTerminalAgentProcessProof;
            evidenceId: string;
            recordedAt: string;
        };
        ensureStall(input: {
            context: VerifiedDeadRecoveryContext;
            proof: VerifiedDeadTerminalAgentProcessProof;
            evidenceId: string;
            reason: string;
            completionObservation: "absent" | "unverifiable";
        }): void;
    };
    state: {
        save(context: VerifiedDeadRecoveryContext, conversation: Conversation): void;
        crashAfterStallEvents(): void;
        logDeath(input: {
            context: VerifiedDeadRecoveryContext;
            proof: VerifiedDeadTerminalAgentProcessProof;
            reason: string;
        }): void;
        settleLocalCompletion(context: LocalCompletionRecoveryContext): void;
    };
    completion: {
        prepareAfterStateRelease(context: VerifiedDeadRecoveryContext, completion: TerminalCompletionEvidence): TerminalCompletionPreparation<Prepared>;
    };
}
/** Own verified-dead and callbackless completion effect ordering. */
export declare class TerminalDispatchRecoveryService<Prepared> {
    #private;
    constructor(ports: TerminalDispatchRecoveryPorts<Prepared>);
    stallAcceptedForVerifiedDead(request: {
        storeDir: string;
        statePath: string;
        logPath: string;
        expectedConversationId: string;
        expectedMessageId?: string;
    }): Promise<VerifiedDeadRecoveryResult<Prepared>>;
    settleLocalCompletion(request: {
        storeDir: string;
        statePath: string;
        logPath: string;
    }): LocalCompletionRecoveryResult;
}