import { type ManagedSessionState } from "./managed-session.js";
import { type Conversation } from "./protocol.js";
import type { ManagedBindingConflictKind } from "./terminal-authority-policy.js";
import { type TerminalUserExplicitSendFacts } from "./terminal-user-explicit-send-policy.js";
export { decideTerminalUserExplicitSendEligibility, type TerminalUserExplicitSendEligibility, type TerminalUserExplicitSendFacts } from "./terminal-user-explicit-send-policy.js";
export type TerminalActionName = "status" | "send" | "new_thread" | "list_resumable_threads" | "native_inspect" | "model_options" | "repair_model_control" | "identify_foreground" | "identify_and_send" | "resume_thread" | "reconcile_binding" | "respond" | "approve" | "cancel" | "renew" | "retry_callback" | "retry_submission" | "watch" | "close";
export type TerminalActionSet<Action> = Partial<{
    [Name in TerminalActionName]: Action;
}>;
export interface TerminalSendAuthorityFacts {
    readonly ownership: "none" | "current" | "conflict";
    readonly verifiedEmpty?: boolean;
    readonly externalHandoff?: boolean;
    readonly deferred?: boolean;
    readonly deferredToken?: string;
    readonly externalToken?: string;
    readonly verifiedEmptyToken?: string;
    readonly managedSendSessionId?: string;
}
export type TerminalSendAuthority = {
    mode: "current";
} | {
    mode: "verified_empty";
    token?: string;
} | {
    mode: "external_handoff";
    token?: string;
} | {
    mode: "deferred";
    token?: string;
} | {
    mode: "managed";
    sessionId: string;
} | {
    mode: "raw";
} | {
    mode: "conflict";
};
export type TerminalUserExplicitSendAuthority = {
    eligible: false;
} | {
    eligible: true;
    terminalId: string;
    expectedTerminalToken: string;
};
/**
 * User-explicit terminal Send is physical terminal authority, not AKK Store
 * authority. Turn, Session, transfer, transition, ledger, ownership, and Store
 * writability facts are deliberately absent from this boundary.
 */
export declare function decideTerminalUserExplicitSendAuthority(facts: TerminalUserExplicitSendFacts): TerminalUserExplicitSendAuthority;
/** Canonical send authority used by list projection and fresh mutation prep. */
export declare function decideTerminalSendAuthority(facts: TerminalSendAuthorityFacts): TerminalSendAuthority;
export interface ConflictingManagedSessionClaim {
    session: ManagedSessionState;
    kind: Exclude<ManagedBindingConflictKind, "stale_process_incarnation">;
}
export type TerminalSessionAuthorityConflict = {
    reason: string;
    session_ids: string[];
    binding_statuses: string[];
    transition_ids: Array<string | null>;
    recovery: string;
} | {
    kind: Exclude<ManagedBindingConflictKind, "stale_process_incarnation">;
    reason: string;
    session_ids: string[];
    binding_ids: Array<string | null>;
    session_revisions: Array<number | null>;
    recovery: string;
} | {
    kind: "ambiguous_bound_claims";
    reason: string;
    session_ids: string[];
    recovery: string;
} | {
    reason: string;
    session_ids: string[];
    recovery: string;
};
export declare function decideTerminalSessionAuthorityConflict({ unresolvedSessionClaims, conflictingBoundSessionClaims, matchingSessions }: {
    unresolvedSessionClaims: readonly ManagedSessionState[];
    conflictingBoundSessionClaims: readonly ConflictingManagedSessionClaim[];
    matchingSessions: readonly ManagedSessionState[];
}): TerminalSessionAuthorityConflict | undefined;
export type TerminalDispatchOwnership<Turn, Conflict extends object> = {
    state: "none";
} | {
    state: "current";
    conversation: Turn;
} | {
    state: "conflict";
    conflict: Conflict;
};
interface TerminalSessionDispatchMismatchConflict {
    reason: string;
    owner_session_id?: string;
    bound_session_id: string;
    recovery: string;
}
export declare function applySessionAuthorityToDispatch<Turn, Conflict extends object>({ localOwnership, sessionAuthorityConflict, authoritativeSession, dispatchOwnerMismatch }: {
    localOwnership: TerminalDispatchOwnership<Turn, Conflict>;
    sessionAuthorityConflict?: TerminalSessionAuthorityConflict;
    authoritativeSession?: ManagedSessionState;
    dispatchOwnerMismatch?: {
        ownerSessionId?: string;
    };
}): TerminalDispatchOwnership<Turn, Conflict | TerminalSessionAuthorityConflict | TerminalSessionDispatchMismatchConflict>;
export declare function compareManagedConversationRecency(left: Conversation, right: Conversation): number;
export interface ManagedTerminalAssociation {
    managedSessionId?: string;
    historySessionId?: string;
    sessionIds: Set<string>;
    sessionAllRelated: Conversation[];
    sessionDisplayedRelated: Conversation[];
}
export declare function decideManagedTerminalAssociation({ allRelated, displayedRelated, authoritativeSession, sessionAuthorityRequired, currentOwner }: {
    allRelated: Conversation[];
    displayedRelated: readonly Conversation[];
    authoritativeSession?: ManagedSessionState;
    sessionAuthorityRequired: boolean;
    currentOwner?: Conversation;
}): ManagedTerminalAssociation;
export declare function selectManagedTerminalHistory({ displayedRelated, currentConversationId, hasCurrentTurn, includeAll }: {
    displayedRelated: readonly Conversation[];
    currentConversationId?: string;
    hasCurrentTurn: boolean;
    includeAll: boolean;
}): {
    recentConversation?: Conversation;
    historyConversations: Conversation[];
};
export declare function managedTurnNeedsAttention(facts: {
    status: string;
    callbackDeliveryStatus?: string;
}): boolean;
export interface TerminalDispatchConflictProjection {
    reason: string;
    dispatch_status?: string;
    owner_conversation_id?: string;
    message_id?: string;
    recovery: string;
}
export declare function projectTerminalDispatchConflict(facts: {
    reason: string;
    dispatchStatus?: string;
    ownerConversationId?: string;
    messageId?: string;
}): TerminalDispatchConflictProjection;
export declare function decideLocalTerminalDispatchOwnership<Turn>(facts: {
    ledgerOwnerId: string;
    localOwner?: Turn;
    localOwnerMatchesLiveTerminal: boolean;
}): {
    state: "current";
    conversation: Turn;
} | {
    state: "conflict";
    conflict: {
        reason: string;
        owner_conversation_id: string;
        recovery: string;
    };
};
export declare function selectTerminalAvailableActions<Action>({ ownership, currentActions, sessionAwareRawActions, nonOwnerRawActions, authoritativeSendAction, terminalUserExplicitSendAction, reconcileBindingAction, terminalScopedApprovalAction, isAction }: {
    ownership: "none" | "current" | "conflict";
    currentActions: TerminalActionSet<Action>;
    sessionAwareRawActions: TerminalActionSet<Action>;
    nonOwnerRawActions: TerminalActionSet<Action>;
    authoritativeSendAction?: Action;
    terminalUserExplicitSendAction?: Action;
    reconcileBindingAction?: Action;
    terminalScopedApprovalAction?: Action;
    isAction?: (value: unknown) => value is Action;
}): TerminalActionSet<Action>;
export declare function nonOwnerTerminalActions<Action>(actions: TerminalActionSet<Action>, facts: {
    hasAuthoritativeSession: boolean;
    rolloutBackedCodexSession: boolean;
}): TerminalActionSet<Action>;
export declare function projectTerminalManagement<Turn>({ managedSessionId, managedSessionShortRef, currentTurn, recentTurn, sessionAllRelatedCount, hiddenTurnCount, sessionCount, authoritativeSession, history }: {
    managedSessionId?: string;
    managedSessionShortRef: string | null;
    currentTurn?: Turn;
    recentTurn?: Turn;
    sessionAllRelatedCount: number;
    hiddenTurnCount: number;
    sessionCount: number;
    authoritativeSession?: ManagedSessionState;
    history?: Turn[];
}): {
    session_id: string | null;
    session_short_ref: string | null;
    current_turn: NonNullable<Turn> | null;
    recent_turn: NonNullable<Turn> | null;
    turn_count: number;
    hidden_turn_count: number;
    session_count: number;
    history?: Turn[] | undefined;
    binding_status?: import("./managed-session.js").ManagedSessionStatus | undefined;
    binding_id?: string | null | undefined;
    binding_generation?: number | null | undefined;
    native_thread_id?: string | null | undefined;
    binding_token?: string | undefined;
};
export declare function authoritativeTerminalIdentity(session: ManagedSessionState | undefined): {
    native_agent_session_id: string;
    native_agent_process_uuid: string | undefined;
    native_agent_process_birth: string | undefined;
    native_agent_rollout: {
        fd: string;
        device: string;
        inode: string;
        path: string;
    } | undefined;
    native_agent_identity_evidence: string;
    lifecycle_binding_token: string;
} | {
    native_agent_session_id?: undefined;
    native_agent_process_uuid?: undefined;
    native_agent_process_birth?: undefined;
    native_agent_rollout?: undefined;
    native_agent_identity_evidence?: undefined;
    lifecycle_binding_token?: undefined;
};
export declare function projectPublicManagementConflict<Conflict extends object>({ conflict, verifiedEmptyToken, deferredToken, explicitlyAbandonedPredecessor }: {
    conflict?: Conflict;
    verifiedEmptyToken?: string;
    deferredToken?: string;
    explicitlyAbandonedPredecessor: boolean;
}): Conflict | (Conflict & {
    kind: string;
    reason: string;
    recovery: string;
}) | undefined;
export declare function projectHandoffPresentation(facts: {
    externalHandoffDetected: boolean;
    externalHandoffAdoptable: boolean;
    recoveryBlockingTurnCount: number;
    hasHandoffDecision: boolean;
    sourceBlockingTurnCount: number;
    automatedInputComposerReady: boolean;
    verifiedEmptyToken?: string;
}): {};
export declare function projectReconcileBindingAction(facts: {
    terminalId?: string;
    conflictingSession: ManagedSessionState;
    conflictingSessionRevision: number;
    expectedTerminalToken: string;
}): {
    tool: string;
    arguments: {
        terminal_id: string | undefined;
        conflicting_session_id: string;
        expected_session_revision: number;
        expected_binding_token: string;
        expected_terminal_token: string;
    };
    requires_user_intent: boolean;
};
export declare function projectHandoffDecision(facts: {
    sourceSessionId?: string;
    sourceTurnId: string;
    liveNativeThreadId: string;
    handoffDecisionToken: string;
    actionTurnId?: string;
}): {
    kind: string;
    source_session_id: string | undefined;
    source_turn_id: string;
    live_native_thread_id: string;
    choices: {
        take_over_current: {
            action: {
                tool: string;
                arguments: {
                    turn_id: string;
                    reason: string;
                };
                requires_explicit_user_confirmation: boolean;
            };
            after: string;
        };
        keep_source: {
            effect: string;
            after: string;
        };
    };
};
export declare function projectBlockingTurn(facts: {
    sessionId: string;
    turnId: string;
    status: string;
    recoveryTurnId?: string;
}): {
    session_id: string;
    turn_id: string;
    status: string;
    recovery_action: {
        tool: string;
        arguments: {
            turn_id: string;
        };
        requires_explicit_user_confirmation: boolean;
    };
};