import type { ExecutionTaskCategory } from "./executionRouting.js";
export type GraphEngineGroup = "G0" | "G1" | "G2" | "G3" | "G4" | "G5" | "G6";
export type GraphTaskCategory = ExecutionTaskCategory;
export type GraphEvidenceStage = "define" | "plan" | "build" | "verify" | "review" | "debug" | "ship" | "fast-judge" | "integrate";
export type GraphValidatorType = "structured-tool" | "schema" | "tests" | "typecheck" | "lint" | "build" | "security" | "human-gate";
export type GraphStageStatus = "succeeded" | "failed" | "skipped" | "cancelled" | "paused";
export type GraphContractStatus = "passed" | "failed" | "skipped" | "unknown";
export type GraphRecoveryLevel = "none" | "retry" | "diagnose" | "repair" | "replan" | "pause" | "fail";
export type GraphFinalStatus = "done" | "failed" | "cancelled" | "paused";
export type GraphTraceCompleteness = "complete" | "partial" | "missing";
export type GraphParallelismMode = "none" | "read-only" | "isolated-writes";
export type GraphEvidenceNumber = number | "unknown";
export type GraphRolloutDecision = "keep-graph-shadow" | "enable-sequential-graph" | "enable-graph-dag";
export type GraphRolloutDecisionReason = "evidence-incomplete" | "sequential-regression" | "typed-recovery-unobserved" | "dag-regression" | "useful-isolated-parallelism-unobserved" | "sequential-non-inferior" | "dag-non-inferior";
export interface GraphEvidenceUsage {
    inputTokens: GraphEvidenceNumber;
    outputTokens: GraphEvidenceNumber;
    cacheReadTokens: GraphEvidenceNumber;
    cacheWriteTokens: GraphEvidenceNumber;
}
export interface GraphEvidenceCost {
    estimatedUsd: GraphEvidenceNumber;
    observedUsd: GraphEvidenceNumber;
}
export interface GraphPlanTransitionEvidence {
    sourcePlanVersion: number;
    targetPlanVersion: number;
    graphDigest: string;
    planDigest: string;
    approvalDigest: string;
    recoveryLedgerDigest: string;
}
export interface GraphPlanActivationIdentity {
    runId: string;
    corpusCaseId: string;
    corpusSnapshotDigest: string;
    eventId: string;
    nodeId: string;
    sequence: number;
    transition: GraphPlanTransitionEvidence;
}
export interface GraphExecutionReceiptIdentity {
    runId: string;
    corpusCaseId: string;
    corpusSnapshotDigest: string;
    eventId: string;
    nodeId: string;
    sequence: number;
    attempt: number;
    stage: GraphEvidenceStage;
    startedAt: string;
    completedAt: string;
    baseRevisionDigest?: string;
    writeSetDigest?: string;
    worktreeReceiptDigest?: string;
    schedulerReceiptDigest?: string;
}
export interface GraphDisjointnessReceiptIdentity {
    runId: string;
    corpusCaseId: string;
    corpusSnapshotDigest: string;
    baseRevisionDigest: string;
    executions: readonly GraphExecutionReceiptIdentity[];
}
export interface GraphStageExecutionWindow {
    startedAt: string;
    completedAt: string;
    /** Digest of the scheduler-authored execution receipt for this exact attempt. */
    schedulerReceiptDigest: string;
    /** Present together for BUILD/INTEGRATE attempts executed in isolated worktrees. */
    worktreeReceiptDigest?: string;
    baseRevisionDigest?: string;
    writeSetDigest?: string;
    disjointnessReceiptDigest?: string;
}
interface GraphEvidenceBase {
    schemaVersion: 1;
    /** Canonical SHA-256 digest or UUID; never a task, path, or provider label. */
    eventId: string;
    runId: string;
    /** Stable opaque identity shared by the same sanitized corpus case across ablation groups. */
    corpusCaseId: string;
    /** Trusted experiment manifest and exact sanitized fixture/config bindings. */
    experimentId: string;
    corpusSnapshotDigest: string;
    engineConfigurationDigest: string;
    sequence: number;
    recordedAt: string;
    engineGroup: GraphEngineGroup;
    taskCategory: GraphTaskCategory;
    graphVersion: string;
    planVersion: number;
}
export interface GraphStageEvidenceEvent extends GraphEvidenceBase {
    type: "stage";
    stage: GraphEvidenceStage;
    nodeId: string;
    attempt: number;
    status: GraphStageStatus;
    contractStatus: GraphContractStatus;
    validatorTypes: GraphValidatorType[];
    readySetWidth: number;
    retryCount: number;
    fallbackCount: number;
    recoveryLevel: GraphRecoveryLevel;
    /** Exact immutable Plan 0016 successor/approval bindings, present only on an N -> N+1 plan stage. */
    planTransition?: GraphPlanTransitionEvidence;
    /** Composite digest of the active transition, repeated by every stage in the successor plan. */
    planActivationDigest?: string;
    /** Scheduler-authored interval used to reproduce observed concurrency. */
    executionWindow?: GraphStageExecutionWindow;
    durationMs: GraphEvidenceNumber;
    usage: GraphEvidenceUsage;
    cost: GraphEvidenceCost;
    failureLocalizationMs: GraphEvidenceNumber;
}
export interface GraphParallelismEvidence {
    mode: GraphParallelismMode;
    executedConcurrently: boolean;
    summedNodeDurationMs: GraphEvidenceNumber;
    criticalPathDurationMs: GraphEvidenceNumber;
    failedNodeCount: number;
    skippedNodeCount: number;
    conflictingNodeCount: number;
}
export interface GraphRunEvidenceEvent extends GraphEvidenceBase {
    type: "run";
    finalStatus: GraphFinalStatus;
    traceCompleteness: GraphTraceCompleteness;
    nodeCount: number;
    nodeExecutions: number;
    redundantNodeExecutions: number;
    maxReadySetWidth: number;
    validatorTypes: GraphValidatorType[];
    contractChecks: {
        passed: number;
        failed: number;
        skipped: number;
    };
    retryCount: number;
    fallbackCount: number;
    recoveryLevel: GraphRecoveryLevel;
    /** Number of recovery-bearing stage executions reproduced by a complete trace. */
    recoveryAttempts: number;
    /** Recovery-bearing stage executions that succeeded and passed their contract. */
    recoverySuccesses: number;
    buildPasses: number;
    firstPassVerification: boolean | "unknown";
    laterRejection: boolean;
    humanOverride: boolean;
    durationMs: GraphEvidenceNumber;
    usage: GraphEvidenceUsage;
    cost: GraphEvidenceCost;
    failureLocalizationMs: GraphEvidenceNumber;
    parallelism: GraphParallelismEvidence;
}
export type GraphEvidenceEvent = GraphStageEvidenceEvent | GraphRunEvidenceEvent;
export type GraphEvidenceValidationError = "not-object" | "unexpected-field" | "unsupported-version" | "invalid-token" | "invalid-time" | "invalid-enum" | "invalid-number" | "invalid-boolean" | "unbounded-array" | "duplicate-array-value" | "inconsistent-metrics";
export type GraphEvidenceValidation = {
    ok: true;
    event: GraphEvidenceEvent;
} | {
    ok: false;
    error: GraphEvidenceValidationError;
};
export interface KnownUnknownTotal {
    total: number;
    knownSamples: number;
    unknownSamples: number;
}
export interface GraphEvidenceAggregate {
    runCount: number;
    successCount: number;
    successRateBasisPoints: number | "unknown";
    finalStatuses: Record<GraphFinalStatus, number>;
    contractChecks: {
        passed: number;
        failed: number;
        skipped: number;
        satisfactionRateBasisPoints: number | "unknown";
    };
    wallTimeMs: KnownUnknownTotal;
    failureLocalizationMs: KnownUnknownTotal;
    inputTokens: KnownUnknownTotal;
    outputTokens: KnownUnknownTotal;
    cacheReadTokens: KnownUnknownTotal;
    cacheWriteTokens: KnownUnknownTotal;
    estimatedCostUsd: KnownUnknownTotal;
    observedCostUsd: KnownUnknownTotal;
    redundantNodeExecutions: number;
    failedNodeExecutions: number;
    skippedNodeExecutions: number;
    conflictingNodeExecutions: number;
    retryCount: number;
    fallbackCount: number;
    buildPasses: number;
    maxReadySetWidth: number;
    laterRejectionRuns: number;
    humanOverrideRuns: number;
    firstPassVerification: {
        successes: number;
        knownSamples: number;
        rateBasisPoints: number | "unknown";
    };
    recovery: {
        successes: number;
        attempts: number;
        successRateBasisPoints: number | "unknown";
    };
    graphVersions: Record<string, number>;
    planVersions: Record<string, number>;
    recoveryLevels: Record<GraphRecoveryLevel, number>;
    traceStatuses: Record<GraphTraceCompleteness, number>;
    validatorTypes: Partial<Record<GraphValidatorType, number>>;
    failureLoopRuns: number;
    failureLoopRateBasisPoints: number | "unknown";
    completeTraceRuns: number;
    completeTraceRateBasisPoints: number | "unknown";
    usefulParallelism: {
        usefulRuns: number;
        eligibleRuns: number;
        observedCriticalPathSavingsMs: number;
    };
}
export interface GraphEvidenceCohortReport extends GraphEvidenceAggregate {
    engineGroup: GraphEngineGroup;
    taskCategory: GraphTaskCategory;
}
export type GraphEvidenceLimitation = "no-counterfactual-quality-claim" | "paid-provider-evidence-not-attested" | "unverified-experiment-provenance" | "insufficient-cohort-samples" | "incomplete-engine-group-coverage" | "incomplete-task-category-coverage" | "incomplete-ablation-matrix" | "insufficient-distinct-corpus-cases" | "unpaired-baseline-corpus" | "incomplete-run-summaries" | "partial-traces" | "unknown-usage" | "unknown-cost";
export interface GraphEvidenceReport {
    schemaVersion: 1;
    qualityClaim: "observed-executions-only";
    /** Structural completeness is reported separately from the evidence-derived recommendation. */
    evidenceComplete: boolean;
    recommendedDecision: GraphRolloutDecision;
    decisionReasons: GraphRolloutDecisionReason[];
    /** True only when complete evidence supports a positive graph rollout recommendation. */
    rolloutDecisionEligible: boolean;
    eventCount: number;
    stageEventCount: number;
    runCount: number;
    totals: GraphEvidenceAggregate;
    cohorts: GraphEvidenceCohortReport[];
    limitations: GraphEvidenceLimitation[];
}
export interface GraphEvidenceReportOptions {
    /** May raise the hard ten-run cohort floor, never lower it. */
    minimumCohortRuns?: number;
    /** Compiled by trusted local corpus configuration, never repository data. */
    experimentManifest?: GraphExperimentManifest;
}
export interface GraphEngineFeatureVector {
    graphDeclarations: boolean;
    activeOuterGraph: boolean;
    durableScheduler: boolean;
    immutableBuildDag: boolean;
    typedRecovery: boolean;
    isolatedParallelBuild: boolean;
}
export interface GraphExperimentEngine {
    engineGroup: GraphEngineGroup;
    graphVersion: string;
    configurationDigest: string;
    features: Readonly<GraphEngineFeatureVector>;
}
export interface GraphExperimentCase {
    corpusCaseId: string;
    taskCategory: GraphTaskCategory;
    snapshotDigest: string;
}
export interface GraphExperimentManifest {
    schemaVersion: 1;
    experimentId: string;
    releaseVersion: string;
    corpusSnapshotDigest: string;
    engines: readonly Readonly<GraphExperimentEngine>[];
    cases: readonly Readonly<GraphExperimentCase>[];
}
export type GraphExperimentManifestInput = Omit<GraphExperimentManifest, "experimentId" | "corpusSnapshotDigest"> & {
    /** Optional assertion; when present it must equal the digest derived from the canonical case list. */
    corpusSnapshotDigest?: string;
};
export type GraphEvidenceErrorCode = "invalid-event" | "too-many-events" | "duplicate-event-id" | "duplicate-sequence" | "duplicate-run-summary" | "inconsistent-run-identity" | "inconsistent-run-trace" | "run-summary-not-terminal" | "aggregate-overflow" | "invalid-report-options" | "invalid-experiment-manifest" | "inconsistent-experiment-evidence" | "invalid-retirement-evidence";
export declare class GraphEvidenceError extends Error {
    readonly code: GraphEvidenceErrorCode;
    constructor(code: GraphEvidenceErrorCode);
}
export interface ReleaseBoundEvidenceReference {
    releaseVersion: string;
    artifactDigest: string;
}
export interface RolloutReportEvidenceReference extends ReleaseBoundEvidenceReference {
    decision: GraphRolloutDecision;
}
export interface LegacyRetirementEvidence {
    releasedCompatibilityWindows: number;
    /** Must be supplied only by trusted user/release storage, never repository configuration. */
    evidenceSource?: "trusted-release-record";
    rolloutReport?: RolloutReportEvidenceReference;
    graphCoverage?: ReleaseBoundEvidenceReference;
    cleanRollback?: ReleaseBoundEvidenceReference;
    configMigration?: ReleaseBoundEvidenceReference;
}
export type LegacyRetirementRequirement = "released-compatibility-window" | "trusted-release-evidence" | "verified-release-artifacts" | "decision-ready-rollout-report" | "consistent-release-binding" | "graph-coverage" | "clean-rollback" | "config-migration";
export interface LegacyRetirementAssessment {
    eligible: boolean;
    missing: LegacyRetirementRequirement[];
}
export declare const GRAPH_ENGINE_GROUP_DESCRIPTIONS: Readonly<Record<GraphEngineGroup, string>>;
export declare const GRAPH_ENGINE_FEATURES: Readonly<Record<GraphEngineGroup, Readonly<GraphEngineFeatureVector>>>;
export declare function validateGraphEvidenceEvent(value: unknown): GraphEvidenceValidation;
/** Bind a successor activation to the exact run and PLAN event that consumed the re-plan. */
export declare function graphPlanActivationDigest(value: GraphPlanActivationIdentity): string;
/** Digest the immutable worktree/base/write-set receipt for one exact stage attempt. */
export declare function graphWorktreeReceiptDigest(value: GraphExecutionReceiptIdentity): string;
/** Digest the scheduler interval and, for isolated mutation, its exact worktree artifacts. */
export declare function graphSchedulerReceiptDigest(value: GraphExecutionReceiptIdentity): string;
/** Bind one disjointness decision to the complete, sorted set of isolated mutation receipts. */
export declare function graphDisjointnessReceiptDigest(value: GraphDisjointnessReceiptIdentity): string;
export declare function createGraphExperimentManifest(value: GraphExperimentManifestInput): GraphExperimentManifest;
export declare function validateGraphExperimentManifest(value: unknown): GraphExperimentManifest;
export declare function buildGraphEvidenceReport(values: readonly unknown[], options?: GraphEvidenceReportOptions): GraphEvidenceReport;
export declare function assessLegacyRetirement(value: LegacyRetirementEvidence): LegacyRetirementAssessment;
export {};