/**
 * ConjectureRunner is the first operator-facing loop around `conjecture.v1`:
 * generate a bounded suite, execute invariant probes, preserve falsifiers,
 * classify receipts, and graduate the survivor/falsifier pair as evidence.
 */
import { type ConjectureProbePredicate, type ConjectureReceipt, type ConjectureStatus } from './ConjectureEngine';
import { type AttachSemanticAdvisoryOptions } from './ConjectureSemanticAdvisory';
import type { SemanticCorpusIndex } from './SemanticCorpusIndex';
import type { SemanticNoveltyAssessment } from './SemanticNoveltyEncoder';
import type { HashMode } from './hashes';
import { type RenderManifoldArtifact } from './RenderManifold';
export declare const CONJECTURE_RUNNER_V1: "conjecture.runner.v1";
export declare const PROOF_CARRYING_GEOMETRY_SMOKE_SUITE: "proof-carrying-geometry-smoke";
export declare const GENERATED_GEOMETRY_FAMILY_SUITE: "generated-geometry-family";
export type ConjectureRunnerV1SolverType = typeof CONJECTURE_RUNNER_V1;
export type ConjectureRunnerSuite = typeof PROOF_CARRYING_GEOMETRY_SMOKE_SUITE | typeof GENERATED_GEOMETRY_FAMILY_SUITE;
export type ConjectureRunnerStatus = 'completed' | 'failed';
export type ConjectureRunnerPhase = 'GENERATE' | 'EXECUTE' | 'FALSIFY' | 'CLASSIFY' | 'GRADUATE' | 'RENDER';
export type ConjectureScenarioRole = 'survivor' | 'falsifier' | 'boundary';
export type ConjectureGraduationTarget = 'receipt-carrying.geometry' | 'trait-invariant.candidate' | 'compiler-check.candidate' | 'lean-obligation.gated';
export interface ConjectureRunnerInput {
    suite?: ConjectureRunnerSuite;
    proposedBy?: string;
    hashMode?: HashMode;
    includeHashBoundary?: boolean;
}
/** Per-probe timing record for cost-cell instrumentation. */
export interface ConjectureProbeTiming {
    probeId: string;
    wallClockMs: number;
}
/** Per-candidate cost record within a cost-cell measurement. */
export interface ConjectureCandidateCost {
    candidateId: string;
    family: string;
    probeTimings: ReadonlyArray<ConjectureProbeTiming>;
    totalProbeMs: number;
    status: ConjectureStatus;
}
/** Cost-cell result: efficiency metrics for a single runner invocation. */
export interface ConjectureCostCellResult {
    solverType: string;
    suite: string;
    scaleCandidateCount: number;
    totalRunnerMs: number;
    candidates: ReadonlyArray<ConjectureCandidateCost>;
    /** How many candidates survived / were falsified / were undecided. */
    survivedCount: number;
    falsifiedCount: number;
    undecidedCount: number;
    /** candidates-per-accepted-conjecture: total candidates / survived count. */
    candidatesPerAcceptedConjecture: number | null;
    /** Sum of all per-probe wall clock times across all candidates. */
    totalProbeMs: number;
    /** Mean per-candidate probe time. */
    meanCandidateProbeMs: number;
    /** Median per-candidate probe time. */
    medianCandidateProbeMs: number;
    /** Max per-candidate probe time. */
    maxCandidateProbeMs: number;
    /** Per-probe-type aggregated timing. */
    probeTypeAggregate: ReadonlyArray<{
        probeId: string;
        totalMs: number;
        meanMs: number;
        invocationCount: number;
    }>;
}
export interface ConjectureRunnerStage {
    phase: ConjectureRunnerPhase;
    status: ConjectureRunnerStatus;
    summary: string;
    evidence: ReadonlyArray<string>;
    predicates?: ReadonlyArray<ConjectureProbePredicate>;
}
export interface ConjectureRunnerReplay {
    scenarioId: string;
    status: ConjectureStatus;
    receiptKeyMatched: boolean;
    counterexampleMatched: boolean;
}
export interface ConjectureRunnerGate {
    survivorReceiptKey: string | null;
    falsifiedReceiptKey: string | null;
    replayCounterexampleMatched: boolean;
    passed: boolean;
}
export interface ConjectureRunnerClassification {
    scenarioId: string;
    role: ConjectureScenarioRole;
    status: ConjectureStatus;
    receiptKey: string;
    counterexampleCount: number;
}
export interface ConjectureRunnerResult {
    solverType: ConjectureRunnerV1SolverType;
    specVersion: 1;
    suite: ConjectureRunnerSuite;
    status: ConjectureRunnerStatus;
    receiptKey: string;
    stages: ReadonlyArray<ConjectureRunnerStage>;
    receipts: ReadonlyArray<ConjectureReceipt>;
    classifications: ReadonlyArray<ConjectureRunnerClassification>;
    replay: ReadonlyArray<ConjectureRunnerReplay>;
    gate: ConjectureRunnerGate;
    graduation: ReadonlyArray<ConjectureGraduationTarget>;
    /** The RENDER leg: receipt-carrying render manifold artifact (P36). */
    renderManifold: RenderManifoldArtifact;
}
export interface ConjectureRunnerSemanticAdvisory {
    scenarioId: string;
    claimId: string;
    receiptKey: string;
    receiptStatus: ConjectureStatus;
    receiptKeyPreserved: boolean;
    semanticAdvisory: SemanticNoveltyAssessment | null;
    advisorySkippedReason?: 'status-not-advisable' | 'empty-index';
}
export interface ConjectureRunnerSemanticAdvisorySummary {
    provider: 'semantic-corpus-index';
    binding: 'advisory';
    corpusSize: number;
    modelId: string;
    receiptKeysPreserved: boolean;
    nearDuplicateCount: number;
    skippedCount: number;
}
export interface ConjectureRunnerResultWithSemanticAdvisory {
    result: ConjectureRunnerResult;
    semanticAdvisorySummary: ConjectureRunnerSemanticAdvisorySummary;
    semanticAdvisories: ReadonlyArray<ConjectureRunnerSemanticAdvisory>;
}
export declare function runProofCarryingGeometryConjectureCycle(input?: ConjectureRunnerInput): ConjectureRunnerResult;
/**
 * GENERATE leg: build a conjecture over machine-generated candidate *families*
 * (a swept parameter), not hand-coded one-offs. The survivor family is a sweep
 * of regular polygon sheets; the falsifier family is an apex-height sweep that
 * discovers the degenerate (collinear) member. Survivors and the replayable
 * falsifier graduate exactly as in the smoke suite.
 */
export declare function runGeneratedGeometryConjectureCycle(input?: ConjectureRunnerInput): ConjectureRunnerResult;
export declare class ConjectureRunner {
    run(input?: ConjectureRunnerInput): ConjectureRunnerResult;
}
export declare function runConjectureRunner(input?: ConjectureRunnerInput): ConjectureRunnerResult;
/**
 * Cost-cell instrumentation: run the conjecture loop at a given candidate scale,
 * measuring candidates-per-accepted-conjecture and per-probe wall clock time.
 *
 * This wraps `buildConjectureV1Receipt` with timing, producing a
 * `ConjectureCostCellResult` suitable for empirical efficiency tables.
 */
export declare function runConjectureCostCell(input: ConjectureRunnerInput & {
    candidateScale: number;
}): ConjectureCostCellResult;
/**
 * Attach the learned-semantic novelty layer to an already-minted runner result.
 * This is intentionally a sibling wrapper: receipt-binding trigram novelty and
 * receipt keys stay unchanged until the semantic determinism gate graduates.
 */
export declare function attachSemanticAdvisoriesToRunnerResult(result: ConjectureRunnerResult, index: SemanticCorpusIndex, options?: AttachSemanticAdvisoryOptions): Promise<ConjectureRunnerResultWithSemanticAdvisory>;
export declare function runConjectureRunnerWithSemanticAdvisory(input: ConjectureRunnerInput, index: SemanticCorpusIndex, options?: AttachSemanticAdvisoryOptions): Promise<ConjectureRunnerResultWithSemanticAdvisory>;
//# sourceMappingURL=ConjectureRunner.d.ts.map