export declare const ATTEMPT_COMPARISON_SCHEMA = "open-scaffold.attempt-comparison.v1";
type AttemptFileName = 'diff.patch' | 'rationale.txt' | 'transcript.md' | 'ac-status.json';
export interface AttemptCriterionStatus {
    id: string;
    text: string;
    status: string | null;
}
type AttemptFileState = {
    present: boolean;
    bytes: number;
};
export interface BareAttemptSummary {
    name: string;
    path: string;
    files: Record<AttemptFileName, AttemptFileState>;
    diff: {
        present: boolean;
        changedFiles: string[];
        additions: number;
        deletions: number;
    };
    rationale: {
        present: boolean;
        text: string;
    };
    transcript: AttemptFileState;
    acStatus: {
        present: boolean;
        score: number | null;
        scoreLabel: string | null;
        criteria: AttemptCriterionStatus[];
    };
    warnings: string[];
}
export interface AttemptCriterionDelta {
    id: string;
    text: string;
    aStatus: string | null;
    bStatus: string | null;
}
export interface BareAttemptComparison {
    schema: typeof ATTEMPT_COMPARISON_SCHEMA;
    attempts: {
        a: BareAttemptSummary;
        b: BareAttemptSummary;
    };
    summary: {
        changedFiles: string[];
        additionsDelta: number;
        deletionsDelta: number;
        scoreDelta: number | null;
    };
    diff: {
        changedFiles: string[];
        onlyInA: string[];
        onlyInB: string[];
        inBoth: string[];
    };
    acceptanceCriteria: {
        rows: AttemptCriterionDelta[];
        aPresent: boolean;
        bPresent: boolean;
    };
    warnings: string[];
    boundary: {
        runtimeSpawning: false;
        automaticScoring: false;
        modelBenchmarking: false;
        frontierPromotion: false;
    };
}
export declare function compareBareAttempts(attemptAPath: string, attemptBPath: string): BareAttemptComparison;
export declare function renderAttemptComparisonMarkdown(comparison: BareAttemptComparison): string;
export declare function renderAttemptComparisonJson(comparison: BareAttemptComparison): string;
export declare const PROOF_COMPARISON_SCHEMA = "open-scaffold.proof-comparison.v1", PROOF_COMPARISON_RESULT_SCHEMA = "open-scaffold.proof-comparison-result.v1";
export type ProofRenderFormat = 'terminal' | 'markdown' | 'json';
type ProofCategory = 'quality' | 'tokens' | 'speed' | 'evolution';
type ProofDirection = 'higher' | 'lower';
type ProofWinner = 'scaffolded' | 'control' | 'tie';
type ProofRatio = number | 'unbounded' | null;
type ProofEvidenceKind = 'cold_resume_fixture' | 'cold_resume_packet' | 'human_reviewer_replication' | 'controlled_ablation' | 'legacy_fixture' | 'reviewability_fixture' | 'other';
type ProofEvidenceStatus = 'demonstrated' | 'reproduced' | 'partially_reproduced' | 'not_reproduced' | 'not_demonstrated' | 'mixed_not_proven' | 'blocked';
type ProofIssue = {
    level: 'fail' | 'warn';
    code: string;
    message: string;
    path?: string;
};
type ProofValidationResult = {
    failures: ProofIssue[];
    warnings: ProofIssue[];
};
type ProofEvidenceItem = {
    id: string;
    kind: ProofEvidenceKind;
    status: ProofEvidenceStatus;
    requiredForPass: boolean;
    claim: string;
    boundary: string;
    sourceRefs: string[];
    notes?: string | null;
};
export declare function validateProofManifestFile(pathArg: string): ProofValidationResult;
export declare function compareProofManifest(pathArg: string): {
    schema: string;
    comparisonId: string;
    title: string;
    question: string;
    arms: {
        control: {
            id: string;
            label: string;
            runtime: string | null;
        };
        scaffolded: {
            id: string;
            label: string;
            runtime: string | null;
        };
    };
    metrics: {
        winner: ProofWinner;
        delta: number;
        improvementRatio: ProofRatio;
        minimumRatio: number | null;
        minimumRatioActual: ProofRatio;
        minimumRatioPassed: boolean | null;
        sourceRefs: string[];
        id: string;
        label: string;
        category: ProofCategory;
        unit: string;
        direction: ProofDirection;
        control: number;
        scaffolded: number;
        source_refs: string[];
        notes?: string | null;
        minimum_ratio?: number | null;
    }[];
    evidenceBattery: ProofEvidenceItem[];
    summary: {
        scaffoldedWins: number;
        controlWins: number;
        ties: number;
        categories: Record<ProofCategory, "missing" | "regressed" | "improved" | "tied">;
        thresholdsPass: boolean;
        thresholdViolations: {
            metricId: string;
            required: number | null;
            actual: ProofRatio;
        }[];
        evidenceBatteryPresent: boolean;
        evidenceBatteryRequired: string[];
        evidenceBatteryPass: boolean | null;
        evidenceBatteryStatus: "fail" | "pass" | "not_evaluated";
        evidenceBatteryBlocking: string[];
        boundedProof: boolean;
        verdict: string;
    };
    caveats: string[];
    validation: ProofValidationResult;
};
export declare function renderProofComparison(result: ReturnType<typeof compareProofManifest>, format?: ProofRenderFormat): string;
export {};