import { type CodexOpenRootRolloutInventory } from "./agent-session-provider.js";
import type { ExecutorKind } from "./executors.js";
import { type Conversation } from "./protocol.js";
import { type ManagedSessionState, type NativeThreadTransition } from "./managed-session.js";
import type { TerminalControlRef, TerminalRuntimeIdentity } from "./terminal-agent-adapter.js";
import { isCompleteNativeRollout, terminalNativeIdentityFence as codexIdentityFence, terminalNativeIdentityMatchesFence as nativeIdentityMatchesCodexPreMaterialization, type TerminalNativeIdentity } from "./terminal-binding-authority.js";
import { nativeAgentIdentityMatchesTurn, type CodexAllowedCompanionSet } from "./terminal-authority-policy.js";
import type { TerminalDispatchAcceptance } from "./terminal-dispatch-application.js";
import type { TerminalDispatchLedgerDocument } from "./terminal-dispatch-ledger-codec.js";
import { terminalSubmissionReplayReceipt } from "./terminal-dispatch-receipt.js";
import { type CaptureCodexRolloutAcceptanceAnchorOptions, type CodexCandidateSetRolloutAcceptanceRequest, type CodexCandidateSetRolloutAcceptanceResult, type CodexCandidateSetRolloutAcceptanceAnchor, type CodexRolloutAcceptanceAnchor, type CodexRolloutAcceptanceRequest, type TerminalSubmissionAcceptanceEvidence } from "./terminal-submission-facts.js";
export { managedSessionRevision, nativeThreadTransitionRevision } from "./managed-session.js";
export { nativeAgentIdentityMatchesTurn };
export { codexIdentityFence, isCompleteNativeRollout, nativeIdentityMatchesCodexPreMaterialization };
export type CodexPreMaterializationIdentity = NonNullable<TerminalRuntimeIdentity["allowedPreMaterializationNativeIdentity"]>;
export type NativeAgentSessionIdentityObservation = {
    status: "resolved";
    identity: TerminalNativeIdentity;
} | {
    status: "verified_absent";
    evidence: "native_identity_resolver_verified_absent";
} | {
    status: "unavailable";
    reason: string;
};
interface ClaudeIdentityRow {
    pid?: number;
    sessionId?: string;
    startedAt?: number;
}
export interface NativeIdentityResolutionRequest {
    agent: ExecutorKind;
    pid: number;
    cwd?: string;
    preferredSessionId?: string;
    allowedCompanionIdentity?: CodexPreMaterializationIdentity;
    allowedAdditionalIdentities?: readonly CodexPreMaterializationIdentity[];
}
export interface TerminalDispatchExecutionPorts {
    clock: {
        now(): Date;
        nowMs(): number;
        sleep(milliseconds: number): Promise<void>;
    };
    native: {
        resolveCodex(request: Omit<NativeIdentityResolutionRequest, "agent">): Promise<TerminalNativeIdentity | undefined>;
        inspectCodexOpenRoots(pid: number, cwd?: string): Promise<CodexOpenRootRolloutInventory>;
        claudeRows(): readonly ClaudeIdentityRow[];
        codexProcessIncarnation(pid: number): {
            processUuid: string;
            processBirth: string;
        };
    };
    acceptance: {
        captureCodex(request: CaptureCodexRolloutAcceptanceAnchorOptions): CodexRolloutAcceptanceAnchor;
        detectCodexCandidates(request: CodexCandidateSetRolloutAcceptanceRequest): CodexCandidateSetRolloutAcceptanceResult;
        detectBoundCodex(request: CodexRolloutAcceptanceRequest): TerminalSubmissionAcceptanceEvidence | undefined;
        detectClaude(conversation: Conversation, terminalControl: TerminalControlRef): TerminalSubmissionAcceptanceEvidence | undefined;
    };
    terminal: {
        proveExactDraftStillPresent(input: {
            executor: ExecutorKind;
            conversation: Conversation;
            terminalControl: TerminalControlRef;
            requestText: string;
            scrollbackLines: number;
        }): Promise<boolean>;
    };
    authority: {
        assertTurnCurrent(conversation: Conversation, operation: string): void;
    };
}
export interface TerminalAcceptanceDetectionRequest {
    executor: ExecutorKind;
    conversation: Conversation;
    terminalControl: TerminalControlRef;
    allowedCompanionIdentity?: CodexPreMaterializationIdentity;
    allowedAdditionalIdentities?: readonly CodexPreMaterializationIdentity[];
}
export interface TerminalAcceptancePollRequest extends TerminalAcceptanceDetectionRequest {
    timeoutMs: number;
    pollIntervalMs: number;
    scrollbackLines: number;
}
export interface NativeIdentityPollRequest {
    executor: ExecutorKind;
    terminalControl: TerminalControlRef;
    pid: number;
    expectedSessionId?: string;
    allowedPreMaterializationIdentity?: CodexPreMaterializationIdentity;
    allowedAdditionalIdentities?: CodexPreMaterializationIdentity[];
    requiredCodexAcceptance?: {
        anchor: CodexRolloutAcceptanceAnchor;
        requestHash: string;
    };
    attempts?: number;
    delayMs?: number;
}
export type TerminalDispatchExecutionPreflight = {
    action: "proceed";
} | {
    action: "replay";
    owner: Conversation;
    receipt: ReturnType<typeof terminalSubmissionReplayReceipt>;
    accepted: boolean;
    acceptanceInvalid: boolean;
    receiptConversationId: string;
    receiptMessageId: string;
    callbackExpected: boolean;
};
export interface TerminalDispatchTransportLifecycle {
    requireExactComposerBeforeEnter: boolean;
    requireExactEmptyComposerBeforeText?: boolean;
    userExplicitEnterAfterTextWithoutComposerVeto?: boolean;
    beforeText?: () => Promise<void>;
    beforeEnter?: () => Promise<void>;
    onTransportStage(input: {
        stage: "text_injected" | "enter_dispatched";
    }): Promise<void>;
}
interface RuntimeIdentityAssertion {
    runtime?: TerminalRuntimeIdentity;
    currentIdentity: TerminalNativeIdentity | undefined;
    agent: ExecutorKind;
    pid: number;
}
export declare function resolvedTerminalProcessIncarnation(input: {
    terminal: {
        agent: ExecutorKind;
        pid: number;
    };
    identity?: TerminalNativeIdentity;
    codexProcessIncarnation(pid: number): {
        processUuid: string;
        processBirth: string;
    };
}): {
    processUuid?: string;
    processBirth?: string;
};
export declare function managedSessionOwnerIsInactive(input: {
    session: ManagedSessionState;
    terminal: {
        agent: ExecutorKind;
        pid: number;
    };
    identity?: TerminalNativeIdentity;
    isProcessAlive(pid: number): boolean;
    codexProcessIncarnation(pid: number): {
        processUuid: string;
        processBirth: string;
    };
}): boolean;
export declare function managedBindingMatchesLiveTerminal(input: {
    session: ManagedSessionState;
    terminal: {
        agent: ExecutorKind;
        pid: number;
    };
    identity?: TerminalNativeIdentity;
    processIncarnation: {
        processUuid?: string;
        processBirth?: string;
    };
    claimMatches: boolean;
    codexLingeringBeforeMatches(): boolean;
}): boolean;
export declare function codexKnownBeforeIdentityForTransition(input: {
    session: ManagedSessionState;
    transition?: NativeThreadTransition;
    requireNewThread?: boolean;
}): TerminalNativeIdentity | undefined;
export declare function codexLingeringIdentityMatches(input: {
    session: ManagedSessionState;
    identity?: TerminalNativeIdentity;
    transition?: NativeThreadTransition;
    companions: CodexAllowedCompanionSet;
}): boolean;
export declare function logicalManagedSessionIdentity(input: {
    session: ManagedSessionState;
    observedIdentity?: TerminalNativeIdentity;
    lingeringBeforeMatches: boolean;
}): TerminalNativeIdentity | undefined;
export declare function terminalRuntimeForLiveIdentity(input: {
    terminal: {
        agent: ExecutorKind;
        pid: number;
        terminalControl: TerminalControlRef;
    };
    identity?: TerminalNativeIdentity;
    expectedEmptyNativeSession?: boolean;
    physicalOnly?: boolean;
    codexProcessIncarnation(pid: number): {
        processUuid: string;
        processBirth: string;
    };
}): TerminalRuntimeIdentity;
export declare function terminalRuntimeIdentityBase(conversation: Conversation, terminalControl: TerminalControlRef): TerminalRuntimeIdentity;
export declare function migratedTerminalBindingMatches(input: {
    session: ManagedSessionState;
    agent: ExecutorKind;
    terminalAliasMatches: boolean;
    terminalIncarnationMatches: boolean;
    workspaceMatches: boolean;
    terminalId?: string;
    pid: number;
    nativeThreadId?: string;
    processUuid?: string;
    processBirth?: string;
    rollout?: unknown;
}): boolean;
export declare function selectBoundManagedSessionForTerminal(input: {
    sessions: readonly ManagedSessionState[];
    agent: ExecutorKind;
    pid: number;
    terminalTarget: string;
    aliasMatches(session: ManagedSessionState): boolean;
    exactMatches(session: ManagedSessionState): boolean;
    sameIncarnation(session: ManagedSessionState): boolean;
    ownerIsInactive(session: ManagedSessionState): boolean;
}): ManagedSessionState | undefined;
export declare function selectSoleBoundManagedSessionClaim(input: {
    sessions: readonly ManagedSessionState[];
    terminalTarget: string;
    claims(session: ManagedSessionState): boolean;
    ownerIsInactive(session: ManagedSessionState): boolean;
}): ManagedSessionState | undefined;
export declare function managedTurnMatchesTerminal(input: {
    conversation: Conversation;
    terminal: {
        conversationId: string;
        agent: ExecutorKind;
        pid: number;
    };
    currentIdentity?: TerminalNativeIdentity;
    storedControlExists: boolean;
    terminalIncarnationMatches: boolean;
    workspaceMatches: boolean;
}): boolean;
export declare function assertManagedSessionCanStartTurnPolicy(turns: readonly Conversation[], isBlocking: (conversation: Conversation) => boolean): void;
export declare function terminalSubmissionPayload(payload: string): string;
export declare class TerminalDispatchExecutionService {
    #private;
    constructor(syntheticAcceptanceOutcome: string | undefined, ports: TerminalDispatchExecutionPorts);
    preflightRequiresOwner(ledger: TerminalDispatchLedgerDocument | undefined, lifecycle: boolean): boolean;
    evaluatePreflight(input: {
        ledger?: TerminalDispatchLedgerDocument;
        owner?: Conversation;
        conversation: Conversation;
        requestHash: string;
        requestText: string;
        messageId: string;
        terminalTarget: string;
        ledgerLifecycle: boolean;
        statePathMatches: boolean;
        continuingTurnResponse: boolean;
    }): TerminalDispatchExecutionPreflight;
    transportLifecycle(input: {
        observedHandoff?: {
            verify(requireEmptyComposer: boolean): Promise<unknown>;
        };
        verifiedEmptyHandoff?: {
            verify(requireEmptyComposer: boolean): Promise<unknown>;
        };
        deferredBinding?: {
            verify(requireEmptyComposer: boolean): Promise<unknown>;
            begin(at: string): unknown;
            advance(stage: "text_injected" | "enter_dispatched", at: string): unknown;
        };
        recordStage(stage: "text_injected" | "enter_dispatched", at: string, afterDurable: () => Promise<void>): Promise<void>;
    }): TerminalDispatchTransportLifecycle;
    captureCodexAcceptanceAnchor(input: {
        currentIdentity?: TerminalNativeIdentity;
        expectedNativeThreadId?: string;
        boundProcessUuid?: string;
        boundProcessBirth?: string;
        allowedPreMaterializationIdentity?: CodexPreMaterializationIdentity;
        needsPostSendNativeBinding: boolean;
        candidateSetAnchor?: CodexCandidateSetRolloutAcceptanceAnchor;
    }): CodexRolloutAcceptanceAnchor | undefined;
    resolveCurrentNativeIdentity(request: NativeIdentityResolutionRequest): Promise<TerminalNativeIdentity | undefined>;
    observeCurrentNativeIdentity(request: NativeIdentityResolutionRequest): Promise<NativeAgentSessionIdentityObservation>;
    inspectCodexOpenRootInventory(pid: number, cwd?: string): Promise<CodexOpenRootRolloutInventory>;
    detectAcceptance(request: TerminalAcceptanceDetectionRequest): Promise<TerminalSubmissionAcceptanceEvidence | undefined>;
    pollAcceptance(request: TerminalAcceptancePollRequest): Promise<TerminalDispatchAcceptance>;
    assertRuntimeIdentity(input: RuntimeIdentityAssertion): void;
    assertTurnIdentity(input: {
        conversation: Conversation;
        currentIdentity: TerminalNativeIdentity | undefined;
        operation: string;
    }): void;
    withNativeIdentity(conversation: Conversation, identity: TerminalNativeIdentity): Conversation;
    pollNativeIdentity(request: NativeIdentityPollRequest): Promise<TerminalNativeIdentity | undefined>;
}