import type { ExecutorKind } from "./executors.js";
import { type ManagedSessionState, type NativeThreadTransition } from "./managed-session.js";
import { type NativeThreadLifecycleRecoveryAuthority } from "./native-thread-lifecycle-recovery-service.js";
import { type NativeThreadVerificationAdapterPorts } from "./native-thread-transition-verification-adapter.js";
import type { TerminalControlRef, TerminalRuntimeIdentity } from "./terminal-agent-adapter.js";
import { type ResolvedTerminalConversation, type TerminalBridgeStatus } from "./terminal-agent-bridge.js";
import type { TerminalDispatchTerminal } from "./terminal-dispatch-composition.js";
import { type CodexAllowedCompanionSet, type ManagedBindingConflictKind } from "./terminal-authority-policy.js";
import type { TerminalNativeIdentity as NativeAgentSessionIdentity } from "./terminal-binding-authority.js";
import { type TerminalDispatchLedgerDocument } from "./terminal-dispatch-ledger-codec.js";
import type { NativeThreadLifecycleLedgerCliAdapter } from "./native-thread-lifecycle-ledger-cli-adapter.js";
import type { NativeThreadLifecycleCliFacade } from "./native-thread-lifecycle-cli-adapter.js";
import type { TerminalRuntimeCliAdapter } from "./terminal-runtime-cli-adapter.js";
import { type BindingReconciliationStatusFacts, type BindingReconciliationTerminalFacts } from "./terminal-binding-reconciliation-service.js";
import { type CanonicalMutationLockPorts, type CanonicalMutationResources, type CanonicalMutationScopes } from "./mutation-transaction.js";
import { type Conversation } from "./protocol.js";
export type NativeThreadTransitionCliOptions = Readonly<Record<string, unknown>>;
type Scoped<Args extends unknown[], Result> = (scopes: CanonicalMutationScopes, resources: CanonicalMutationResources, ...args: Args) => Result;
export interface NativeThreadTransitionRuntimePorts {
    now(): Date;
    nowMs(): number;
    pid(): number;
    cwd(): string;
    sleep(milliseconds: number): Promise<void>;
    env(name: string): string | undefined;
    exit(code: number): void;
    log(level: "info" | "warn" | "error", event: string, details: Record<string, unknown>): void;
    print(value: unknown): void;
    summarizeError(error: unknown): Readonly<{
        length: number;
        preview?: string;
    }>;
}
export interface NativeThreadTransitionLifecyclePorts {
    facade: Pick<NativeThreadLifecycleCliFacade, "resolveLifecycleTerminal" | "queryPorts" | "assertExclusive" | "currentSnapshot" | "lifecycleBindingTokens" | "agentAdapter" | "assertSameInspectionTerminal">;
    runtime(options: NativeThreadTransitionCliOptions): TerminalRuntimeCliAdapter;
    resolveIdentity(input: {
        options: NativeThreadTransitionCliOptions;
        agent: ExecutorKind;
        pid: number;
        cwd?: string;
        preferredSessionId?: string;
        allowedCompanionIdentity?: CodexAllowedCompanionSet["primary"];
        allowedAdditionalIdentities?: readonly NonNullable<CodexAllowedCompanionSet["primary"]>[];
    }): Promise<NativeAgentSessionIdentity | undefined>;
    runtimeForIdentity(input: {
        terminal: ResolvedTerminalConversation;
        identity?: NativeAgentSessionIdentity;
        expectedEmptyNativeSession?: boolean;
        physicalOnly?: boolean;
    }): TerminalRuntimeIdentity;
    exactIdentity(terminal: ResolvedTerminalConversation, identity: NativeAgentSessionIdentity): NativeAgentSessionIdentity;
    assertComposerReady(input: {
        options: NativeThreadTransitionCliOptions;
        terminalControl: TerminalControlRef;
    }): Promise<void>;
}
export interface NativeThreadTransitionStatePorts {
    storeDir(options: NativeThreadTransitionCliOptions): string;
    runtimeDir(): string;
    loadLedger(terminalControl: TerminalControlRef): TerminalDispatchLedgerDocument | undefined;
    reconcilePrepared(terminalControl: TerminalControlRef, ledger?: TerminalDispatchLedgerDocument): TerminalDispatchLedgerDocument | undefined;
    reconcileIncarnation(terminalControl: TerminalControlRef, ledger?: TerminalDispatchLedgerDocument): TerminalDispatchLedgerDocument | undefined;
    recordMatchesControl(ledger: TerminalDispatchLedgerDocument | undefined, terminalControl: TerminalControlRef): boolean;
    lifecycleLedger: NativeThreadLifecycleLedgerCliAdapter;
    ordinaryOwnerStatus(ledger: TerminalDispatchLedgerDocument): Conversation["status"] | undefined;
    blockingTurns(storeDir: string, terminalControl: TerminalControlRef): readonly Conversation[];
    managedTurns(storeDir: string, sessionId: string): readonly Conversation[];
    hasUnresolvedTransition(storeDir: string, session: ManagedSessionState): boolean;
    dispatchOwnership(terminalControl: TerminalControlRef): {
        state: string;
    };
}
export interface NativeThreadTransitionAuthorityPorts {
    sessionClaimsTerminal(session: ManagedSessionState, terminal: BindingReconciliationTerminalFacts): boolean;
    conflictKind(input: {
        storeDir: string;
        session: ManagedSessionState;
        terminal: ResolvedTerminalConversation;
        identity?: NativeAgentSessionIdentity;
    }): ManagedBindingConflictKind | undefined;
    ownerIsInactive(input: {
        session: ManagedSessionState;
        terminal: Pick<ResolvedTerminalConversation, "agent" | "pid">;
        identity?: NativeAgentSessionIdentity;
    }): boolean;
    observeExternal(input: {
        options: NativeThreadTransitionCliOptions;
        terminal: ResolvedTerminalConversation;
        sourceSession: ManagedSessionState;
        resolvedIdentity?: NativeAgentSessionIdentity;
    }): Promise<{
        identity?: NativeAgentSessionIdentity;
        status: TerminalBridgeStatus;
    }>;
    recoverDeferred(input: {
        options: NativeThreadTransitionCliOptions;
        terminal: ResolvedTerminalConversation;
        storeDir: string;
        scopes: CanonicalMutationScopes;
        resources: CanonicalMutationResources;
    }): Promise<void>;
    knownRoots(input: {
        storeDir: string;
        terminal: ResolvedTerminalConversation;
        transition: NativeThreadTransition;
    }): CodexAllowedCompanionSet;
    codexProcessBirth(pid: number): string;
    processAlive(pid: number): boolean;
    workspaceMatches(configured: unknown, observed: unknown): boolean;
}
export interface NativeThreadTransitionMutationPorts {
    locks(storeDir: string, terminalControl: TerminalControlRef): CanonicalMutationLockPorts;
    authenticate(scopes: CanonicalMutationScopes, resources: CanonicalMutationResources): Readonly<{
        terminalControl: TerminalControlRef;
        storeDir: string;
    }>;
    loadSession: Scoped<[string], ManagedSessionState>;
    saveSession: Scoped<[
        ManagedSessionState,
        Readonly<{
            expectedRevision: number;
        }>
    ], ManagedSessionState>;
}
export interface CreateNativeThreadTransitionApplicationInput {
    runtime: NativeThreadTransitionRuntimePorts;
    lifecycle: NativeThreadTransitionLifecyclePorts;
    state: NativeThreadTransitionStatePorts;
    authority: NativeThreadTransitionAuthorityPorts;
    mutation: NativeThreadTransitionMutationPorts;
}
export interface NativeThreadTransitionApplication {
    runNewThread(options: NativeThreadTransitionCliOptions): Promise<void>;
    runResumeThread(options: NativeThreadTransitionCliOptions): Promise<void>;
    runReconcileBinding(options: NativeThreadTransitionCliOptions): Promise<void>;
    verificationPorts(options: NativeThreadTransitionCliOptions, terminal: ResolvedTerminalConversation): NativeThreadVerificationAdapterPorts;
    assertTerminalReady(input: {
        options: NativeThreadTransitionCliOptions;
        terminal: TerminalDispatchTerminal;
        terminalStatus: BindingReconciliationStatusFacts;
    }): void;
    recoverBeforeMutation(scopes: CanonicalMutationScopes, resources: CanonicalMutationResources, options: NativeThreadTransitionCliOptions, capturedTerminal: ResolvedTerminalConversation): Promise<void>;
    reconcileLedger(scopes: CanonicalMutationScopes, resources: CanonicalMutationResources, options: NativeThreadTransitionCliOptions, capturedTerminal: ResolvedTerminalConversation, ledger: TerminalDispatchLedgerDocument, authority?: NativeThreadLifecycleRecoveryAuthority): Promise<TerminalDispatchLedgerDocument>;
}
export declare function createNativeThreadTransitionApplication(ports: CreateNativeThreadTransitionApplicationInput): NativeThreadTransitionApplication;
export {};