eval-quality 0.1.0

package/dist/core/schemas/evidence-artifact.d.ts

@@ -0,0 +1,471 @@
+/** the scored output `emit` owns: outcomes, strength, and one verdict. */
+import { z } from 'zod';
+/**
+ * AD-6's closed twelve. Exported so a later reader can walk the list
+ * directly, and asserted at twelve by a test: AD-6 says the set "stays closed
+ * at twelve", so adding a thirteenth member means amending that AD first.
+ */
+export declare const OUTCOME_STATES: readonly ['caught', 'confirmed', 'missed', 'passed-clean-control', 'false-positive', 'abstained', 'bypassed', 'unreached', 'oracle-error', 'judge-error', 'infrastructure-error', 'not-applicable'];
+export declare const OutcomeState: z.ZodEnum<{
+    abstained: "abstained";
+    bypassed: "bypassed";
+    caught: "caught";
+    confirmed: "confirmed";
+    "false-positive": "false-positive";
+    "infrastructure-error": "infrastructure-error";
+    "judge-error": "judge-error";
+    missed: "missed";
+    "not-applicable": "not-applicable";
+    "oracle-error": "oracle-error";
+    "passed-clean-control": "passed-clean-control";
+    unreached: "unreached";
+}>;
+/** AD-33's closed three. */
+export declare const CORROBORATION_VALUES: readonly ['agrees', 'disagrees', 'not-evaluable'];
+export declare const Corroboration: z.ZodEnum<{
+    agrees: "agrees";
+    disagrees: "disagrees";
+    "not-evaluable": "not-evaluable";
+}>;
+export type CheckResolutionValue = {
+    resolution: 'true' | 'false' | 'insufficient-evidence';
+    introductionCondition: 'empty-collection' | null;
+    children: CheckResolutionValue[];
+};
+/**
+ * AD-4 requires that "each node's resolution and, where it is
+ * `insufficient-evidence`, the introduction condition that fired, are recorded
+ * in the evidence". A single verdict per oracle would erase that distinction,
+ * so the record mirrors the oracle's own `check` tree. Self-referential, so
+ * it carries `.meta({ id })`; without it the tree exports as a positional
+ * `__schema0` that the published-schema drift check would pin.
+ * `core/evaluate/resolution.ts` populates it.
+ */
+export declare const CheckResolution: z.ZodType<CheckResolutionValue>;
+/**
+ * AD-11's five named inputs, transcribed so a reader can recompute the
+ * digest and see what was compared (AD-8's "by digest and opaque reference,
+ * never by content or path"). Named object rather than a concatenated tuple:
+ * revision 1 let two conforming scorers compute different versions from
+ * identical inputs if they hashed a different ordering. The scorer computes
+ * the scoring version over this shape.
+ */
+export declare const SCORING_VERSION_INPUT_NAMES: readonly ['contractSchemaVersion', 'corpusDigest', 'fixtureDigest', 'evaluatorConfigurationDigest', 'scoringPolicyDigest'];
+export declare const ScoringVersionInputName: z.ZodEnum<{
+    contractSchemaVersion: "contractSchemaVersion";
+    corpusDigest: "corpusDigest";
+    evaluatorConfigurationDigest: "evaluatorConfigurationDigest";
+    fixtureDigest: "fixtureDigest";
+    scoringPolicyDigest: "scoringPolicyDigest";
+}>;
+export declare const ScoringVersionInputs: z.ZodObject<{
+    contractSchemaVersion: z.ZodInt;
+    corpusDigest: z.ZodString;
+    fixtureDigest: z.ZodString;
+    evaluatorConfigurationDigest: z.ZodString;
+    scoringPolicyDigest: z.ZodString;
+}, z.core.$strict>;
+export declare const InvalidatedAttempt: z.ZodObject<{
+    attempt: z.ZodInt;
+    reason: z.ZodString;
+}, z.core.$strict>;
+/**
+ * AD-6: "Every artifact records its trial count, its invalidated attempts, and
+ * each attempt's reason, including on a PASS." None of the three is nullable,
+ * because "including on a PASS" is exactly the case a nullable field would let
+ * a producer skip.
+ */
+export declare const Trials: z.ZodObject<{
+    declaredMinimum: z.ZodInt;
+    completed: z.ZodInt;
+    invalidatedAttempts: z.ZodArray<z.ZodObject<{
+        attempt: z.ZodInt;
+        reason: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export declare const Outcome: z.ZodObject<{
+    oracleId: z.ZodString;
+    probeId: z.ZodNullable<z.ZodString>;
+    state: z.ZodEnum<{
+        abstained: "abstained";
+        bypassed: "bypassed";
+        caught: "caught";
+        confirmed: "confirmed";
+        "false-positive": "false-positive";
+        "infrastructure-error": "infrastructure-error";
+        "judge-error": "judge-error";
+        missed: "missed";
+        "not-applicable": "not-applicable";
+        "oracle-error": "oracle-error";
+        "passed-clean-control": "passed-clean-control";
+        unreached: "unreached";
+    }>;
+    severity: z.ZodEnum<{
+        critical: "critical";
+        low: "low";
+        material: "material";
+    }>;
+    disposition: z.ZodEnum<{
+        held: "held";
+        "not-attempted": "not-attempted";
+        violated: "violated";
+    }>;
+    resolvedFrom: z.ZodNullable<z.ZodString>;
+    corroboration: z.ZodEnum<{
+        agrees: "agrees";
+        disagrees: "disagrees";
+        "not-evaluable": "not-evaluable";
+    }>;
+    selectedObservationIds: z.ZodArray<z.ZodString>;
+    checkResolution: z.ZodNullable<z.ZodType<CheckResolutionValue, unknown, z.core.$ZodTypeInternals<CheckResolutionValue, unknown>>>;
+}, z.core.$strict>;
+export declare const CoverageGap: z.ZodObject<{
+    rule: z.ZodString;
+    relevancePredicate: z.ZodString;
+    satisfactionPredicate: z.ZodString;
+    satisfied: z.ZodBoolean;
+    severity: z.ZodEnum<{
+        critical: "critical";
+        low: "low";
+        material: "material";
+    }>;
+}, z.core.$strict>;
+/** the record as a type, so `core/coverage/` names it without importing Zod. */
+export type CoverageGap = z.infer<typeof CoverageGap>;
+export declare const ClassStrength: z.ZodObject<{
+    caught: z.ZodInt;
+    exercised: z.ZodInt;
+    rate: z.ZodNullable<z.ZodNumber>;
+}, z.core.$strict>;
+/**
+ * A fixed three-key object instead of a map keyed by probe class. AD-7 is
+ * explicit that "canary probes and clean controls never enter the vector", so
+ * the fourth class has no key here at all and its absence is structural.
+ */
+export declare const StrengthVector: z.ZodObject<{
+    defect: z.ZodNullable<z.ZodObject<{
+        caught: z.ZodInt;
+        exercised: z.ZodInt;
+        rate: z.ZodNullable<z.ZodNumber>;
+    }, z.core.$strict>>;
+    gameability: z.ZodNullable<z.ZodObject<{
+        caught: z.ZodInt;
+        exercised: z.ZodInt;
+        rate: z.ZodNullable<z.ZodNumber>;
+    }, z.core.$strict>>;
+    'zero-action': z.ZodNullable<z.ZodObject<{
+        caught: z.ZodInt;
+        exercised: z.ZodInt;
+        rate: z.ZodNullable<z.ZodNumber>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export declare const Strength: z.ZodObject<{
+    denominator: z.ZodString;
+    basis: z.ZodEnum<{
+        measured: "measured";
+        reconstructed: "reconstructed";
+    }>;
+    vector: z.ZodObject<{
+        defect: z.ZodNullable<z.ZodObject<{
+            caught: z.ZodInt;
+            exercised: z.ZodInt;
+            rate: z.ZodNullable<z.ZodNumber>;
+        }, z.core.$strict>>;
+        gameability: z.ZodNullable<z.ZodObject<{
+            caught: z.ZodInt;
+            exercised: z.ZodInt;
+            rate: z.ZodNullable<z.ZodNumber>;
+        }, z.core.$strict>>;
+        'zero-action': z.ZodNullable<z.ZodObject<{
+            caught: z.ZodInt;
+            exercised: z.ZodInt;
+            rate: z.ZodNullable<z.ZodNumber>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    comparable: z.ZodBoolean;
+    note: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>;
+/**
+ * AD-12's three named checks, transcribed from the same sentence the field
+ * comes from: the package "validates a caller-presented lineage chain (length
+ * consistent with the declared revision, no repeated digest, no gap) and
+ * emits evidence of compliance." A single boolean would tell a reader a chain
+ * failed without saying which of three ways, on an artifact whose purpose is
+ * to be read. AD-21's FAIL rung reads the conjunction.
+ */
+export declare const LineageChain: z.ZodObject<{
+    lengthConsistent: z.ZodBoolean;
+    noRepeatedDigest: z.ZodBoolean;
+    noGap: z.ZodBoolean;
+}, z.core.$strict>;
+/** Exported for `core/lineage/chain.ts`, which computes these three. */
+export type LineageChain = z.infer<typeof LineageChain>;
+export declare const Remediation: z.ZodObject<{
+    revisionCount: z.ZodInt;
+    cap: z.ZodInt;
+    capSource: z.ZodLiteral<"caller-attested">;
+    lineageChain: z.ZodObject<{
+        lengthConsistent: z.ZodBoolean;
+        noRepeatedDigest: z.ZodBoolean;
+        noGap: z.ZodBoolean;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+/**
+ * A discriminated union, because AD-21 requires that no shape hold a
+ * production verdict and a contract verdict at once, with neither mode able
+ * to read a field as the other's.
+ */
+export declare const EvidenceArtifact: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    schemaVersion: z.ZodInt;
+    parentDigest: z.ZodNullable<z.ZodString>;
+    revisionCount: z.ZodInt;
+    runId: z.ZodString;
+    scoringVersion: z.ZodString;
+    scoringVersionInputs: z.ZodObject<{
+        contractSchemaVersion: z.ZodInt;
+        corpusDigest: z.ZodString;
+        fixtureDigest: z.ZodString;
+        evaluatorConfigurationDigest: z.ZodString;
+        scoringPolicyDigest: z.ZodString;
+    }, z.core.$strict>;
+    comparabilityKey: z.ZodString;
+    excludedProbeIds: z.ZodArray<z.ZodString>;
+    exitCode: z.ZodInt;
+    verdictBasis: z.ZodArray<z.ZodString>;
+    callerAttestedInputs: z.ZodArray<z.ZodEnum<{
+        contractSchemaVersion: "contractSchemaVersion";
+        corpusDigest: "corpusDigest";
+        evaluatorConfigurationDigest: "evaluatorConfigurationDigest";
+        fixtureDigest: "fixtureDigest";
+        scoringPolicyDigest: "scoringPolicyDigest";
+    }>>;
+    trials: z.ZodObject<{
+        declaredMinimum: z.ZodInt;
+        completed: z.ZodInt;
+        invalidatedAttempts: z.ZodArray<z.ZodObject<{
+            attempt: z.ZodInt;
+            reason: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    outcomes: z.ZodArray<z.ZodObject<{
+        oracleId: z.ZodString;
+        probeId: z.ZodNullable<z.ZodString>;
+        state: z.ZodEnum<{
+            abstained: "abstained";
+            bypassed: "bypassed";
+            caught: "caught";
+            confirmed: "confirmed";
+            "false-positive": "false-positive";
+            "infrastructure-error": "infrastructure-error";
+            "judge-error": "judge-error";
+            missed: "missed";
+            "not-applicable": "not-applicable";
+            "oracle-error": "oracle-error";
+            "passed-clean-control": "passed-clean-control";
+            unreached: "unreached";
+        }>;
+        severity: z.ZodEnum<{
+            critical: "critical";
+            low: "low";
+            material: "material";
+        }>;
+        disposition: z.ZodEnum<{
+            held: "held";
+            "not-attempted": "not-attempted";
+            violated: "violated";
+        }>;
+        resolvedFrom: z.ZodNullable<z.ZodString>;
+        corroboration: z.ZodEnum<{
+            agrees: "agrees";
+            disagrees: "disagrees";
+            "not-evaluable": "not-evaluable";
+        }>;
+        selectedObservationIds: z.ZodArray<z.ZodString>;
+        checkResolution: z.ZodNullable<z.ZodType<CheckResolutionValue, unknown, z.core.$ZodTypeInternals<CheckResolutionValue, unknown>>>;
+    }, z.core.$strict>>;
+    uncitedFindings: z.ZodArray<z.ZodString>;
+    coverageGaps: z.ZodArray<z.ZodObject<{
+        rule: z.ZodString;
+        relevancePredicate: z.ZodString;
+        satisfactionPredicate: z.ZodString;
+        satisfied: z.ZodBoolean;
+        severity: z.ZodEnum<{
+            critical: "critical";
+            low: "low";
+            material: "material";
+        }>;
+    }, z.core.$strict>>;
+    strength: z.ZodObject<{
+        denominator: z.ZodString;
+        basis: z.ZodEnum<{
+            measured: "measured";
+            reconstructed: "reconstructed";
+        }>;
+        vector: z.ZodObject<{
+            defect: z.ZodNullable<z.ZodObject<{
+                caught: z.ZodInt;
+                exercised: z.ZodInt;
+                rate: z.ZodNullable<z.ZodNumber>;
+            }, z.core.$strict>>;
+            gameability: z.ZodNullable<z.ZodObject<{
+                caught: z.ZodInt;
+                exercised: z.ZodInt;
+                rate: z.ZodNullable<z.ZodNumber>;
+            }, z.core.$strict>>;
+            'zero-action': z.ZodNullable<z.ZodObject<{
+                caught: z.ZodInt;
+                exercised: z.ZodInt;
+                rate: z.ZodNullable<z.ZodNumber>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+        comparable: z.ZodBoolean;
+        note: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>;
+    remediation: z.ZodObject<{
+        revisionCount: z.ZodInt;
+        cap: z.ZodInt;
+        capSource: z.ZodLiteral<"caller-attested">;
+        lineageChain: z.ZodObject<{
+            lengthConsistent: z.ZodBoolean;
+            noRepeatedDigest: z.ZodBoolean;
+            noGap: z.ZodBoolean;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    mode: z.ZodLiteral<"production">;
+    productionVerdict: z.ZodEnum<{
+        CONCERNS: "CONCERNS";
+        FAIL: "FAIL";
+        PASS: "PASS";
+        WAIVED: "WAIVED";
+    }>;
+}, z.core.$strict>, z.ZodObject<{
+    schemaVersion: z.ZodInt;
+    parentDigest: z.ZodNullable<z.ZodString>;
+    revisionCount: z.ZodInt;
+    runId: z.ZodString;
+    scoringVersion: z.ZodString;
+    scoringVersionInputs: z.ZodObject<{
+        contractSchemaVersion: z.ZodInt;
+        corpusDigest: z.ZodString;
+        fixtureDigest: z.ZodString;
+        evaluatorConfigurationDigest: z.ZodString;
+        scoringPolicyDigest: z.ZodString;
+    }, z.core.$strict>;
+    comparabilityKey: z.ZodString;
+    excludedProbeIds: z.ZodArray<z.ZodString>;
+    exitCode: z.ZodInt;
+    verdictBasis: z.ZodArray<z.ZodString>;
+    callerAttestedInputs: z.ZodArray<z.ZodEnum<{
+        contractSchemaVersion: "contractSchemaVersion";
+        corpusDigest: "corpusDigest";
+        evaluatorConfigurationDigest: "evaluatorConfigurationDigest";
+        fixtureDigest: "fixtureDigest";
+        scoringPolicyDigest: "scoringPolicyDigest";
+    }>>;
+    trials: z.ZodObject<{
+        declaredMinimum: z.ZodInt;
+        completed: z.ZodInt;
+        invalidatedAttempts: z.ZodArray<z.ZodObject<{
+            attempt: z.ZodInt;
+            reason: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    outcomes: z.ZodArray<z.ZodObject<{
+        oracleId: z.ZodString;
+        probeId: z.ZodNullable<z.ZodString>;
+        state: z.ZodEnum<{
+            abstained: "abstained";
+            bypassed: "bypassed";
+            caught: "caught";
+            confirmed: "confirmed";
+            "false-positive": "false-positive";
+            "infrastructure-error": "infrastructure-error";
+            "judge-error": "judge-error";
+            missed: "missed";
+            "not-applicable": "not-applicable";
+            "oracle-error": "oracle-error";
+            "passed-clean-control": "passed-clean-control";
+            unreached: "unreached";
+        }>;
+        severity: z.ZodEnum<{
+            critical: "critical";
+            low: "low";
+            material: "material";
+        }>;
+        disposition: z.ZodEnum<{
+            held: "held";
+            "not-attempted": "not-attempted";
+            violated: "violated";
+        }>;
+        resolvedFrom: z.ZodNullable<z.ZodString>;
+        corroboration: z.ZodEnum<{
+            agrees: "agrees";
+            disagrees: "disagrees";
+            "not-evaluable": "not-evaluable";
+        }>;
+        selectedObservationIds: z.ZodArray<z.ZodString>;
+        checkResolution: z.ZodNullable<z.ZodType<CheckResolutionValue, unknown, z.core.$ZodTypeInternals<CheckResolutionValue, unknown>>>;
+    }, z.core.$strict>>;
+    uncitedFindings: z.ZodArray<z.ZodString>;
+    coverageGaps: z.ZodArray<z.ZodObject<{
+        rule: z.ZodString;
+        relevancePredicate: z.ZodString;
+        satisfactionPredicate: z.ZodString;
+        satisfied: z.ZodBoolean;
+        severity: z.ZodEnum<{
+            critical: "critical";
+            low: "low";
+            material: "material";
+        }>;
+    }, z.core.$strict>>;
+    strength: z.ZodObject<{
+        denominator: z.ZodString;
+        basis: z.ZodEnum<{
+            measured: "measured";
+            reconstructed: "reconstructed";
+        }>;
+        vector: z.ZodObject<{
+            defect: z.ZodNullable<z.ZodObject<{
+                caught: z.ZodInt;
+                exercised: z.ZodInt;
+                rate: z.ZodNullable<z.ZodNumber>;
+            }, z.core.$strict>>;
+            gameability: z.ZodNullable<z.ZodObject<{
+                caught: z.ZodInt;
+                exercised: z.ZodInt;
+                rate: z.ZodNullable<z.ZodNumber>;
+            }, z.core.$strict>>;
+            'zero-action': z.ZodNullable<z.ZodObject<{
+                caught: z.ZodInt;
+                exercised: z.ZodInt;
+                rate: z.ZodNullable<z.ZodNumber>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+        comparable: z.ZodBoolean;
+        note: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>;
+    remediation: z.ZodObject<{
+        revisionCount: z.ZodInt;
+        cap: z.ZodInt;
+        capSource: z.ZodLiteral<"caller-attested">;
+        lineageChain: z.ZodObject<{
+            lengthConsistent: z.ZodBoolean;
+            noRepeatedDigest: z.ZodBoolean;
+            noGap: z.ZodBoolean;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    mode: z.ZodLiteral<"contract-scoring">;
+    contractVerdict: z.ZodEnum<{
+        CONCERNS: "CONCERNS";
+        FAIL: "FAIL";
+        PASS: "PASS";
+        WAIVED: "WAIVED";
+    }>;
+    systemRecommendationRecorded: z.ZodEnum<{
+        CONCERNS: "CONCERNS";
+        FAIL: "FAIL";
+        PASS: "PASS";
+    }>;
+    systemRecommendationNote: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>], "mode">;
+export type EvidenceArtifact = z.infer<typeof EvidenceArtifact>;