import type * as native from "@bastani/atomic-natives";
import type { AgentMessage } from "@earendil-works/pi-agent-core";
import type { AgentSessionEvent } from "../agent-session.js";
import type { SessionManager } from "../session-manager.ts";
import type { TaskCompletionSource } from "./completion-ordering.js";
import type * as C from "./contracts.js";
export type TaskTranscriptSource = Pick<SessionManager, "getSessionId" | "getEntries"> & {
    readonly completionSource?: TaskCompletionSource;
    /** Viewer-only subscription; updates never publish task lifecycle events. */
    subscribe?(listener: (event: AgentSessionEvent) => void): () => void;
    getStreamingMessage?(): AgentMessage | undefined;
};
export declare const DEFAULT_AGENT_WAIT_BUDGET_MS = 30000;
/** These objects are live authority, not DTOs, restart tokens or model arguments. */
declare class Capability {
    #private;
    toJSON(): never;
}
declare class HostCapability extends Capability {
    readonly kind = "host";
}
declare class OwnerCapability extends Capability {
    readonly kind = "owner";
}
declare class TaskCapability extends Capability {
    readonly kind = "task";
}
declare class WaitCapability extends Capability {
    readonly kind = "wait";
}
declare class SubscriptionCapability extends Capability {
    readonly kind = "subscription";
}
declare class StdinCapability extends Capability {
    readonly kind = "stdin";
}
export type StdinLease = StdinCapability;
export type HostSession = HostCapability;
export type OwnerLease = OwnerCapability;
export type TaskLease = TaskCapability;
export type WaitLease = WaitCapability;
export type SubscriptionLease = SubscriptionCapability;
export type FakeRunnerContext = {
    ref: C.NativeTaskRef;
    signal: AbortSignal;
    reportActivity(report: C.ActivityReport): C.Result<C.ReportReceipt, C.ReportError>;
    /** Bind existing child history while holding the admitted runner authority. */
    bindTranscript(session: TaskTranscriptSource): void;
};
/** Independent cleanup evidence: an outcome alone never proves resource release. */
export type FakeExecution = {
    result: Promise<C.TaskResult>;
    cleanup: Promise<C.Cleanup>;
};
export type TrustedTaskHost = {
    scope: C.OwnerScope;
    /** Owner-host observation settings; never an execution deadline. */
    tasks?: {
        wait?: C.TaskWaitConfiguration;
    };
    /** The existing host/tool refusal throws here, before native admission. */
    authorizeCommandLaunch?(intent: C.CommandIntent): void;
    authorizeLaunch(intent: C.AgentIntent): void;
    resourceAdmission?: import("../sdk-types.ts").ResourceAdmission;
    onTaskSettled?(ref: C.NativeTaskRef, receipt: C.SettlementReceipt): void;
    createRunner(context: FakeRunnerContext, intent: C.AgentIntent): FakeExecution;
};
/** Reads only history bound by the admitted runner, never a caller-selected session. */
export declare function taskTranscriptSource(task: TaskLease): C.Result<{
    session: TaskTranscriptSource;
    taskId: C.TaskId;
}, C.Failure<"UnknownTask" | "TranscriptUnavailable">>;
/** History the runner produced; a forked child's inherited parent entries are excluded. */
export declare function taskOwnTranscriptEntries(task: TaskLease): ReturnType<TaskTranscriptSource["getEntries"]> | undefined;
export declare class TaskSubscription {
    #private;
    /** Reconciliation supplements the RFC snapshot/cursor/iterable contract with the events it applied. */
    onReconcile: (snapshot: C.OwnerSnapshot, events: readonly C.NativeEvent[]) => void;
    readonly events: AsyncIterable<C.NativeEvent>;
    readonly lease: SubscriptionLease;
    constructor(actor: native.TaskSupervisor, initial: native.NativeTaskSubscription, onDispose: () => void);
    get snapshot(): C.OwnerSnapshot;
    get cursor(): C.Cursor;
    /** Consumer exceptions are observable without breaking the native wake or fallback poll. */
    get failure(): Error | undefined;
    /** Callback payloads are authentic hints; only the journal/snapshot is authoritative. */
    wake(_hint: native.NativeEvent): void;
    drain(): void;
    dispose(clear?: boolean): void;
}
export declare class TaskSupervisor {
    #private;
    bindHostSession(binding: TrustedTaskHost): HostSession;
    openTaskOwner(host: HostSession, scope: C.OwnerScope): C.Result<OwnerLease, C.OwnerError>;
    startCommandTask(owner: OwnerLease, intent: C.CommandIntent, operation: C.OperationId, signal?: AbortSignal): Promise<C.Result<TaskLease, C.StartFailure>>;
    /** Caller must hold launch authorization closed while this snapshot drains. */
    drainCommandAdmissions(owner: OwnerLease): Promise<void>;
    taskStdin(task: TaskLease): C.Result<StdinLease, C.InputError>;
    writeTaskInput(input: StdinLease, operation: C.OperationId, data: C.InputData): Promise<C.Result<C.InputReceipt, C.InputError>>;
    readTaskOutput(task: TaskLease, range: C.OutputRange): Promise<C.Result<C.OutputPage, C.OutputError>>;
    startAgentTask(owner: OwnerLease, intent: C.AgentIntent, operation: C.OperationId, schedule?: (dispatch: () => Promise<void>) => void): Promise<C.Result<TaskLease, C.StartFailure>>;
    taskReference(task: TaskLease): C.NativeTaskRef;
    waitForTask(task: TaskLease, budgetMs?: number, designation?: HostSession): Promise<C.Result<C.WaitOutcome, C.WaitError>>;
    /** Resolve only a task admitted under this live owner; IDs alone confer no authority. */
    lookupTask(owner: OwnerLease, taskId: C.TaskId): C.Result<TaskLease, C.WaitError>;
    waitForTaskId(owner: OwnerLease, taskId: C.TaskId, budgetMs?: number, onRegistered?: (wait: WaitLease) => void): Promise<C.Result<C.WaitOutcome, C.WaitError>>;
    foregroundTask(task: TaskLease, budgetMs?: number): Promise<C.Result<C.WaitOutcome, C.ForegroundError>>;
    waitId(wait: WaitLease): C.WaitId;
    findWait(id: C.WaitId): WaitLease | undefined;
    observeTaskWait(wait: WaitLease): Promise<C.Result<C.WaitOutcome, C.WaitError>>;
    yieldTaskWait(wait: WaitLease, reason: C.YieldReason): C.Result<C.WaitOutcome, C.YieldError>;
    disposeTaskWait(wait: WaitLease): C.Result<void, C.WaitError>;
    initialObservation(task: TaskLease, policy?: C.WaitPolicy, onRegistered?: (wait: WaitLease) => void): Promise<C.Result<C.WaitOutcome, C.WaitError>>;
    cancelTask(task: TaskLease, cause: C.CancelCause): Promise<C.Result<C.CancelReceipt, C.CancelError>>;
    closeTaskOwner(owner: OwnerLease, cause: C.OwnerCloseCause): Promise<C.Result<C.OwnerCloseReceipt, C.CloseError>>;
    /**
     * The bounded stream carries only authentic deltas. Overflow/native reset publishes
     * snapshot/cursor then ends the current iterator, even with no surviving delta.
     * Reconcile on completion; obtain a new iterator on the same events iterable to
     * continue observing. Apply snapshots first and ignore deltas at/below their cursor.
     * onReconcile is optional; consumer failures never disable the fallback poll.
     */
    watchOwnerTasks(owner: OwnerLease, from?: C.Cursor): C.Result<TaskSubscription, C.WatchError>;
}
export {};
//# sourceMappingURL=supervisor.d.ts.map