import type { AgentContextOutcomeStatus, AgentExperienceEvent, AgentLearningDelta } from './types.js';
import type { AgentExperienceCaptureResult } from './experience-journal.js';
import { AgentExperienceJournal } from './experience-journal.js';
export interface AgentReflectionRequest {
    readonly episodeId: string;
    readonly events: readonly AgentExperienceEvent[];
    readonly evidenceOffset: number;
    readonly evidenceCount: number;
}
export interface AgentLearningAdapter {
    readonly owner: string;
    supports(event: AgentExperienceEvent): boolean;
    reflect(request: AgentReflectionRequest): Promise<AgentReflectionOutput>;
    /** Domain Providers consolidate one Reflection batch behind stable semantic keys. */
    consolidate(request: AgentLearningConsolidationRequest): Promise<void>;
}
export interface AgentReflectionResult {
    readonly deltas: readonly AgentLearningDelta[];
    /** Deterministic deltas may be consolidated while semantic work remains replayable. */
    readonly deferred: boolean;
}
export type AgentReflectionOutput = readonly AgentLearningDelta[] | AgentReflectionResult;
export interface AgentLearningConsolidationDelta {
    readonly delta: AgentLearningDelta;
    readonly idempotencyKey: string;
}
export interface AgentLearningConsolidationRequest {
    readonly episodeId: string;
    readonly eventIds: readonly string[];
    readonly deltas: readonly AgentLearningConsolidationDelta[];
}
export interface AgentLearningCoordinatorOptions {
    readonly journal: AgentExperienceJournal;
    readonly learners: readonly AgentLearningAdapter[] | ((event: AgentExperienceEvent) => readonly AgentLearningAdapter[] | Promise<readonly AgentLearningAdapter[]>);
    readonly schedule?: (task: () => Promise<void>) => void | Promise<void>;
    readonly maxEventsPerReflection?: number;
    readonly maxEvidencePerReflection?: number;
    readonly onDiagnostic?: (message: string) => void;
}
export interface AgentLearningCaptureResult extends AgentExperienceCaptureResult {
    readonly reflectedSynchronously: boolean;
    readonly deltas: readonly AgentLearningDelta[];
}
export declare class AgentLearningCoordinator {
    private readonly journal;
    private readonly learners;
    private readonly schedule;
    private readonly maxEvents;
    private readonly maxEvidence;
    private readonly onDiagnostic?;
    private readonly episodeQueues;
    private readonly scheduledEventIds;
    constructor(options: AgentLearningCoordinatorOptions);
    capture(event: AgentExperienceEvent): Promise<AgentLearningCaptureResult>;
    replayPending(limit?: number): Promise<void>;
    feedback(options: {
        readonly episodeId: string;
        readonly projectId?: string;
        readonly applicationId: string;
        readonly unitIds: readonly string[];
        readonly status: AgentContextOutcomeStatus;
        readonly summary?: string;
        readonly occurredAt?: string;
    }): Promise<AgentLearningCaptureResult>;
    private processEpisode;
    private processAndRecord;
}
export declare function chunkReflectionRequests(episodeId: string, events: readonly AgentExperienceEvent[], maxEvents?: number, maxEvidence?: number): AgentReflectionRequest[];
/** Return the evidence slice represented by one Reflection request. */
export declare function reflectionEvents(request: AgentReflectionRequest): AgentExperienceEvent[];
//# sourceMappingURL=coordinator.d.ts.map