/** Internal, provider-neutral contract for hosts embedding Sortie-dogs. */
export declare const HOST_CONFORMANCE_VERSION: "sortie-host-conformance/v1";
export type SessionIdentity = Readonly<{
    sessionID: string;
    agent?: string;
    parentID?: string;
    parentPresent: boolean;
}>;
export type ToolIdentity = Readonly<{
    sessionID: string;
    callID: string;
}>;
export type WorkerIdentity = Readonly<{
    parentSessionID: string;
    callID: string;
    childSessionID: string;
}>;
export type CompletionIdentity = Readonly<{
    sessionID: string;
    messageID: string;
    partID?: string;
}>;
export type ModelIdentity = Readonly<{
    providerID: string;
    modelID: string;
}>;
export declare function sessionIdentity(sessionID: string, details: Readonly<{
    agent?: string;
    parentID?: string;
    parentPresent: boolean;
}>): SessionIdentity;
export declare function toolIdentity(sessionID: string, callID: string): ToolIdentity;
export declare function workerIdentity(parentSessionID: string, callID: string, childSessionID: string): WorkerIdentity;
export declare function completionIdentity(sessionID: string, messageID: string, partID?: string): CompletionIdentity;
export declare function modelIdentity(providerID: string, modelID: string): ModelIdentity;
export type ReplayDisposition = "first" | "exact-replay" | "conflict";
export type AllowDeny = Readonly<{
    decision: "allow";
}> | Readonly<{
    decision: "deny";
    reason: string;
}>;
export type ModelAvailability = Readonly<{
    available: boolean;
    identity: ModelIdentity;
}>;
export interface ToolPort {
    invoke(identity: ToolIdentity, payload: string): Promise<AllowDeny>;
}
export interface SessionPort {
    identity(sessionID: string): Promise<SessionIdentity | undefined>;
    complete(identity: CompletionIdentity, payload: string): Promise<ReplayDisposition>;
}
export interface WorkerPort {
    complete(identity: WorkerIdentity, payload: string): Promise<ReplayDisposition>;
}
export interface ContinuationPort {
    resume(sessionID: string, parentSessionID?: string): Promise<AllowDeny>;
}
export interface ModelPort {
    inspect(identity: ModelIdentity): Promise<ModelAvailability>;
}
export interface HostCapabilityDeclaration {
    readonly version: typeof HOST_CONFORMANCE_VERSION;
    readonly tools: readonly string[];
    readonly ports: Readonly<Record<"tool" | "session" | "worker" | "continuation" | "model", boolean>>;
    readonly identities: Readonly<Record<"session" | "tool" | "worker" | "completion" | "model", string>>;
    readonly replay: Readonly<Record<"exact" | "conflict", string>>;
    readonly continuation: Readonly<Record<"rootOnly" | "sameRoot", boolean>>;
}
export interface HostConformanceSubject {
    readonly capabilities: HostCapabilityDeclaration;
    readonly tool: ToolPort;
    readonly session: SessionPort;
    readonly worker: WorkerPort;
    readonly continuation: ContinuationPort;
    readonly model: ModelPort;
}
export type HostConformanceSubjectFactory = () => HostConformanceSubject | Promise<HostConformanceSubject>;
export declare const HOST_CAPABILITIES: HostCapabilityDeclaration;
export declare const ALLOW_FIXTURE: Readonly<{
    tool: ToolIdentity;
    payload: string;
    decision: "allow";
}>;
export declare const DENY_FIXTURE: Readonly<{
    tool: ToolIdentity;
    payload: string;
    decision: "deny";
    reason: string;
}>;
export declare const COMPLETION_FIXTURE: Readonly<{
    root: Readonly<{
        sessionID: string;
        agent?: string;
        parentID?: string;
        parentPresent: boolean;
    }>;
    child: Readonly<{
        sessionID: string;
        agent?: string;
        parentID?: string;
        parentPresent: boolean;
    }>;
    session: Readonly<{
        identity: Readonly<{
            sessionID: string;
            messageID: string;
            partID?: string;
        }>;
        payload: "completed";
    }>;
    part: Readonly<{
        identity: Readonly<{
            sessionID: string;
            messageID: string;
            partID?: string;
        }>;
        payload: "completed-part";
    }>;
    worker: Readonly<{
        identity: Readonly<{
            parentSessionID: string;
            callID: string;
            childSessionID: string;
        }>;
        payload: "worker-completed";
    }>;
}>;
export declare function replayDisposition(previous: string | undefined, next: string): ReplayDisposition;
export declare function allow(): AllowDeny;
export declare function deny(reason: string): AllowDeny;