interface HarnessRuntimeReceipt {
    status: 'completed' | 'needs_human' | 'failed' | 'blocked' | 'dry_run';
    spawned: boolean;
    exit: {
        status: number | null;
        signal: string | null;
        timedOut: boolean;
    };
    marker: {
        state: string;
        context?: string;
    };
    failure: {
        code?: string | null;
    };
    evidencePaths: Array<{
        role: string;
        path: string;
        schema?: string;
    }>;
    tokenUsage?: {
        totalTokens: number;
        promptTokens?: number | null;
        completionTokens?: number | null;
    } | null;
}
export declare const BENCH_SUITE_SCHEMA = "osc.bench-suite-aggregate.v1";
export declare const HANDOFF_LAB_SCHEMA = "osc.handoff-lab-aggregate.v1";
type BenchMode = 'simulated' | 'live';
type ReproductionStatus = 'reproduced' | 'partially_reproduced' | 'not_reproduced';
type LaneCompletionStatus = 'clean' | 'dirty' | 'blocked' | 'dry_run';
type MetricValue = {
    value: number | null;
    source: string;
    unit?: string;
    note?: string;
    promptTokens?: number;
    completionTokens?: number;
    promptBytes?: number;
    outputBytes?: number;
};
type LaneCompletion = {
    clean: boolean;
    status: LaneCompletionStatus;
    reasonIds: string[];
    evidenceComplete: boolean;
    failureCode: string | null;
    markerState: string | null;
    exit: {
        status: number | null;
        signal: string | null;
        timedOut: boolean;
    };
};
type BenchLane = {
    laneId: string;
    label: string;
    quality: MetricValue & {
        maxScore: number;
    };
    tokens: MetricValue;
    duration: MetricValue;
    rounds: MetricValue;
    completion: LaneCompletion;
    evidencePaths: Array<{
        role: string;
        path: string;
        schema?: string;
    }>;
    receiptPath?: string;
};
type BenchFixture = {
    fixtureId: string;
    title: string;
    control: BenchLane;
    harness: BenchLane;
    comparison: {
        qualityDeltaHarnessMinusControl: number | null;
        tokenDeltaHarnessMinusControl: number | null;
        durationDeltaHarnessMinusControl: number | null;
        roundDeltaHarnessMinusControl: number | null;
        strictNoRegression: boolean;
        blockers: string[];
    };
};
type BenchAblation = {
    fixtureId: string;
    ablationId: string;
    status: 'confound_cleared' | 'confound_not_cleared' | 'not_run';
    quality: MetricValue & {
        maxScore: number;
    };
    completion: LaneCompletion;
    evidencePaths: Array<{
        role: string;
        path: string;
        schema?: string;
    }>;
    comparisonToHarness: {
        harnessQuality: number | null;
        ablationQuality: number | null;
        reason: string;
    };
};
interface BenchSuiteOptions {
    repoRoot?: string;
    mode?: BenchMode;
    outDir?: string;
    fixtureIds?: string[];
    includeAblations?: boolean;
    ablationFixtureIds?: string[] | null;
    allowSpawn?: boolean;
    adapterId?: string;
    timeoutMs?: number;
    maxLogBytes?: number;
    model?: string;
    effort?: string;
}
export declare function classifyBenchLaneCompletion(receipt: Pick<HarnessRuntimeReceipt, 'status' | 'exit' | 'marker' | 'failure' | 'evidencePaths'>): LaneCompletion;
export declare function runBenchSuite({ repoRoot, mode, outDir, fixtureIds, includeAblations, ablationFixtureIds, allowSpawn, adapterId, timeoutMs, maxLogBytes, model, effort }?: BenchSuiteOptions): {
    aggregatePath: string;
    reportPath: string;
    schema: string;
    generatedAt: string;
    suiteId: string;
    mode: "simulated";
    outDir: string;
    totals: {
        fixtures: number;
        laneRuns: number;
        ablationFixtures: number;
        ablationRuns: number;
    };
    metrics: {
        quality: {
            control: number | null;
            harness: number | null;
            direction: string;
            source: string;
        };
        tokens: {
            control: number | null;
            harness: number | null;
            direction: string;
            source: string;
        };
        duration: {
            control: number | null;
            harness: number | null;
            direction: string;
            source: string;
        };
        rounds: {
            control: number | null;
            harness: number | null;
            direction: string;
            source: string;
        };
    };
    cleanCompletion: {
        allLanesClean: boolean;
        dirtyLaneCount: number;
        reasonIds: string[];
    };
    fixtures: BenchFixture[];
    ablations: BenchAblation[];
    proofGate: {
        schema: string;
        status: "not_proven" | "proven";
        broadDominanceClaimAllowed: boolean;
        reasons: {
            id: string;
            detail: string;
            fixtureId?: string | null;
        }[];
        blockers: {
            id: string;
            detail: string;
            fixtureId?: string | null;
        }[];
        requiredStandard: string;
    };
    reproductionVerdict: {
        status: ReproductionStatus;
        rationale: string;
    };
    feedback: {
        status: "not_recorded";
        reason: string;
        path?: undefined;
        analysisPath?: undefined;
        record?: undefined;
        analysis?: undefined;
    } | {
        status: "recorded";
        path: string;
        analysisPath: string;
        record: import("./feedback.js").FeedbackRecord;
        analysis: {
            schema: string;
            runId: string;
            generatedAt: string;
            feedbackCount: number;
            sources: import("./feedback.js").FeedbackSource[];
            verdicts: import("./feedback.js").FeedbackVerdict[];
            repairHypotheses: {
                hypothesis: string;
                evidenceIds: string[];
            }[];
            nextAction: string;
            improvementCandidates: {
                feedbackId: string;
                scope: import("./feedback.js").FeedbackScope;
                hypothesis: string;
                nextAction: string;
            }[];
            boundary: {
                feedback_is_not_approval: boolean;
                analysis_is_not_patch: boolean;
                accepted_improvements_require_review: boolean;
            };
        };
        reason?: undefined;
    };
    sourcePrototypeProvenance: {
        status: string;
        summary: string;
    };
    boundary: {
        broadDominance: string;
        sourcePrototypeEvidenceIsNotOpenScaffoldProof: boolean;
        noMergePublishReleaseApproval: boolean;
        rawLiveLogsAreRuntimeResidue: boolean;
    };
};
export declare function runHandoffLab({ repoRoot, outDir, maxChars }?: {
    repoRoot?: string;
    outDir?: string;
    maxChars?: number;
}): {
    aggregatePath: string;
    reportPath: string;
    schema: string;
    generatedAt: string;
    outDir: string;
    methodsTested: number;
    budget: {
        maxChars: number;
    };
    best: {
        id: string;
        content: string;
        length: number;
        score: number;
        maxScore: number;
        failedCriteria: string[];
    };
    results: {
        id: string;
        length: number;
        score: number;
        maxScore: number;
        failedCriteria: string[];
    }[];
    narrowClaim: {
        status: string;
        language: string;
    };
};
export {};