import type { CodexOpenRootRolloutInventory } from "./agent-session-provider.js";
import { codexProcessBirthForLifecycle, codexProcessIncarnationForPid } from "./codex-process-incarnation.js";
import type { DeferredForegroundTransfer, DeferredForegroundTransferSourceRolloutAuthority, DeferredForegroundTransferSourceTurnAuthority } from "./deferred-foreground-transfer.js";
import * as deferredAuthorityAdapter from "./deferred-foreground-authority-cli-adapter.js";
import type { ExecutorKind } from "./executors.js";
import { type ManagedSessionState, type NativeThreadTransition } from "./managed-session.js";
import { type Conversation } from "./protocol.js";
import type { TerminalCompletionEvidence, TerminalControlRef, TerminalDurableCompletionRequest, TerminalRuntimeIdentity, TerminalAgentAdapter, TerminalAgentAdapterRegistry } from "./terminal-agent-adapter.js";
import { type TerminalAgentBridge, type TerminalBridgeStatus } from "./terminal-agent-bridge.js";
import type { TerminalControlProvider } from "./terminal-control-provider.js";
import type { TerminalProcessSource } from "./terminal-process-source.js";
import { type CodexAllowedCompanionSet, type CodexPreMaterializationIdentity, type CodexSendAuthorityContext, type ManagedBindingConflictKind } from "./terminal-authority-policy.js";
import { type NativeAgentSessionIdentityObservation, type NativeIdentityResolutionRequest } from "./terminal-dispatch-execution.js";
import type { DeferredCodexForegroundDispatchSnapshot, TerminalDispatchTerminal } from "./terminal-dispatch-composition.js";
import type { TerminalDispatchLedgerDocument } from "./terminal-dispatch-ledger-codec.js";
import type { BoundTerminalAgentProcessObservation, VerifiedDeadAgentCompletionObservation } from "./verified-dead-agent-policy.js";
import { type TerminalNativeIdentity as NativeAgentSessionIdentity } from "./terminal-binding-authority.js";
export type TerminalIdentityCliOptions = Readonly<Record<string, unknown>>;
export interface TerminalIdentityTerminal {
    conversationId: string;
    agent: ExecutorKind;
    pid: number;
    legacy: boolean;
    adapter: TerminalAgentAdapter;
    terminalControl: TerminalControlRef;
}
interface NativeThreadOwnershipRequest {
    options: TerminalIdentityCliOptions;
    agent: ExecutorKind;
    currentPid: number;
    nativeThreadId: string;
    storeDir: string;
    terminalControl: TerminalControlRef;
    excludedManagedSessionId?: string;
    allowedManagedSessionIds?: string[];
}
interface CodexProbeRequest {
    options: TerminalIdentityCliOptions;
    terminal: TerminalIdentityTerminal;
    currentIdentity?: NativeAgentSessionIdentity;
    runtimeOverride: TerminalRuntimeIdentity;
}
interface CompletionObservationInput {
    options: TerminalIdentityCliOptions;
    conversation: Conversation;
    terminalControl: TerminalControlRef;
}
interface ManagedOwnerInput {
    session: ManagedSessionState;
    terminal: Pick<TerminalIdentityTerminal, "agent" | "pid">;
    identity?: NativeAgentSessionIdentity;
}
interface ManagedIdentityContextInput {
    storeDir: string;
    terminal: Pick<TerminalIdentityTerminal, "conversationId" | "agent" | "pid" | "terminalControl">;
}
interface KnownRootSetInput {
    storeDir: string;
    terminal: TerminalIdentityTerminal;
    transition: NativeThreadTransition;
}
interface ComposerReadyInput {
    options: TerminalIdentityCliOptions;
    terminalControl: TerminalControlRef;
    runtime?: TerminalRuntimeIdentity;
}
export interface TerminalIdentityRuntimePorts {
    createBridge(options: TerminalIdentityCliOptions): TerminalAgentBridge;
    createControlProvider(options: TerminalIdentityCliOptions): TerminalControlProvider;
    createProcessSource(options: TerminalIdentityCliOptions): TerminalProcessSource;
    createAgentRegistry(options: TerminalIdentityCliOptions): TerminalAgentAdapterRegistry;
    observeNativeIdentity(request: NativeIdentityResolutionRequest & {
        options: TerminalIdentityCliOptions;
    }): Promise<NativeAgentSessionIdentityObservation>;
    probeCodexCurrentThread(request: CodexProbeRequest): Promise<NativeAgentSessionIdentity>;
    agentVersionForRunningProcess?(agent: ExecutorKind, pid: number): string | undefined;
}
export interface TerminalIdentityStorePorts {
    terminalControlFromTakeover(value: unknown): TerminalControlRef | undefined;
    storeDir(options: TerminalIdentityCliOptions): string;
    storeDirForStatePath(statePath: string): string;
    storeDirForConversation(conversation: Conversation): string | undefined;
    withWriter<Result>(storeDir: string, operation: () => Result): Result;
    turnsForSession(storeDir: string, sessionId: string): Conversation[];
    turnMatchesTerminal(conversation: Conversation, terminal: TerminalIdentityTerminal, identity?: NativeAgentSessionIdentity): boolean;
    isDiscoverableTurn(conversation: Conversation): boolean;
    readEvents(logPath: string): TerminalDispatchLedgerDocument[];
    loadLedger(terminalControl: TerminalControlRef): TerminalDispatchLedgerDocument | undefined;
    ledgerMatchesControl(ledger: TerminalDispatchLedgerDocument | undefined, terminalControl: TerminalControlRef, options?: {
        requireCurrentRoute?: boolean;
        requireProcessAnchor?: boolean;
    }): boolean;
    ledgerProcessAnchor(ledger: TerminalDispatchLedgerDocument): number | undefined;
    acquireStateLock(statePath: string): () => void;
    loadTurn(statePath: string): Conversation;
    saveTurn(statePath: string, conversation: Conversation): void;
    appendEvent(logPath: string, event: Readonly<{
        event: string;
        [key: string]: unknown;
    }>): void;
}
export interface TerminalIdentityCompletionPorts {
    requiresExactBoundCodexCompletion(conversation: Conversation): boolean;
}
export interface TerminalIdentityAuthorityPorts {
    assertTurnBindingCurrent(conversation: Conversation, operation: string): void;
    assertManagedSessionCanStartTurn(turns: Conversation[]): void;
    assertNativeThreadHasExclusiveOwnership(request: NativeThreadOwnershipRequest): Promise<void>;
    assertSafeTerminalSend(agent: ExecutorKind, status: TerminalBridgeStatus): void;
    assertTerminalLifecycleReady(input: {
        options: TerminalIdentityCliOptions;
        terminal: TerminalDispatchTerminal;
        terminalStatus: TerminalBridgeStatus;
    }): void;
    provisionalManagedBindingTurnCount(storeDir: string, session: ManagedSessionState): number | undefined;
    managedTurnNeedsAttention(turn: Conversation): boolean;
    hasUnresolvedNativeTransition(storeDir: string, session: ManagedSessionState): boolean;
    hasAnyNativeTransition(storeDir: string, session: ManagedSessionState): boolean;
}
export interface TerminalIdentityEnvironmentPorts {
    cwd(): string;
    now(): Date;
    isProcessAlive(pid: number): boolean;
    workspaceMatches(configured: unknown, candidate: unknown): boolean;
}
export interface CreateTerminalIdentityAuthorityCliAdapterInput {
    runtime: TerminalIdentityRuntimePorts;
    store: TerminalIdentityStorePorts;
    authority: TerminalIdentityAuthorityPorts;
    environment: TerminalIdentityEnvironmentPorts;
    completion: TerminalIdentityCompletionPorts;
}
export declare function createTerminalIdentityAuthorityCliAdapter(ports: CreateTerminalIdentityAuthorityCliAdapterInput): Readonly<{
    resolveTerminalConversationFromOptions: (options: TerminalIdentityCliOptions) => Promise<TerminalIdentityTerminal | undefined>;
    refineTerminalTurnEndpoint: (input: EndpointRefinementInput) => Conversation;
    terminalRuntimeIdentityForConversation: (conversation: Conversation, terminalControl: TerminalControlRef) => TerminalRuntimeIdentity;
    terminalDurableRequestForConversation: (conversation: Conversation, terminalControl: TerminalControlRef) => TerminalDurableCompletionRequest;
    migrateLegacyTerminalAgentIdentity: (input: LegacyIdentityMigrationInput) => Promise<Conversation>;
    exactLifecycleProcessIdentity: (terminal: TerminalIdentityTerminal, identity: NativeAgentSessionIdentity) => NativeAgentSessionIdentity;
    codexProcessBirthForLifecycle: typeof codexProcessBirthForLifecycle;
    codexProcessIncarnationForPid: typeof codexProcessIncarnationForPid;
    observeDurableCompletionBeforeDeadStall: (input: CompletionObservationInput) => Promise<DurableCompletionBeforeDeadStallObservation>;
    observeBoundTerminalAgentProcess: (input: CompletionObservationInput) => Promise<BoundTerminalAgentProcessObservation>;
    resolvedTerminalProcessIncarnation: typeof resolvedTerminalProcessIncarnation;
    managedSessionOwnerIsConclusivelyInactive: (input: ManagedOwnerInput) => boolean;
    codexKnownBeforeIdentityForManagedSession: typeof codexKnownBeforeIdentityForManagedSession;
    codexLingeringBeforeIdentityMatchesSession: typeof codexLingeringBeforeIdentityMatchesSession;
    logicalIdentityForManagedSession: typeof logicalIdentityForManagedSession;
    codexAllowedCompanionIdentityForManagedSession: typeof codexAllowedCompanionIdentityForManagedSession;
    codexAllowedCompanionSetForManagedSession: typeof codexAllowedCompanionSetForManagedSession;
    codexManagedIdentityResolutionContext: (input: ManagedIdentityContextInput) => {
        claimedSession?: ManagedSessionState;
        companions: CodexAllowedCompanionSet;
        preferredSessionId?: string;
    };
    codexKnownRootSetForLifecycleTransition: (input: KnownRootSetInput) => CodexAllowedCompanionSet;
    codexPreMaterializationIdentityForManagedSession: typeof codexPreMaterializationIdentityForManagedSession;
    assertCodexComposerReadyForAutomatedInput: (input: ComposerReadyInput) => Promise<void>;
    verifyCodexPendingManagedSendStatus: (input: VerifyPendingManagedSendInput) => Promise<void>;
    terminalRuntimeForLiveIdentity: (input: Parameters<typeof terminalRuntimeForLiveIdentity>[0]) => TerminalRuntimeIdentity;
    managedSessionClaimsResolvedTerminal: (session: ManagedSessionState, terminal: ResolvedTerminalClaim) => boolean;
    bindingMatchesLiveTerminal: (session: ManagedSessionState, terminal: TerminalIdentityTerminal, identity: NativeAgentSessionIdentity | undefined, storeDir: string) => boolean;
    boundManagedSessionForTerminal: (input: BoundManagedSessionInput) => ManagedSessionState | undefined;
    managedBindingConflictKindForResolvedTerminal: (input: ManagedBindingConflictInput) => ManagedBindingConflictKind | undefined;
    soleBoundManagedSessionClaimForTerminal: (storeDir: string, terminal: ResolvedTerminalClaim) => ManagedSessionState | undefined;
    createBoundManagedSession: (input: CreateBoundManagedSessionInput) => ManagedSessionState;
    materializeCurrentManagedSession: (input: MaterializeManagedSessionInput) => ManagedSessionState | undefined;
    reattachManagedSessionForNativeIdentity: (input: ReattachManagedSessionInput) => Promise<ManagedSessionState | undefined>;
    deferredForegroundAuthorityAdapterPorts: () => deferredAuthorityAdapter.DeferredForegroundAuthorityAdapterPorts;
    codexCandidateInventoryHasNoOtherManagedClaim: (options: CodexCandidateInventoryClaimOptions) => boolean;
    deferredCandidateSourceTurnHistory: (storeDir: string, session: ManagedSessionState) => DeferredForegroundTransferSourceTurnAuthority[] | undefined;
    explicitlyAbandonedCandidateSourceFingerprint: (options: ExplicitlyAbandonedFingerprintOptions) => string | undefined;
    assertFrozenExplicitlyAbandonedPredecessorAuthority: (options: FrozenAbandonedPredecessorOptions) => void;
    deferredCodexForegroundDispatchSnapshot: (control: TerminalControlRef) => DeferredCodexForegroundDispatchSnapshot;
    deferredCodexPreviousDispatchSnapshotMatches: (options: PreviousDispatchSnapshotOptions) => boolean;
    observeDeferredCodexAuthority: (options: ObserveDeferredAuthorityOptions) => deferredAuthorityAdapter.DeferredCodexAuthorityObservation | undefined;
    assertVerifiedEmptyCodexHandoffBoundary: (input: VerifiedEmptyCodexHandoffInput) => Promise<void>;
}>;
interface EndpointRefinementInput {
    conversation: Conversation;
    statePath: string;
    terminalControl: TerminalControlRef;
}
interface LegacyIdentityMigrationInput {
    conversation: Conversation;
    statePath: string;
    logPath: string;
    options: TerminalIdentityCliOptions;
}
type DurableCompletionBeforeDeadStallObservation = VerifiedDeadAgentCompletionObservation<TerminalCompletionEvidence>;
declare function resolvedTerminalProcessIncarnation(terminal: Pick<TerminalIdentityTerminal, "agent" | "pid">, identity?: NativeAgentSessionIdentity): {
    processUuid?: string;
    processBirth?: string;
};
declare function codexKnownBeforeIdentityForManagedSession(input: {
    storeDir: string;
    session: ManagedSessionState;
    requireNewThread?: boolean;
}): NativeAgentSessionIdentity | undefined;
declare function codexLingeringBeforeIdentityMatchesSession(input: {
    storeDir: string;
    session: ManagedSessionState;
    identity?: NativeAgentSessionIdentity;
}): boolean;
declare function logicalIdentityForManagedSession(input: {
    storeDir: string;
    session: ManagedSessionState;
    observedIdentity?: NativeAgentSessionIdentity;
}): NativeAgentSessionIdentity | undefined;
declare function codexAllowedCompanionIdentityForManagedSession(input: {
    storeDir: string;
    session: ManagedSessionState;
}): CodexPreMaterializationIdentity | undefined;
declare function codexAllowedCompanionSetForManagedSession(input: {
    storeDir: string;
    session: ManagedSessionState;
}): CodexAllowedCompanionSet;
declare function codexPreMaterializationIdentityForManagedSession(input: {
    storeDir: string;
    session: ManagedSessionState;
    observedIdentity?: NativeAgentSessionIdentity;
}): CodexPreMaterializationIdentity | undefined;
interface VerifyPendingManagedSendInput {
    options: TerminalIdentityCliOptions;
    terminal: TerminalIdentityTerminal;
    session: ManagedSessionState;
    logicalIdentity?: NativeAgentSessionIdentity;
    allowedPreMaterializationIdentity?: CodexPreMaterializationIdentity;
    allowedAdditionalIdentities?: CodexPreMaterializationIdentity[];
}
declare function terminalRuntimeForLiveIdentity(input: {
    terminal: TerminalDispatchTerminal;
    identity?: NativeAgentSessionIdentity;
    expectedEmptyNativeSession?: boolean;
    physicalOnly?: boolean;
}): TerminalRuntimeIdentity;
type ResolvedTerminalClaim = Pick<TerminalIdentityTerminal, "conversationId" | "agent" | "pid" | "terminalControl">;
interface BoundManagedSessionInput {
    storeDir: string;
    terminal: TerminalIdentityTerminal;
    identity?: NativeAgentSessionIdentity;
}
interface ManagedBindingConflictInput {
    storeDir: string;
    session: ManagedSessionState;
    terminal: TerminalIdentityTerminal;
    identity?: NativeAgentSessionIdentity;
}
interface CreateBoundManagedSessionInput {
    sessionId: string;
    terminal: TerminalIdentityTerminal;
    identity?: NativeAgentSessionIdentity;
    nativeThreadId?: string;
    evidence?: string;
    generation?: number;
    lineage: ManagedSessionState["lineage"];
    now?: Date;
}
interface MaterializeManagedSessionInput {
    options: TerminalIdentityCliOptions;
    terminal: TerminalIdentityTerminal;
    identity?: NativeAgentSessionIdentity;
}
interface ReattachManagedSessionInput {
    options: TerminalIdentityCliOptions;
    terminal: TerminalIdentityTerminal;
    identity: NativeAgentSessionIdentity;
    storeDir: string;
}
interface CodexCandidateInventoryClaimOptions {
    storeDir: string;
    inventory: CodexOpenRootRolloutInventory;
    sourceSessionId: string;
    includeDetached?: boolean;
}
interface ExplicitlyAbandonedFingerprintOptions {
    storeDir: string;
    session: ManagedSessionState;
    sourceTurnHistory: DeferredForegroundTransferSourceTurnAuthority[];
    dispatchSnapshot: DeferredCodexForegroundDispatchSnapshot;
    sourceRevision?: number;
    sourceBindingToken?: string;
    ledgerOverride?: TerminalDispatchLedgerDocument;
    requireResolvedTopLevel?: boolean;
}
interface FrozenAbandonedPredecessorOptions {
    storeDir: string;
    transfer: DeferredForegroundTransfer;
    terminalControl: TerminalControlRef;
}
interface PreviousDispatchSnapshotOptions {
    transfer: DeferredForegroundTransfer;
    terminalControl: TerminalControlRef;
    ledger: TerminalDispatchLedgerDocument | undefined;
}
interface ObserveDeferredAuthorityOptions {
    mode: deferredAuthorityAdapter.DeferredCodexAuthorityMode;
    storeDir: string;
    context: CodexSendAuthorityContext;
    sourceSession?: ManagedSessionState;
    candidateInventory?: CodexOpenRootRolloutInventory;
    abandonment: "never" | "missing_rollout" | "missing_inventory_rollout";
    fixedSourceRolloutAuthority?: DeferredForegroundTransferSourceRolloutAuthority;
    fixedDispatchSnapshot?: DeferredCodexForegroundDispatchSnapshot;
    sourceRevision?: number;
    sourceBindingToken?: string;
    requireUnclaimedCandidate?: boolean;
}
interface VerifiedEmptyCodexHandoffInput {
    options: TerminalIdentityCliOptions;
    terminal: TerminalDispatchTerminal;
    sourceSession: ManagedSessionState;
    expectedSourceStatus: "bound" | "detached";
    requireNoDispatch: boolean;
    requireEmptyComposer?: boolean;
}
export {};