import type { Pool } from "pg";
import type { CandidateMemory, ConsolidationPipeline } from "./observation.js";
import type { MemoryProvider } from "./types.js";
export interface DeterministicConsolidationOptions {
    batchSize?: number;
    nearDuplicateSimilarity?: number;
}
/**
 * Consolidates only explicit candidate data. Memory bodies remain inert text and are never executed.
 */
export declare class DeterministicConsolidationPipeline implements ConsolidationPipeline {
    private readonly provider;
    private readonly batchSize;
    private readonly nearDuplicateSimilarity;
    constructor(provider: MemoryProvider, options?: DeterministicConsolidationOptions);
    consolidate(candidates: CandidateMemory[], signal?: AbortSignal): Promise<CandidateMemory[]>;
    private consolidateCandidate;
}
export interface ConsolidationRun {
    id: string;
    status: "completed" | "failed";
    candidates: number;
    promoted: number;
    outputMemoryIds: string[];
    errors: string[];
}
/**
 * PostgreSQL-backed batch runner. A stale started run is returned to approved before each new claim.
 */
export declare class PostgresConsolidationRunner {
    private readonly pool;
    private readonly pipeline;
    private readonly batchSize;
    private readonly recoveryAfterMs;
    private readonly providerId?;
    constructor(pool: Pool, pipeline: ConsolidationPipeline, batchSize?: number, recoveryAfterMs?: number, providerId?: string | undefined);
    run(signal?: AbortSignal): Promise<ConsolidationRun>;
    private recoverInterruptedRuns;
    private claimCandidates;
    private complete;
    private fail;
}