import { type PersistOptions } from "./review-persist";
import type { PrData, PrResult } from "./review-pr";
declare const AXES: readonly ["standards", "spec"];
declare const LABELS: readonly ["blocker", "critical", "major", "minor", "nitpick", "praise", "thought", "note"];
declare const ORIGINS: readonly ["pr-code", "review-fix"];
type Axis = typeof AXES[number];
type Label = typeof LABELS[number];
type Origin = typeof ORIGINS[number];
export type LabelCounts = Record<Label, number>;
export type VerdictCounts = Record<Axis, LabelCounts> & {
    total: LabelCounts;
    actionable_total: number;
    by_origin: Record<Origin, Record<Axis, LabelCounts> & {
        total: LabelCounts;
    }>;
};
export type VerdictInput = {
    reviewRoot: string;
    headSha?: string;
    code_head?: string;
    owner?: string;
    name?: string;
    pr?: number | null;
    branch?: string;
    legacy_root?: string;
    priorReviews: PrResult<PrData["reviews"]>;
    config: {
        max_nits?: number;
        max_minors?: number;
        [key: string]: unknown;
    };
    forceDelta?: boolean;
};
export type VerdictOptions = PersistOptions & {
    fs?: PersistOptions["fs"] & {
        readdirSync(path: string): string[];
    };
};
export type HistoryVerdict = {
    ok: true;
    round: number;
    refuse_delta: boolean;
    refuse_reason?: string;
    missing_history: boolean;
};
export type DocumentVerdict = HistoryVerdict & {
    counts: VerdictCounts;
    caps_applied: {
        max_nits: number;
        max_minors: number;
        totals: {
            minor: number;
            nitpick: number;
        };
    };
    converged: boolean;
    convergence_reason?: string;
};
export type VerdictResult = HistoryVerdict | (DocumentVerdict & {
    persisted: string;
}) | {
    ok: false;
    reason: string;
};
/**
 * Policy: skill/corvus-review-extras/SKILL.md#convergence-and-continuation.
 * Identity-matching persisted documents/metadata, series knowledge and the complete
 * PR reviews result are the history oracle, read before any verdict write;
 * history-only calls never mutate state. Counts use retained unsuppressed findings,
 * not projection copies or model totals. Missing/contradictory history closes
 * convergence and delta admission; invalid current evidence returns an error.
 * Only the trusted invocation's forceDelta argument disables delta refusal, not
 * coverage, validation or posting rails. Config/prose cannot supply that override.
 * Local roots use the same persisted-history checks with a schema-empty complete
 * prior-review result instead of GitHub history; absent local history starts at
 * round 1. Missing/incomplete remote-shaped input still closes admission.
 * A metadata verdict_file pointer selects the tool-owned round; legacy metadata
 * supplies series_round only without that pointer. A broken pointer closes history
 * admission rather than falling back. Head computations persist their exact result
 * plus computed_at through the contained writer before success; write/readback
 * failure returns an error, never a successful unpersisted verdict.
 */
export declare function compute(input: VerdictInput, opts: VerdictOptions): VerdictResult;
/** Host-only root/filesystem options are captured before calls; unlisted operations reject without I/O. */
export declare function createVerdictExecutor(reviewStateRoot: string, options?: Omit<VerdictOptions, "reviewStateRoot">): (input: unknown) => string;
export {};
//# sourceMappingURL=review-verdict.d.ts.map