import type { CodingAgentSessionProvider } from "./agent-session-provider.js";
import type { ActiveCodexProcess, ForkContextPackage } from "./codex-session-provider.js";
import type { ExecutorKind } from "./executors.js";
import { type Conversation } from "./protocol.js";
import type { ResolvedTerminalConversation, TerminalBridgeStatus } from "./terminal-agent-bridge.js";
import { type TerminalControlRef, type TerminalRuntimeIdentity } from "./terminal-agent-adapter.js";
import { type TerminalStatusListObservation, type TerminalStatusJsonObject, type TerminalStatusSummaryPorts } from "./terminal-status-facts.js";
import type { TranscriptEvent } from "./transcript.js";
export interface TerminalStatusCliOptions {
    conversation?: unknown;
    conversationId?: unknown;
    idleTimeoutMinutes?: unknown;
    logDir?: unknown;
    maxCommands?: unknown;
    maxMessages?: unknown;
    maxTextLength?: unknown;
    reconcile?: unknown;
    scrollbackLines?: unknown;
    state?: unknown;
    storeDir?: unknown;
    trace?: unknown;
    turn?: unknown;
    workspace?: unknown;
    [option: string]: unknown;
}
interface StatusStoreSelection {
    storeDir: string;
    reconciliationConversationId?: string;
}
interface LoadedStatusConversation {
    conversation: Conversation;
    statePath: string;
    logPath: string;
}
interface TerminalStatusMonitorItem {
    status?: string;
    [field: string]: unknown;
}
interface TerminalStatusMonitorReconciliation {
    checked: number;
    launched: number;
    repaired: number;
    collateral_stalls_checked: number;
    collateral_stalls_skipped: number;
    already_running: number;
    skipped: number;
    errors: number;
    items: TerminalStatusMonitorItem[];
}
export interface TerminalStatusSelectionPorts {
    statusStoreSelection(options: TerminalStatusCliOptions): StatusStoreSelection;
    resolveTerminalConversation(options: TerminalStatusCliOptions): Promise<ResolvedTerminalConversation | undefined>;
    assertExpectedTerminalSelector(request: {
        options: TerminalStatusCliOptions;
        terminal: ResolvedTerminalConversation;
    }): void;
    loadConversation(options: TerminalStatusCliOptions): LoadedStatusConversation;
    terminalControlFromTakeover(value: unknown): TerminalControlRef | undefined;
    terminalRuntimeIdentity(conversation: Conversation, terminalControl: TerminalControlRef): TerminalRuntimeIdentity;
}
export interface TerminalStatusObservationPorts {
    readEvents(logPath: string): TranscriptEvent[];
    createCodexProvider(options: TerminalStatusCliOptions): CodingAgentSessionProvider;
    listActiveCodexSessions(options: TerminalStatusCliOptions, provider: CodingAgentSessionProvider): Promise<ActiveCodexProcess[]>;
    createTerminalBridge(options: TerminalStatusCliOptions): TerminalStatusBridgePort;
    terminalAdapter(options: TerminalStatusCliOptions, agent: ExecutorKind): {
        readonly displayName: string;
    };
}
export interface TerminalStatusBridgePort {
    status(agent: ExecutorKind, terminalControl: TerminalControlRef, options?: {
        scrollbackLines?: number;
        runtime?: TerminalRuntimeIdentity;
    }): Promise<TerminalBridgeStatus>;
}
export interface TerminalStatusReconciliationPorts {
    reconcileMonitors(options: TerminalStatusCliOptions, request: {
        includeCallbackRecovery: false;
        reason: "status_reconciliation";
        conversationId?: string;
    }): Promise<TerminalStatusMonitorReconciliation>;
    workspaceMatches(configured: unknown, observed: unknown): boolean;
    withStoreWriter<Result>(storeDir: string, operation: () => Result): Result;
    acquireStateLock(statePath: string): () => void;
    terminalBridgeEnabled(conversation: Conversation): boolean;
}
export interface TerminalStatusWatchHintAuthorityPorts {
    terminalListObservation(options: TerminalStatusCliOptions, terminalId: string): Promise<TerminalStatusListObservation | undefined>;
}
export interface TerminalStatusCliDependencies {
    selection: TerminalStatusSelectionPorts;
    observation: TerminalStatusObservationPorts;
    reconciliation: TerminalStatusReconciliationPorts;
    watchAuthority: TerminalStatusWatchHintAuthorityPorts;
    projection: TerminalStatusSummaryPorts;
}
export interface TerminalStatusIdleReconciliation {
    checked: number;
    closed: number;
    skipped: number;
    idle_timeout_minutes: number;
}
export interface TerminalStatusCliFacade {
    runStatus(options: TerminalStatusCliOptions): Promise<void>;
    reconcileIdleConversations(storeDir: string, options?: TerminalStatusCliOptions, now?: Date, conversationId?: string): TerminalStatusIdleReconciliation;
    terminalStatusForControl(agent: ExecutorKind, terminalControl: TerminalControlRef, options: TerminalStatusCliOptions, runtime?: TerminalRuntimeIdentity): Promise<TerminalBridgeStatus>;
    activeCodexProcessForPid(options: TerminalStatusCliOptions, pid: number | undefined): Promise<ActiveCodexProcess | undefined>;
    loadCodexCompletionContexts(input: {
        nativeTakeover?: Readonly<Record<string, unknown>>;
        options: TerminalStatusCliOptions;
    }): Promise<readonly CodexCompletionContextMatch[]>;
    summarizeConversation(conversation: Conversation): TerminalStatusJsonObject;
}
export interface CodexCompletionContextMatch {
    context: ForkContextPackage;
    process: ActiveCodexProcess | undefined;
    match: string;
    confidence: "high" | "medium" | "low";
}
export declare function createTerminalStatusCliFacade(dependencies: TerminalStatusCliDependencies): TerminalStatusCliFacade;
export {};