eval-quality 0.1.0 → 0.3.0

package/dist/core/score/quotation.d.ts

@@ -0,0 +1,56 @@
+import type { EvidenceChannelName } from '../schemas/pointer.ts';
+import type { Observation, SealedRunRecord } from '../schemas/sealed-run-record.ts';
+type DefectFinding = Extract<SealedRunRecord['findings'][number], {
+    findingType: 'defect';
+}>;
+type QuotedEvidence = DefectFinding['quotedEvidence'][number];
+export declare function projectChannel(observation: Observation, channel: EvidenceChannelName, artifactPath: string, artifactId?: string | null): string | null;
+export type UnwitnessedQuotation = {
+    readonly findingId: string;
+    /** the position of the quotation within the finding's own list. */
+    readonly quoteIndex: number;
+    readonly channel: EvidenceChannelName;
+    readonly quote: string;
+    /** the observations the finding cited and this audit could read. */
+    readonly citedObservationIds: readonly string[];
+};
+/**
+ * Every defect finding's quoted evidence, checked against the observations that
+ * finding itself cited.
+ *
+ * Over every defect finding in the record regardless of which bucket the
+ * finding maps to, because AD-40 makes an unwitnessed quote a property of the
+ * finding rather than of the probe it maps to. A cited identifier naming no
+ * observation in the record contributes nothing to read, which is a separate
+ * cross-artifact inconsistency and is not this audit's to report.
+ */
+export declare function auditQuotation(record: Pick<SealedRunRecord, 'observations' | 'findings'>): readonly UnwitnessedQuotation[];
+export type ReconstructedDetection = {
+    /**
+     * AD-40 forbids pooling a detection derived this way with a measured catch
+     * rate, so the label travels with the result and is never optional.
+     */
+    readonly basis: 'reconstructed';
+    readonly detected: boolean;
+    readonly witnessObservationIds: readonly string[];
+};
+/**
+ * The containment procedure AD-40 keeps defined for exactly one purpose:
+ * re-deriving detection from records written before observation identifiers
+ * were required.
+ *
+ * Nothing in v0 calls it, and nothing can. At least one observation identifier
+ * has been required on the defect branch since the schema's first version, so
+ * no version of this schema predates the identifier requirement, and AD-11
+ * makes a reader reject an unequal version anyway. The procedure exists for
+ * records from outside this schema entirely.
+ *
+ * It takes the satisfying partition the witness match already computed and asks
+ * which of those observations the finding's own quotations appear in. Detection
+ * so derived is `reconstructed`; the witness match's is `measured`, and the two
+ * are never pooled.
+ */
+export declare function reconstructDetection(finding: {
+    readonly quotedEvidence: readonly QuotedEvidence[];
+}, satisfying: readonly Observation[], artifactPath: string): ReconstructedDetection;
+export {};

package/dist/core/score/quotation.js

@@ -0,0 +1,226 @@
+/**
+ * AD-40's quotation half, kept out of the verdict path on purpose.
+ *
+ * Every defect finding carries two operands: the identifiers of the
+ * observations it relies on, and the verbatim quoted evidence with its channel.
+ * Requiring both without ranking them left the disagreement case with three
+ * conforming answers, and ADR-009 Decision 2 ranks them: "the match resolves
+ * over identifiers alone; quoted evidence that appears in no cited observation
+ * invalidates the run as an AD-32 declared-versus-observed inconsistency." So
+ * the witness match reads identifiers and this module audits quotation, and no
+ * verdict path reads what this module returns.
+ *
+ * The invalidation itself belongs to ingest, which owns no module yet, so
+ * `auditQuotation` ships with no caller by design.
+ *
+ * Nothing in `src/` compared a quote against an observation before this, so
+ * there was no procedure to inherit. Two shipped mechanisms look like
+ * candidates and are not: AD-4's containment operator falls through to `false`
+ * on an object container rather than serializing it, and the canonical digest
+ * returns bytes rather than the string a substring test needs.
+ */
+import { serialize } from '../canonical/canonicalize.js';
+/**
+ * One evidence channel of one observation, rendered as the text a quotation is
+ * asked to be a substring of.
+ *
+ * `stdout` and `stderr` project as themselves; `response-status` and
+ * `exit-code` through the ordinary integer rendering; `response-body`,
+ * `response-headers`, and `call-inputs` through the same RFC 8785 serialization
+ * the digest uses.
+ *
+ * No case folding and no whitespace normalization: AD-23 requires the evidence
+ * verbatim, and a normalizing match would accept a quote the record does not
+ * contain. Canonical serialization re-spells a body with sorted keys and no
+ * whitespace, so a quote taken from a pretty-printed rendering is not a
+ * substring of it. The record stores JSON values and has no pretty-printed form
+ * to quote.
+ *
+ * A `null` channel projects to nothing and witnesses nothing. On
+ * `response-body` that also swallows a body that genuinely was JSON `null`,
+ * which is the schema's own stated cost of one uniform spelling for "absent".
+ *
+ * Should canonicalization fault on a caller's record, the fault propagates,
+ * which is what keeps this procedure from being circular with it.
+ */
+/**
+ * One tagged observed value as the text a quotation is compared against. A
+ * text body is its own value; a JSON body is its canonical serialisation, the
+ * same one `response-body` gets; an absent channel has no text.
+ */
+function observedText(body, artifactPath) {
+    if (body.kind === 'absent')
+        return null;
+    if (body.kind === 'text')
+        return body.value;
+    return serialize(body.value, artifactPath);
+}
+export function projectChannel(observation, channel, artifactPath, artifactId = null) {
+    switch (channel) {
+        case 'stdout':
+            return observedText(observation.stdout, artifactPath);
+        case 'stderr':
+            return observedText(observation.stderr, artifactPath);
+        case 'artifact': {
+            // One named file's own text. Serializing the whole map instead was
+            // wrong twice over: it escaped every newline and quotation mark, so
+            // a quotation from a file with more than one line could never match,
+            // and it searched every file at once, so a quotation from a file the
+            // finding did not cite matched anyway.
+            if (artifactId === null)
+                return null;
+            if (!Object.hasOwn(observation.artifacts, artifactId))
+                return null;
+            const written = observation.artifacts[artifactId];
+            return written === undefined ? null : observedText(written, artifactPath);
+        }
+        case 'response-status':
+            return observation.responseStatus === null
+                ? null
+                : observation.responseStatus.toString();
+        case 'exit-code':
+            return observation.exitCode === null
+                ? null
+                : observation.exitCode.toString();
+        case 'response-body':
+            return observation.responseBody === null
+                ? null
+                : serialize(observation.responseBody, artifactPath);
+        case 'response-headers':
+            return observation.responseHeaders === null
+                ? null
+                : serialize(observation.responseHeaders, artifactPath);
+        case 'call-inputs':
+            return serialize(observation.callInputs, artifactPath);
+    }
+}
+/**
+ * Whether one quotation appears in one observation's named channel, verbatim.
+ */
+function quotationWitnessed(quoted, observation, artifactPath) {
+    const projected = projectChannel(observation, quoted.channel, artifactPath, quoted.artifactId);
+    // A null projection witnesses nothing, and `false` is the answer: an
+    // optional chain here would hand a caller `undefined` where the return type
+    // says boolean.
+    if (projected === null)
+        return false;
+    return projected.includes(quoted.quote);
+}
+/** total over strings, so a tie is a genuine equality rather than a coin toss. */
+const order = (a, b) => (a < b ? -1 : a > b ? 1 : 0);
+/**
+ * Every defect finding's quoted evidence, checked against the observations that
+ * finding itself cited.
+ *
+ * Over every defect finding in the record regardless of which bucket the
+ * finding maps to, because AD-40 makes an unwitnessed quote a property of the
+ * finding rather than of the probe it maps to. A cited identifier naming no
+ * observation in the record contributes nothing to read, which is a separate
+ * cross-artifact inconsistency and is not this audit's to report.
+ */
+export function auditQuotation(record) {
+    // Indexed to a list rather than a value. `observations` is refined unique on
+    // `sequence` and not on `observationId`, so two observations may share an
+    // identifier, and a last-write-wins map would turn the existential below into
+    // a pick decided by array position: one permutation of a record answers that
+    // a quotation is witnessed and the other that it is not. AD-40 states the
+    // rule as "at least one observation satisfying the condition", so a repeated
+    // identifier names both and the `.some` ranges over both.
+    const byId = new Map();
+    for (const observation of record.observations) {
+        const sharing = byId.get(observation.observationId);
+        if (sharing === undefined) {
+            byId.set(observation.observationId, [observation]);
+        }
+        else {
+            sharing.push(observation);
+        }
+    }
+    const unwitnessed = [];
+    for (const finding of record.findings) {
+        if (finding.findingType !== 'defect')
+            continue;
+        // Deduplicated and sorted by identifier. `observationIds` is an array with
+        // no uniqueness refinement, so a finding may cite one observation twice,
+        // and carrying the citation array's order into `citedObservationIds` would
+        // put a position with no declared meaning on the payload. The identifier
+        // list stays deduplicated even where two observations share one: it names
+        // what the finding cited, not what resolved.
+        const citedObservationIds = [];
+        const cited = [];
+        for (const identifier of [...new Set(finding.observationIds)].sort(order)) {
+            const sharing = byId.get(identifier);
+            if (sharing === undefined)
+                continue;
+            citedObservationIds.push(identifier);
+            cited.push(...sharing);
+        }
+        const artifactPath = `SealedRunRecord.findings[findingId=${finding.findingId}]`;
+        finding.quotedEvidence.forEach((quoted, quoteIndex) => {
+            const witnessed = cited.some((observation) => quotationWitnessed(quoted, observation, artifactPath));
+            if (witnessed)
+                return;
+            unwitnessed.push({
+                findingId: finding.findingId,
+                quoteIndex,
+                channel: quoted.channel,
+                quote: quoted.quote,
+                citedObservationIds,
+            });
+        });
+    }
+    // `findings` carries no ordering field, so reading it in array order would
+    // make the result depend on a position NFR9 forbids reading. Sorted by
+    // finding identifier, then by the quotation's index within that finding,
+    // which is the one order the record itself declares.
+    //
+    // `findingId` and `quoteIndex` do not separate every pair: `findings` has no
+    // uniqueness refinement, so two findings may share an identifier and each
+    // carry an unwitnessed quote at index 0, and a stable sort would then fall
+    // back to the position this sort exists to stop reading. Unlike two entries
+    // that tie on everything, those two are distinguishable — different quote,
+    // different channel, two basis lines that say different things — so the key
+    // runs to the whole payload.
+    //
+    // `quote` is compared directly rather than through a joined key. It is free
+    // text and may contain any code point including U+0000, so no delimiter is
+    // below every character it can carry. `citedObservationIds` may be joined:
+    // its members are `Identifier`, whose lowest code point is U+002D.
+    return unwitnessed.sort((a, b) => order(a.findingId, b.findingId) ||
+        a.quoteIndex - b.quoteIndex ||
+        order(a.channel, b.channel) ||
+        order(a.quote, b.quote) ||
+        order(a.citedObservationIds.join('\u0000'), b.citedObservationIds.join('\u0000')));
+}
+/**
+ * The containment procedure AD-40 keeps defined for exactly one purpose:
+ * re-deriving detection from records written before observation identifiers
+ * were required.
+ *
+ * Nothing in v0 calls it, and nothing can. At least one observation identifier
+ * has been required on the defect branch since the schema's first version, so
+ * no version of this schema predates the identifier requirement, and AD-11
+ * makes a reader reject an unequal version anyway. The procedure exists for
+ * records from outside this schema entirely.
+ *
+ * It takes the satisfying partition the witness match already computed and asks
+ * which of those observations the finding's own quotations appear in. Detection
+ * so derived is `reconstructed`; the witness match's is `measured`, and the two
+ * are never pooled.
+ */
+export function reconstructDetection(finding, satisfying, artifactPath) {
+    // A finding quoting nothing proves nothing, which the schema already forbids
+    // on this branch; a record from outside it can still present the shape, and
+    // an `every` over an empty list would otherwise report every satisfying
+    // observation as a witness.
+    const witnessObservationIds = finding.quotedEvidence.length === 0
+        ? []
+        : satisfying
+            .filter((observation) => finding.quotedEvidence.every((quoted) => quotationWitnessed(quoted, observation, artifactPath)))
+            .map((observation) => observation.observationId);
+    return {
+        basis: 'reconstructed',
+        detected: witnessObservationIds.length > 0,
+        witnessObservationIds,
+    };
+}

package/dist/core/score/reduce-trials.d.ts

@@ -0,0 +1,80 @@
+/**
+ * AD-7's trial-set reducer, closing Owed item 1: repeated trials had no
+ * reducer, so the default three-trial minimum was unreachable.
+ *
+ * Pure and total: no clock, filesystem, or randomness, and nothing thrown for
+ * a domain input. Stage one, collapsing several outcome resolutions for one
+ * `(probeId, trialIndex)` down to one vote, is a lookup rather than a genuine
+ * multi-value fold, because AD-40's discriminating condition pairs a probe
+ * with exactly one designated oracle; the caller performs that lookup and
+ * this module receives the resulting one-vote-per-trial sequence directly.
+ * Stage two, folding across trials for one probe, is `reduceTrialSet` below.
+ */
+import type { InvalidatedAttempt, OUTCOME_STATES } from '../schemas/evidence-artifact.ts';
+type OutcomeStateValue = (typeof OUTCOME_STATES)[number];
+/**
+ * The reducer's own vote, narrower than `resolveOutcome`'s
+ * `OutcomeResolution`: only `state` decides which of the three groups below a
+ * trial falls into, and the reducer has no use for a rule identifier, a
+ * resolved-from finding, or a corroboration value.
+ */
+export type TrialVote = {
+    readonly state: OutcomeStateValue;
+};
+/**
+ * The reducer's three-way grouping of AD-6's closed twelve states. Three
+ * invalidate a trial for this probe and are excluded from both the vote and
+ * the valid-trial count; two leave a trial's probe unvoted without
+ * invalidating it, so an unexercised trial contributes to neither the
+ * numerator nor the denominator; the remaining seven are valid votes, of
+ * which only `caught` counts toward the numerator.
+ */
+export declare const TRIAL_VOTE_STATES: {
+    readonly invalidating: readonly ["oracle-error", "judge-error", "infrastructure-error"];
+    readonly unvoted: readonly ["not-applicable", "unreached"];
+    readonly voted: readonly ["caught", "confirmed", "missed", "abstained", "bypassed", "passed-clean-control", "false-positive"];
+};
+export type TrialVoteState = keyof typeof TRIAL_VOTE_STATES;
+export type TrialSetResult = {
+    /** whether at least one trial voted, i.e. `validCount > 0`. */
+    readonly exercised: boolean;
+    /** `caughtCount / validCount > catchThreshold`, strict, so a tie is unreachable. */
+    readonly caught: boolean;
+    /** the count of voted (valid, non-`unvoted`) trials: the majority's denominator. */
+    readonly validCount: number;
+    /** the count of voted trials whose state is `caught`: the majority's numerator. */
+    readonly caughtCount: number;
+    readonly invalidatedAttempts: readonly InvalidatedAttempt[];
+};
+/**
+ * Folds one probe's trial votes to one result. `votes[i]`'s position is the
+ * attempt number `i + 1`, since stage one has already reduced each trial's
+ * outcome resolutions to one vote per `(probeId, trialIndex)`.
+ *
+ * A probe with zero voted trials is `exercised: false` and contributes
+ * nothing to `ClassStrength`; `caught` is `false` in that case too, since a
+ * majority over zero trials decides nothing.
+ *
+ * `catchThreshold` is checked against `ScoringPolicy.catchThreshold`'s own
+ * declared domain (`.min(0).max(1)`) and a `vote.state` outside the closed
+ * twelve is checked explicitly, rather than silently falling through into
+ * `votedStates.push`: both were reachable only through a type-system bypass
+ * while this reducer shipped with no caller, and now that `score.ts` calls
+ * it for real, a bypass is exactly the input this pure function must still
+ * answer without absorbing it silently.
+ *
+ * Both checks are written to survive a bypass that also defeats the naive
+ * form of the check, not only a bypass of the declared type. `catchThreshold`
+ * is asserted a finite primitive `number` before the range comparison runs:
+ * `>=`/`<=` coerce their operands, so `null`, a numeric string, or a boxed
+ * `Number` would each satisfy `0 <= x <= 1` without ever being the number the
+ * range check means to bound. `vote.state`'s lookup uses `Object.hasOwn`
+ * rather than trusting `=== undefined`: `TRIAL_VOTE_STATE_OF` is a plain
+ * object and so inherits `Object.prototype`, and a state string that happens
+ * to name an inherited member (`"toString"`, `"constructor"`,
+ * `"hasOwnProperty"`, `"valueOf"`) resolves to that inherited function
+ * instead of `undefined`, which would silently clear the `=== undefined`
+ * guard and vote the bogus state in.
+ */
+export declare function reduceTrialSet(votes: readonly TrialVote[], catchThreshold: number): TrialSetResult;
+export {};

package/dist/core/score/reduce-trials.js

@@ -0,0 +1,90 @@
+/**
+ * The reducer's three-way grouping of AD-6's closed twelve states. Three
+ * invalidate a trial for this probe and are excluded from both the vote and
+ * the valid-trial count; two leave a trial's probe unvoted without
+ * invalidating it, so an unexercised trial contributes to neither the
+ * numerator nor the denominator; the remaining seven are valid votes, of
+ * which only `caught` counts toward the numerator.
+ */
+export const TRIAL_VOTE_STATES = {
+    invalidating: ['oracle-error', 'judge-error', 'infrastructure-error'],
+    unvoted: ['not-applicable', 'unreached'],
+    voted: [
+        'caught',
+        'confirmed',
+        'missed',
+        'abstained',
+        'bypassed',
+        'passed-clean-control',
+        'false-positive',
+    ],
+};
+/**
+ * A total map from every one of the twelve states to its group, built once
+ * from `TRIAL_VOTE_STATES` rather than duplicated as a second literal that
+ * could drift from it.
+ */
+const TRIAL_VOTE_STATE_OF = Object.fromEntries(Object.entries(TRIAL_VOTE_STATES).flatMap(([group, states]) => states.map((state) => [state, group])));
+/**
+ * Folds one probe's trial votes to one result. `votes[i]`'s position is the
+ * attempt number `i + 1`, since stage one has already reduced each trial's
+ * outcome resolutions to one vote per `(probeId, trialIndex)`.
+ *
+ * A probe with zero voted trials is `exercised: false` and contributes
+ * nothing to `ClassStrength`; `caught` is `false` in that case too, since a
+ * majority over zero trials decides nothing.
+ *
+ * `catchThreshold` is checked against `ScoringPolicy.catchThreshold`'s own
+ * declared domain (`.min(0).max(1)`) and a `vote.state` outside the closed
+ * twelve is checked explicitly, rather than silently falling through into
+ * `votedStates.push`: both were reachable only through a type-system bypass
+ * while this reducer shipped with no caller, and now that `score.ts` calls
+ * it for real, a bypass is exactly the input this pure function must still
+ * answer without absorbing it silently.
+ *
+ * Both checks are written to survive a bypass that also defeats the naive
+ * form of the check, not only a bypass of the declared type. `catchThreshold`
+ * is asserted a finite primitive `number` before the range comparison runs:
+ * `>=`/`<=` coerce their operands, so `null`, a numeric string, or a boxed
+ * `Number` would each satisfy `0 <= x <= 1` without ever being the number the
+ * range check means to bound. `vote.state`'s lookup uses `Object.hasOwn`
+ * rather than trusting `=== undefined`: `TRIAL_VOTE_STATE_OF` is a plain
+ * object and so inherits `Object.prototype`, and a state string that happens
+ * to name an inherited member (`"toString"`, `"constructor"`,
+ * `"hasOwnProperty"`, `"valueOf"`) resolves to that inherited function
+ * instead of `undefined`, which would silently clear the `=== undefined`
+ * guard and vote the bogus state in.
+ */
+export function reduceTrialSet(votes, catchThreshold) {
+    if (typeof catchThreshold !== 'number' || !Number.isFinite(catchThreshold)) {
+        throw new TypeError(`reduceTrialSet: catchThreshold ${String(catchThreshold)} is not a finite number`);
+    }
+    if (!(catchThreshold >= 0 && catchThreshold <= 1)) {
+        throw new TypeError(`reduceTrialSet: catchThreshold ${catchThreshold} is outside ScoringPolicy's declared 0..1 domain`);
+    }
+    const invalidatedAttempts = [];
+    const votedStates = [];
+    votes.forEach((vote, index) => {
+        if (!Object.hasOwn(TRIAL_VOTE_STATE_OF, vote.state)) {
+            throw new TypeError(`reduceTrialSet: vote ${index + 1} carries an out-of-domain state "${vote.state}"`);
+        }
+        const group = TRIAL_VOTE_STATE_OF[vote.state];
+        if (group === 'invalidating') {
+            invalidatedAttempts.push({ attempt: index + 1, reason: vote.state });
+            return;
+        }
+        if (group === 'unvoted')
+            return;
+        votedStates.push(vote.state);
+    });
+    const validCount = votedStates.length;
+    const caughtCount = votedStates.filter((state) => state === 'caught').length;
+    const exercised = validCount > 0;
+    // Divide rather than multiply: `caughtCount > catchThreshold * validCount`
+    // rounds `catchThreshold * validCount` under IEEE-754 for some non-power-of-
+    // two thresholds (0.29 * 100 = 28.999999999999996), which turns a
+    // mathematically exact tie (29/100 = 0.29) into a false caught. Division by
+    // a positive integer `validCount` has no such failure mode here.
+    const caught = exercised && caughtCount / validCount > catchThreshold;
+    return { exercised, caught, validCount, caughtCount, invalidatedAttempts };
+}

package/dist/core/score/score.d.ts

@@ -0,0 +1,72 @@
+/**
+ * AD-24's score stage: the one orchestration over the reference functions
+ * `core/score/` already ships, closing owed item 1's remaining half (a
+ * trial-set shape for `validated-observations`) and giving `score.module`
+ * its first real value.
+ *
+ * The body lifts `scripts/worked-example-target.ts:1071-1381`'s order
+ * rather than designing a second one, generalised two ways that file never
+ * needed: over `readonly ValidatedObservations[]` instead of one record, and
+ * without ever throwing on a domain input. Every `fail()` call that script
+ * used to stop on a malformed-but-schema-legal shape (a rejected probe, a
+ * clean-control or canary probe with no seeded defect, an oracle with no
+ * check, a resolution naming a finding the trial does not carry) is replaced
+ * here by a graceful, documented fallback: a `schema-parse-failure` already
+ * happened at the application boundary before any of these values reached
+ * this function, so nothing left to see here is a reason to crash.
+ *
+ * Two of `AssessmentCommon`'s fields have no source among this stage's five
+ * declared inputs and are not among its two caller-supplied parameters
+ * either: `evidenceIntegrity.disclosure` (`EvidenceDisclosure`, which lives
+ * only on `SealedRunRecord`, a field `ingest`'s product does not carry
+ * through) and `remediationState` (`AD-12`'s remediation chain, which needs
+ * a caller-presented ancestor sequence score's five inputs never carry, only
+ * the current contract). Both arrive declared with a neutral value, exactly
+ * the posture `ladder.ts`'s own `EvidenceIntegrityInputs` doc comment
+ * already states for `overTruncated`, `unavailable`, and
+ * `internallyInconsistent`: "they arrive declared rather than derived."
+ * `disclosure` and `remediationState` join them on the same reasoning
+ * rather than a new one.
+ */
+import type { ValidatedObservations } from '../ingest/ingest.ts';
+import { type EvalContract } from '../schemas/eval-contract.ts';
+import type { Outcome } from '../schemas/evidence-artifact.ts';
+import type { Probe } from '../schemas/probe.ts';
+import type { ScoringPolicy } from '../schemas/scoring-policy.ts';
+import type { ScoreStage } from '../stage-contracts.ts';
+import type { ContractAssessment, LadderResolution, ProductionAssessment } from './ladder.ts';
+import { type SealedProbeSet } from './qualification.ts';
+import { type TrialSetResult } from './reduce-trials.ts';
+/**
+ * `score`'s owned product: the assessment/ladder pairing AD-24 names, "the
+ * outcome and verdict values emit serializes", widened with eight more
+ * fields `emit` needs to mint an `EvidenceArtifact` and cannot re-derive from
+ * that pairing alone. Every one of the eight is a value this function
+ * already holds locally or already receives as a parameter; none is fetched
+ * anew, only carried one step further. Still not a new artifact: a plain
+ * TypeScript type with no Zod schema, matching `ValidatedObservations`'
+ * precedent.
+ */
+export type ScoredOutcomesAndVerdict = {
+    readonly assessment: ProductionAssessment | ContractAssessment;
+    readonly ladder: LadderResolution;
+    /** the trial set's own run identifier, read off the first trial the same way `mode`/`evaluatorRecommendation` are. */
+    readonly runId: string;
+    readonly contract: EvalContract;
+    readonly policy: ScoringPolicy;
+    readonly probe: Probe;
+    readonly sealedProbes: SealedProbeSet;
+    /** this probe's own AD-7 trial-set fold, keyed by `emit` under `probe.probeId` to build the strength vector. */
+    readonly trialSetResult: TrialSetResult;
+    /** the full `EvidenceArtifact.outcomes` shape, a parallel array to `ScoredOutcome[]` above: `ScoredOutcome` carries `resolution` but not `disposition` or the raw `CheckResolution` tree this shape needs, so the two are not reconstructible from one another. */
+    readonly outcomes: readonly Outcome[];
+    /** every finding across every trial citing no oracle, per `outcome.ts`'s `uncitedFindingIds`. */
+    readonly uncitedFindings: readonly string[];
+};
+/**
+ * The stage. Signature order matches `ScoreStage`'s own: the five declared
+ * artifact inputs, then `waiver` and `evaluationFault`, the two documented
+ * caller-supplied parameters -- neither has a source among those five, and
+ * each arrives named and explicit rather than a hardcoded literal.
+ */
+export declare const score: ScoreStage<ValidatedObservations, ScoredOutcomesAndVerdict>;