import { type ProcessJobErrorCode, type ProcessJobProjection, type ProcessJobState } from "@mono-agent/agent-contracts";
import type { ProcessJobsController } from "@mono-agent/runtime-adapter";
import type { NotifyDeliveryResult } from "./channels.js";
import { type ProcessJobsSettings } from "./process-jobs-config.js";
import { type OwnerPrivateLock } from "./owner-private-lock.js";
import { attestProcessJobsRootRegistration, type ProcessJobsRootRegistrationProof } from "./process-jobs-root-registry.js";
import { isSameProcessIncarnation, readProcessIncarnation, type ProcessIncarnation } from "./process-incarnation.js";
import { type ProcessJobOriginRecord, type ProcessJobStore } from "./process-jobs-store.js";
export interface ProcessJobsHealth {
    readonly state: "ok" | "degraded";
    readonly quarantinedTransactions: number;
    readonly failureOperation?: string;
    readonly failureDetectedAt?: string;
}
export interface ProcessJobWakeInput {
    readonly projection: ProcessJobProjection;
    readonly prompt: string;
    readonly conversationId: string;
    readonly channel: ProcessJobOriginRecord["channel"];
    readonly deliveryKey: string;
    readonly chainDepth: number;
}
export interface OpenProcessJobsServiceOptions {
    readonly cwd: string;
    readonly workspace: string;
    readonly settings: ProcessJobsSettings;
    /** Durable registration proof which must predate all state-root creation/mutation. */
    readonly registration: ProcessJobsRootRegistrationProof;
    /** Deterministic unit-test seam; production always re-attests the durable proof. */
    readonly attestRegistration?: typeof attestProcessJobsRootRegistration;
    readonly wake: (input: ProcessJobWakeInput) => Promise<NotifyDeliveryResult>;
    /** Best-effort retained lifecycle update for the exact originating surface. */
    readonly surfaceUpdate?: (projection: ProcessJobProjection) => Promise<void>;
    readonly onHealthChange?: (health: ProcessJobsHealth) => void | Promise<void>;
    readonly logger?: {
        info?(message: string, details?: Readonly<Record<string, unknown>>): void;
        warn?(message: string, details?: Readonly<Record<string, unknown>>): void;
    };
    readonly now?: () => Date;
    readonly platform?: NodeJS.Platform;
    readonly randomId?: () => string;
    readonly currentIncarnation?: () => Promise<ProcessIncarnation>;
    readonly readIncarnation?: typeof readProcessIncarnation;
    readonly sameIncarnation?: typeof isSameProcessIncarnation;
    readonly signalProcess?: (pid: number, signal: NodeJS.Signals) => void;
    readonly processGroupExists?: (pgid: number) => boolean;
    readonly sleep?: (milliseconds: number) => Promise<void>;
    readonly wakeBusyRearmMs?: number;
    readonly acquireLock?: () => Promise<OwnerPrivateLock | undefined>;
    readonly store?: ProcessJobStore;
}
export interface ProcessJobsServiceHandle {
    readonly settings: ProcessJobsSettings;
    readonly operatorToken: string;
    readonly health: ProcessJobsHealth;
    controller(origin: ProcessJobOriginRecord, chainDepth: number | (() => number)): ProcessJobsController;
    list(): Promise<readonly ProcessJobProjection[]>;
    get(jobId: string): Promise<ProcessJobProjection | undefined>;
    cancel(jobId: string): Promise<ProcessJobProjection>;
    counts(): Promise<Readonly<Record<ProcessJobState, number>>>;
    activateWakes(): Promise<void>;
    stop(): Promise<void>;
}
export declare class ProcessJobServiceError extends Error {
    readonly code: ProcessJobErrorCode;
    constructor(code: ProcessJobErrorCode, _message?: string);
}
/** Acquire exclusive ownership, recover interrupted work, and expose one host controller. */
export declare function openProcessJobsService(options: OpenProcessJobsServiceOptions): Promise<ProcessJobsServiceHandle>;
//# sourceMappingURL=process-jobs-service.d.ts.map