import type { CodexOpenRootRolloutInventory } from "./agent-session-provider.js";
import { type ExecutorKind } from "./executors.js";
import { type HumanObservedHandoffTargetSnapshot, type ManagedSessionState } from "./managed-session.js";
import { type Conversation } from "./protocol.js";
import { type TerminalAgentAdapterRegistry, type TerminalControlRef, type TerminalRuntimeIdentity } from "./terminal-agent-adapter.js";
import { TerminalAgentBridge, type ResolvedTerminalConversation } from "./terminal-agent-bridge.js";
import { type TerminalDispatchOwnership } from "./terminal-action-projection.js";
import { type CodexAllowedCompanionSet, type CodexSendAuthorityContext } from "./terminal-authority-policy.js";
import { type TerminalNativeIdentity, type TerminalNativeIdentityObservation } from "./terminal-binding-authority.js";
import { type TerminalScopedCodexApprovalBoundary, type TerminalScopedCodexApprovalPromptSnapshot } from "./terminal-scoped-approval-authority.js";
import type { TerminalDispatchLedgerDocument } from "./terminal-dispatch-ledger-codec.js";
import type { TerminalProcessSource } from "./terminal-process-source.js";
import type { TerminalControlProvider } from "./terminal-control-provider.js";
import { type TerminalListInventoryEntry, type TerminalListInventoryScan } from "./terminal-list-inventory.js";
interface JsonObject {
    [key: string]: unknown;
}
export interface TerminalListCliOptions {
    agent?: string;
    all?: boolean;
    conversation?: string;
    conversationId?: string;
    expectedTerminalToken?: string;
    logDir?: string;
    managedOnly?: boolean;
    noApprovalScan?: boolean;
    reconcile?: boolean;
    scrollbackLines?: number | string;
    session?: string;
    state?: string;
    status?: string;
    storeDir?: string;
    terminalDebug?: boolean;
    turn?: string;
    workspace?: string;
    [option: string]: unknown;
}
interface TerminalListMonitorReconciliation {
    checked: number;
    launched: number;
    repaired: number;
    collateral_stalls_checked: number;
    collateral_stalls_skipped: number;
    already_running: number;
    skipped: number;
    errors: number;
    items: Array<{
        status?: string;
        [field: string]: unknown;
    }>;
}
interface TerminalListIdleReconciliation {
    checked: number;
    closed: number;
    skipped: number;
    idle_timeout_minutes: number;
}
interface TerminalListNativeIdentityRequest {
    options: TerminalListCliOptions;
    agent: ExecutorKind;
    pid: number;
    cwd?: string;
    preferredSessionId?: string;
    allowedCompanionIdentity?: CodexAllowedCompanionSet["primary"];
    allowedAdditionalIdentities?: CodexAllowedCompanionSet["additional"];
}
export type TerminalListScanEntry = TerminalListInventoryEntry;
export type TerminalListScan = TerminalListInventoryScan;
export type ExactTerminalListObservation = {
    state: "available";
    rawTerminal: TerminalListScanEntry;
    terminal: TerminalListScanEntry;
    summary: TerminalListScan["summary"];
} | {
    state: "absent";
    summary: TerminalListScan["summary"];
} | {
    state: "unavailable";
    reason?: string;
    summary: TerminalListScan["summary"];
};
type TerminalDispatchOwnershipResult = TerminalDispatchOwnership<Conversation, JsonObject>;
type TerminalScopedCodexApprovalResolution = {
    state: "unmanaged";
} | {
    state: "eligible";
    boundary: TerminalScopedCodexApprovalBoundary;
} | {
    state: "blocked";
    reason: string;
};
export interface TerminalListReconciliationPorts {
    reconcileMonitors(options: TerminalListCliOptions, request: {
        includeCallbackRecovery: false;
        reason: "list_reconciliation";
        conversationId: undefined;
    }): Promise<TerminalListMonitorReconciliation>;
    reconcileIdleConversations(storeDir: string, options: TerminalListCliOptions): TerminalListIdleReconciliation;
}
export interface TerminalListDiscoveryPorts {
    createRuntimeTerminalAgentRegistry(options: TerminalListCliOptions): TerminalAgentAdapterRegistry;
    createTerminalAgentBridge(options: TerminalListCliOptions, provider?: TerminalControlProvider, registry?: TerminalAgentAdapterRegistry): TerminalAgentBridge;
    createTerminalControlProvider(options: TerminalListCliOptions): TerminalControlProvider;
    createTerminalProcessSource(options: TerminalListCliOptions): TerminalProcessSource;
    agentVersionForRunningProcess(agent: ExecutorKind, pid: number, options: TerminalListCliOptions): string | undefined;
    codexLatentClearResumeObservation(request: {
        screen?: string;
        agentVersion?: string;
    }): {
        sourceNativeThreadId: string;
        fingerprint: string;
    } | undefined;
    codexManagedIdentityResolutionContext(request: {
        storeDir: string;
        terminal: Pick<ResolvedTerminalConversation, "conversationId" | "agent" | "pid" | "terminalControl">;
    }): {
        preferredSessionId?: string;
        companions: CodexAllowedCompanionSet;
    };
    codexProcessIncarnationForPid(pid: number): {
        processUuid: string;
        processBirth: string;
        evidence: "codex_process_birth";
    };
    processIncarnationForPid(pid: number): {
        processUuid: string;
        processBirth: string;
        evidence: "process_birth";
    };
    inspectCodexOpenRootRolloutInventory(request: {
        options: TerminalListCliOptions;
        pid: number;
        cwd?: string;
    }): Promise<CodexOpenRootRolloutInventory>;
    nativeInspectionComposerEmpty(agent: ExecutorKind, screen: string | undefined): boolean;
    observeCurrentNativeAgentSessionIdentity(request: TerminalListNativeIdentityRequest): Promise<TerminalNativeIdentityObservation>;
    terminalStatusForControl(agent: ExecutorKind, terminalControl: TerminalControlRef, options: TerminalListCliOptions, runtime?: TerminalRuntimeIdentity): ReturnType<TerminalAgentBridge["status"]>;
}
export interface TerminalListStoreObservationPorts {
    callbackRetryDisposition(delivery: unknown): {
        state: string;
    };
    codexLingeringBeforeIdentityMatchesSession(request: {
        storeDir: string;
        session: ManagedSessionState;
        identity: TerminalNativeIdentity;
    }): boolean;
    isActiveStatus(status: unknown): boolean;
    isDiscoverableTmuxConversation(conversation: Conversation): boolean;
    isVerifiedDeadTerminalAgentProcess(conversation: Conversation | JsonObject): boolean;
    loadTerminalBridgeDispatchLedger(terminalControl: TerminalControlRef): TerminalDispatchLedgerDocument | undefined;
    loadTerminalDispatchLedgerOwner(ledger: TerminalDispatchLedgerDocument): Conversation | undefined;
    listTerminalWatches?(storeDir: string, options?: {
        includeAll?: boolean;
    }): JsonObject[];
    scanTerminalWatchesForExactObservation?(storeDir: string, options?: {
        includeAll?: boolean;
    }): {
        watches: JsonObject[];
        activeOverlayTrusted: boolean;
    };
    managedSessionStoreDirForConversation(conversation: Conversation): string | undefined;
    managedTurnsForSession(storeDir: string, sessionId: string): Conversation[];
    matchesConfiguredWorkspace(configured: unknown, observed: unknown): boolean;
    orphanedTerminalDispatchForRecovery(terminalControl: TerminalControlRef): TerminalDispatchLedgerDocument | undefined;
    storeDirFromOptions(options: TerminalListCliOptions): string;
    summarizeConversation(conversation: Conversation): JsonObject;
    terminalBridgeEnabled(conversation: Conversation | JsonObject): boolean;
    terminalBridgeSubmission(conversation: Conversation | JsonObject | undefined): {
        status?: string;
        message_id?: unknown;
        last_proven_stage?: unknown;
    } | undefined;
    terminalControlFromTakeover(value: unknown): TerminalControlRef | undefined;
    terminalDispatchRecordMatchesControl(ledger: TerminalDispatchLedgerDocument | undefined, terminalControl: TerminalControlRef, options?: {
        requireProcessAnchor?: boolean;
    }): boolean;
}
export interface TerminalListAuthorityPorts {
    activeTurnHandoffDecisionToken(request: {
        handoffToken: string;
        turn: Conversation;
        ledger?: TerminalDispatchLedgerDocument;
    }): string;
    assertManagedTerminalDispatchOwner(request: {
        storeDir: string;
        conversation: Conversation;
        terminalControl: TerminalControlRef;
        action: "approve" | "cancel";
    }): void;
    observeDeferredCodexAuthority(request: {
        mode: "list";
        storeDir: string;
        context: CodexSendAuthorityContext;
        sourceSession?: ManagedSessionState;
        candidateInventory?: CodexOpenRootRolloutInventory;
        abandonment: "never" | "missing_rollout";
        requireUnclaimedCandidate: true;
    }): import("./terminal-list-ownership-service.js").DeferredCodexAuthorityObservation | undefined;
    observedHandoffTargetResolution(request: {
        storeDir: string;
        agent: ExecutorKind;
        workspace: string;
        nativeThreadId: string;
        sourceSessionId: string;
    }): {
        status: "eligible";
        session?: ManagedSessionState;
        snapshot: HumanObservedHandoffTargetSnapshot;
    } | {
        status: "blocked";
        reason: string;
    };
}
export interface TerminalListPolicyConfiguration {
    approvalTtlMs: number;
    selectorCommands: ReadonlySet<string>;
    rememberOriginalExpectedTerminalSelector(options: TerminalListCliOptions, selector: string | undefined): void;
}
export interface TerminalListCliDependencies {
    reconciliation: TerminalListReconciliationPorts;
    discovery: TerminalListDiscoveryPorts;
    store: TerminalListStoreObservationPorts;
    authority: TerminalListAuthorityPorts;
    policy: TerminalListPolicyConfiguration;
}
export interface TerminalListCliFacade {
    runList(options: TerminalListCliOptions): Promise<void>;
    buildTerminalListGroup(request: {
        options: TerminalListCliOptions;
        agentFilter?: ExecutorKind;
        statusFilter?: string;
        terminalId?: string;
    }): Promise<TerminalListScan>;
    observeExactTerminal(request: {
        options: TerminalListCliOptions;
        terminalId: string;
    }): Promise<ExactTerminalListObservation>;
    provisionalManagedBindingTurnCount(storeDir: string, session: ManagedSessionState): number | undefined;
    managedSessionHasUnresolvedNativeTransition(storeDir: string, session: ManagedSessionState): boolean;
    managedSessionHasAnyNativeTransition(storeDir: string, session: ManagedSessionState): boolean;
    terminalControlForManagedConversation(conversation: Conversation): TerminalControlRef | undefined;
    terminalIncarnationBlockingTurns(storeDir: string, terminalControl: TerminalControlRef): Conversation[];
    managedTurnNeedsAttention(conversation: Conversation): boolean;
    assertTerminalIncarnationCanStartTurn(storeDir: string, terminalControl: TerminalControlRef): void;
    terminalDispatchOwnership(terminalControl: TerminalControlRef): TerminalDispatchOwnershipResult;
    resolveTerminalScopedCodexApproval(request: {
        options: TerminalListCliOptions;
        terminal: ResolvedTerminalConversation;
        approvalSnapshot?: TerminalScopedCodexApprovalPromptSnapshot;
    }): Promise<TerminalScopedCodexApprovalResolution>;
    resolveConversationSelectorOption(commandName: string, options: TerminalListCliOptions): Promise<void>;
}
export declare function createTerminalListCliFacade(dependencies: TerminalListCliDependencies): TerminalListCliFacade;
export {};