import { type ReinforcementState, type MemoryLearningConfig } from './patterns.js';
export declare const DEFAULT_REINFORCE_THRESHOLD = 0.95;
export type LearningBackendMode = 'native' | 'off' | 'ruvector-gnn';
export type LearningSampleKind = 'recall-hit' | 'reinforce' | 'merge';
export interface SignalCandidate {
    readonly dzId: string;
    readonly score: number;
    readonly reinforcement?: ReinforcementState | undefined;
}
export interface EnhanceContext {
    readonly kind: 'recall' | 'recommend';
    readonly now?: number;
    readonly cap?: number;
}
export interface LearningSample {
    readonly dzId: string;
    readonly kind: LearningSampleKind;
    readonly reward?: number;
    readonly ts: string;
}
export interface TrainingResult {
    readonly trained: boolean;
    readonly flushed: number;
    readonly failed: number;
    readonly error?: string;
}
export interface LearningSignalStats {
    readonly enabled: boolean;
    readonly backend: string;
    readonly samplesCollected: number;
    readonly lastTrainingTime: number | null;
    readonly flushedTotal: number;
    readonly failedTotal: number;
    readonly advisory?: string;
}
export interface LearningSignalBackend {
    enhance(candidates: readonly SignalCandidate[], ctx: EnhanceContext): Float32Array;
    addSample(sample: LearningSample): void;
    train(opts?: {
        readonly maxMs?: number;
    }): Promise<TrainingResult>;
    clearSamples(): void;
    saveModel(path: string): Promise<void>;
    loadModel(path: string): Promise<void>;
    getStats(): LearningSignalStats;
    reset(): void;
}
export declare function isLearningSignalBackend(v: unknown): v is LearningSignalBackend;
export declare class NoopLearningBackend implements LearningSignalBackend {
    enhance(candidates: readonly SignalCandidate[]): Float32Array;
    addSample(): void;
    train(): Promise<TrainingResult>;
    clearSamples(): void;
    saveModel(path: string): Promise<void>;
    loadModel(): Promise<void>;
    getStats(): LearningSignalStats;
    reset(): void;
}
export declare class NativeReinforcementBackend implements LearningSignalBackend {
    private readonly projectRoot;
    private readonly opts;
    private readonly samples;
    private flushedTotal;
    private failedTotal;
    private lastTrainingTime;
    constructor(projectRoot: string, opts?: {
        readonly usesSat: number;
        readonly halfLifeDays: number;
        readonly advisory?: string;
    });
    enhance(candidates: readonly SignalCandidate[], ctx: EnhanceContext): Float32Array;
    addSample(sample: LearningSample): void;
    train(): Promise<TrainingResult>;
    clearSamples(): void;
    saveModel(path: string): Promise<void>;
    loadModel(): Promise<void>;
    getStats(): LearningSignalStats;
    reset(): void;
    private signal;
}
export declare function resolveLearningBackend(projectRoot: string, config?: MemoryLearningConfig): LearningSignalBackend;
export declare function applyLearningSignals<H extends {
    readonly score: number;
}>(hits: readonly H[], backend: LearningSignalBackend, candidates: readonly SignalCandidate[], cap: number): H[];
/**
 * {@link applyLearningSignals} plus a bounded ± SAFLA-delta term (rUv-scout #2 Phase 3). `deltaByIndex[i]`
 * is candidate `i`'s raw payoff SLOPE (0 when it has no slope signal); each is squashed through `tanh`
 * (any slope → [-1, 1]) and applied at `deltaCap`, so a rising lesson nudges UP and a stale one DOWN
 * without a single big-slope lesson dominating the lexical/vector base rank. With `deltaByIndex` all-zero
 * this is byte-identical to {@link applyLearningSignals} (the re-rank is off by default, gated by config).
 */
export declare function applyLearningSignalsWithDelta<H extends {
    readonly score: number;
}>(hits: readonly H[], backend: LearningSignalBackend, candidates: readonly SignalCandidate[], cap: number, deltaByIndex: readonly number[], deltaCap: number): H[];
//# sourceMappingURL=learning-backend.d.ts.map