import { type CodexOpenRootRolloutInventory, type CodingAgentSessionProvider } from "./agent-session-provider.js";
import type { ClaudeAgentRow } from "./claude-terminal-agent-adapter.js";
import { type AgentMessage, type Conversation, type Executor } from "./protocol.js";
import type { ExecutorKind } from "./executors.js";
import { type ManagedSessionState } from "./managed-session.js";
import type { TerminalControlRef, TerminalDurableCompletionRequest, TerminalRuntimeIdentity } from "./terminal-agent-adapter.js";
import { type TerminalNativeIdentity } from "./terminal-binding-authority.js";
import type { TerminalDispatchLedgerDocument } from "./terminal-dispatch-ledger-codec.js";
import type { TerminalDispatchTerminal } from "./terminal-dispatch-composition.js";
import { TerminalDispatchExecutionService, type NativeAgentSessionIdentityObservation, type NativeIdentityResolutionRequest } from "./terminal-dispatch-execution.js";
import { type VirginBindingRecoveryState } from "./terminal-acceptance-application-service.js";
import type { DeferredForegroundTransfer } from "./deferred-foreground-transfer.js";
import type { CallbackRouteV1 } from "./callback-transport.js";
import type { FileLockAcquisitionOptions } from "./file-lock-cli-adapter.js";
export interface TerminalAcceptanceCliOptions {
    callbackRoute?: CallbackRouteV1;
    claudeHome?: string;
    gatewayMethod?: string;
    gatewaySession?: string;
    gatewayUrl?: string;
    hardLimit?: number | string;
    logDir?: string;
    messageId?: string;
    openclawBin?: string;
    openclawSession?: string;
    scrollbackLines?: number | string;
    softLimit?: number | string;
    storeDir?: string;
    type?: string;
    [option: string]: unknown;
}
export interface TerminalAcceptanceBridge {
    proveExactDraftStillPresent(executor: ExecutorKind, terminalControl: TerminalControlRef, requestText: string, options: {
        scrollbackLines: number;
        runtime: TerminalRuntimeIdentity;
    }): Promise<boolean>;
    resolveStoredTerminal(agent: "codex", pid: number, terminalControl: TerminalControlRef, expected: {
        pid: number;
    }): Promise<TerminalDispatchTerminal>;
}
interface ManagedTerminalTurn {
    conversation: Conversation;
    nextConversation: Conversation;
    statePath: string;
    logPath: string;
    executor: Executor;
    message: AgentMessage;
}
interface DeferredTurnAuthority {
    conversation: Conversation;
    statePath: string;
    submission: {
        message_body_hash?: unknown;
    };
}
interface TerminalAcceptanceRepositoryPorts {
    acquireStateLock(lockPath: string, options?: FileLockAcquisitionOptions): () => void;
    acquireTerminalLock(storeDir: string, terminalControl: TerminalControlRef, options?: FileLockAcquisitionOptions): () => void;
    loadLedger(terminalControl: TerminalControlRef): TerminalDispatchLedgerDocument | undefined;
    saveLedger(terminalControl: TerminalControlRef, ledger: TerminalDispatchLedgerDocument): void;
    reconcileLedger(terminalControl: TerminalControlRef, ledger?: TerminalDispatchLedgerDocument): TerminalDispatchLedgerDocument | undefined;
    bindingFields(conversation: Conversation): Partial<TerminalDispatchLedgerDocument>;
}
export interface TerminalAcceptanceCliDependencies {
    native: {
        codexProvider(options: TerminalAcceptanceCliOptions): CodingAgentSessionProvider;
        codexProcessIncarnation(pid: number): {
            processUuid: string;
            processBirth: string;
        };
        assertExclusive(input: {
            options: TerminalAcceptanceCliOptions;
            agent: "codex";
            currentPid: number;
            nativeThreadId: string;
            storeDir: string;
            terminalControl: TerminalControlRef;
            excludedManagedSessionId: string;
            allowedManagedSessionIds?: string[];
        }): Promise<void>;
    };
    terminal: {
        runtime(options: TerminalAcceptanceCliOptions): {
            loadClaudeAgentRows(observation?: {
                required?: boolean;
            }): readonly ClaudeAgentRow[];
            createBridge(): TerminalAcceptanceBridge;
        };
        durableRequest(conversation: Conversation, terminalControl: TerminalControlRef): TerminalDurableCompletionRequest;
        runtimeIdentity(conversation: Conversation, terminalControl: TerminalControlRef): TerminalRuntimeIdentity;
    };
    authority: {
        assertTurnCurrent(conversation: Conversation, operation: string): void;
        terminalControl(value: unknown): TerminalControlRef | undefined;
        isDiscoverableTurn(conversation: Conversation): boolean;
        workspaceMatches(configured: unknown, observed: unknown): boolean;
        hasUnresolvedTransition(storeDir: string, session: ManagedSessionState): boolean;
    };
    repository: TerminalAcceptanceRepositoryPorts;
    deferred: {
        recover(input: {
            options: TerminalAcceptanceCliOptions;
            terminal: TerminalDispatchTerminal;
        }): Promise<void>;
        loadAuthority(input: {
            storeDir: string;
            terminal: TerminalDispatchTerminal;
            transfer: DeferredForegroundTransfer;
        }): DeferredTurnAuthority;
        assertLedgerAuthority(input: {
            storeDir: string;
            terminal: Pick<TerminalDispatchTerminal, "terminalControl">;
            transfer: DeferredForegroundTransfer;
            ledger: TerminalDispatchLedgerDocument;
            statePath: string;
            expectedMessageBodyHash?: string;
        }): void;
        loadTransfer(storeDir: string, transferId: string): DeferredForegroundTransfer;
    };
}
export interface TerminalAcceptanceCliFacade {
    execution(options: TerminalAcceptanceCliOptions, bridge?: TerminalAcceptanceBridge): TerminalDispatchExecutionService;
    recoverVirgin(input: {
        options: TerminalAcceptanceCliOptions;
        conversation: Conversation;
        statePath: string;
        logPath: string;
        terminalLockHeld?: boolean;
    }): Promise<{
        conversation: Conversation;
        state: VirginBindingRecoveryState;
    }>;
    reconcileMonitor(input: {
        options: TerminalAcceptanceCliOptions;
        conversation: Conversation;
        statePath: string;
        logPath: string;
        terminalControl: TerminalControlRef;
        executor: Executor;
        terminalBridge: TerminalAcceptanceBridge;
    }): Promise<{
        outcome: "accepted";
        conversation: Conversation;
    } | {
        outcome: "pending";
    } | {
        outcome: "not_accepted";
        conversation: Conversation;
    }>;
    markUncertain(input: {
        conversation: Conversation;
        statePath: string;
        logPath: string;
        terminalControl: TerminalControlRef;
        reason: string;
    }): Conversation;
    inspectCodexOpenRoots(input: {
        options: TerminalAcceptanceCliOptions;
        pid: number;
        cwd?: string;
    }): Promise<CodexOpenRootRolloutInventory>;
    resolveNativeIdentity(request: NativeIdentityResolutionRequest & {
        options: TerminalAcceptanceCliOptions;
    }): Promise<TerminalNativeIdentity | undefined>;
    observeNativeIdentity(request: NativeIdentityResolutionRequest & {
        options: TerminalAcceptanceCliOptions;
    }): Promise<NativeAgentSessionIdentityObservation>;
    assertTurnIdentity(input: {
        conversation: Conversation;
        currentIdentity: TerminalNativeIdentity | undefined;
        operation: string;
    }): void;
    withNativeIdentity(conversation: Conversation, identity: TerminalNativeIdentity): Conversation;
    storeDirForConversation(conversation: Conversation): string | undefined;
    refineSessionIdentity(input: {
        storeDir: string;
        session: ManagedSessionState;
        terminalControl: TerminalControlRef;
        identity?: TerminalNativeIdentity;
    }): ManagedSessionState;
    persistSessionIdentity(input: {
        conversation: Conversation;
        terminalControl: TerminalControlRef;
        identity: TerminalNativeIdentity;
        storeDir: string;
    }): ManagedSessionState | undefined;
    /** Caller must hold terminal -> Store writer -> Turn-state mutation scope. */
    prepareSessionIdentityClaim(input: {
        options: TerminalAcceptanceCliOptions;
        conversation: Conversation;
        terminalControl: TerminalControlRef;
        identity: TerminalNativeIdentity;
        storeDir: string;
    }): Promise<void>;
    quarantineSession(input: {
        conversation: Conversation;
        reason: string;
        storeDir: string;
    }): void;
    turnsForSession(storeDir: string, sessionId: string): Conversation[];
    assertSessionCanStartTurn(turns: Conversation[]): void;
    turnMatchesTerminal(input: {
        conversation: Conversation;
        terminal: TerminalDispatchTerminal;
        currentIdentity?: TerminalNativeIdentity;
    }): boolean;
    createManagedTurn(input: {
        options: TerminalAcceptanceCliOptions;
        conversationId: string;
        agent: ExecutorKind;
        pid: number;
        messageBody: string;
        terminalControl: TerminalControlRef;
        previousTurn?: Conversation;
        managedSession?: ManagedSessionState;
        nativeAgentIdentity?: TerminalNativeIdentity;
        deferredForegroundTransferId?: string;
    }): ManagedTerminalTurn;
}
/** Factory-scoped CLI composition; it retains no mutable module runtime. */
export declare function createTerminalAcceptanceCliFacade(dependencies: TerminalAcceptanceCliDependencies): TerminalAcceptanceCliFacade;
export {};