Durable delivery

/** Queue delivery is a hint; Mongo/another atomic task store owns authoritative state.
 * Persistence precedes enqueue. If Redis fails, call wake() after retrying admission.
 * The stable task key prevents a delivery retry from creating a second execution.
 */
export declare class DurableAgentQueue {
    constructor(config: DurableQueueConfig);
    enqueue(task: DurableTaskInput): Promise<{
        taskId: string;
        deliveryId: string;
    }>;
    /** Explicit re-delivery after approval, reconciliation, or a failed initial enqueue. */
    wake(key: DurableTaskKey): Promise<{
        taskId: string;
        deliveryId: string;
    }>;
    cancel(key: DurableTaskKey, reason?: string): Promise<void>;
    close(): Promise<void>;
}

export declare class DurableAgentWorker {
    constructor(config: DurableWorkerConfig);
    /** Drains owned work. Active durable cancellation is explicit through queue.cancel(). */
    stop(): Promise<void>;
}

export interface DurableDriverRegistration {
    id: string;
    version: number;
    /** Explicit host assertion: resumes use stable action IDs and reconcile uncertain effects. */
    recoverable: true;
    execute: DurableTaskHandler;
}

export interface DurableJobEnvelope {
    schemaVersion: 1;
    type: "durable";
    tenantId: string;
    taskId: string;
    inputDigest: string;
}

export interface DurableQueueConfig extends QueueConfig {
    supervisor: DurableTaskSupervisor;
    /** Verify identity, definition, policy and grants before writing any task/queue record. */
    admit: (task: Readonly<DurableTaskInput>) => Promise<void>;
}

export interface DurableWorkerConfig extends Omit<QueueConfig, "defaultJobOptions"> {
    supervisor: DurableTaskSupervisor;
    workerId?: string;
    concurrency?: number;
    drivers: readonly DurableDriverRegistration[];
    /** Revalidate policy/grants from authoritative host state; a payload is not authentication. */
    admit: (task: Readonly<DurableTaskRecord>) => Promise<void>;
    /** Observe delivery failures; durable task outcome remains available from the store. */
    onError?: (error: Error) => void;
}