import { z } from 'zod';
import type { ResidentAgendaState } from './agenda.js';
export declare const residentObservationSchema: z.ZodObject<{
    evidenceKey: z.ZodString;
    source: z.ZodString;
    progress: z.ZodNumber;
    /** All observations and policy costs use the same host-defined resource unit. */
    costUnits: z.ZodNullable<z.ZodNumber>;
}, "strip", z.ZodTypeAny, {
    source: string;
    evidenceKey: string;
    progress: number;
    costUnits: number | null;
}, {
    source: string;
    evidenceKey: string;
    progress: number;
    costUnits: number | null;
}>;
/** @experimental Host-validated outcome and measured resource use, never model self-confidence. */
export type ResidentObservation = Readonly<z.infer<typeof residentObservationSchema>>;
export declare const residentFeedbackSchema: z.ZodObject<{
    bestProgress: z.ZodNumber;
    hasUnobservedSteps: z.ZodDefault<z.ZodBoolean>;
    stagnantSteps: z.ZodNumber;
    observations: z.ZodArray<z.ZodObject<{
        evidenceKey: z.ZodString;
        source: z.ZodString;
        progress: z.ZodNumber;
        /** All observations and policy costs use the same host-defined resource unit. */
        costUnits: z.ZodNullable<z.ZodNumber>;
    } & {
        gain: z.ZodNumber;
        step: z.ZodNumber;
    }, "strip", z.ZodTypeAny, {
        source: string;
        evidenceKey: string;
        progress: number;
        costUnits: number | null;
        gain: number;
        step: number;
    }, {
        source: string;
        evidenceKey: string;
        progress: number;
        costUnits: number | null;
        gain: number;
        step: number;
    }>, "many">;
}, "strip", z.ZodTypeAny, {
    observations: {
        source: string;
        evidenceKey: string;
        progress: number;
        costUnits: number | null;
        gain: number;
        step: number;
    }[];
    bestProgress: number;
    hasUnobservedSteps: boolean;
    stagnantSteps: number;
}, {
    observations: {
        source: string;
        evidenceKey: string;
        progress: number;
        costUnits: number | null;
        gain: number;
        step: number;
    }[];
    bestProgress: number;
    stagnantSteps: number;
    hasUnobservedSteps?: boolean | undefined;
}>;
/** @experimental Last eight observations; best progress and stagnation survive eviction. */
export type ResidentFeedback = Readonly<Omit<z.infer<typeof residentFeedbackSchema>, 'observations'>> & {
    readonly observations: readonly Readonly<z.infer<typeof residentFeedbackSchema>['observations'][number]>[];
};
export declare function observeResidentStep(previous: ResidentFeedback | undefined, input: ResidentObservation, step: number): ResidentFeedback;
export declare function freezeResidentFeedback(value: ResidentFeedback): ResidentFeedback;
/** @experimental Policy units are chosen by the host; scores are heuristics, not probabilities. */
export interface ResidentSelectionConfig {
    readonly progressValue: number;
    readonly initialExpectedProgress: number;
    readonly initialExpectedCost: number;
    readonly maxStagnantSteps?: number;
}
/** @experimental Explainable inputs for a single selection; unknown cost is not zero. */
export interface ResidentCandidate {
    readonly pursuitId: string;
    readonly reason: 'eligible' | 'not-due' | 'missing-observation' | 'stalled' | 'unknown-cost' | 'nonpositive-value';
    readonly expectedGain: number | null;
    readonly expectedCost: number | null;
    readonly score: number | null;
}
/** @experimental Choice is bound to the whole agenda revision used to compute it. */
export interface ResidentSelection {
    readonly agendaRevision: number;
    readonly pursuitId: string | null;
    readonly reason: 'selected' | 'paused' | 'unresolved' | 'no-useful-work';
    readonly candidates: readonly ResidentCandidate[];
}
/** @experimental Pure local selection; perform inference inside budgeted steps, not here. */
export type ResidentSelector = (agenda: ResidentAgendaState, now: number) => ResidentSelection;
/**
 * @experimental Cost-aware continuation with an explicit abstention choice.
 * This is a measured-progress heuristic, not Bayesian value of computation.
 * A finite bootstrap allowance permits delayed payoffs but may stop too early.
 */
export declare function createResidentSelector(config: ResidentSelectionConfig): ResidentSelector;
//# sourceMappingURL=initiative.d.ts.map