eval-quality 0.1.0 → 0.3.0

package/dist/core/score/outcome-table.js

@@ -0,0 +1,172 @@
+/**
+ * AD-33's published decision table, emitted from the four rule tables the
+ * procedure decides with and from the fixture set's resolved cases.
+ *
+ * Pure, so the writer and the drift check cannot disagree about bytes. Its
+ * inputs are arguments, so the fixture set stays under `tests/` and nothing
+ * here reaches for it.
+ *
+ * AD-33 establishes that a cell per input tuple, each with a positive and a
+ * negative fixture, is arithmetically out of reach, and asks for a total
+ * function whose enumerated output is published. The enumerated output is the
+ * four rule tables, the named structural constraints with the infeasible pairs
+ * derived from them, and five censuses over the fixture set. Every census
+ * count is asserted at least one here, so a rule or a state losing its last
+ * case fails the build.
+ */
+import { OUTCOME_STATES } from '../schemas/evidence-artifact.js';
+import { CORROBORATION_RULES, INVALIDATING_CONDITIONS, OUTCOME_RULES, WAIVER_RULES, } from './outcome.js';
+/** `|` escaped: a guard is prose, and a broken table is still byte-stable. */
+const cell = (text) => text.replace(/\|/g, '\\|');
+const row = (cells) => `| ${cells.map(cell).join(' | ')} |`;
+const table = (headers, rows) => [
+    row(headers),
+    `| ${headers.map(() => '---').join(' | ')} |`,
+    ...rows.map(row),
+];
+const code = (text) => `\`${text}\``;
+const HEADER = [
+    '# AD-33 outcome decision',
+    '',
+    'Generated by `npm run generate:ad33-table` from the four rule tables in',
+    '`src/core/score/outcome.ts` and from the fixture set that exercises them. Guarded by',
+    '`npm run check:ad33-table`, a byte-exact drift check. A hand edit fails that check; regenerate.',
+    '',
+    'The procedure is pure and total: every input value returns a defined resolution and nothing',
+    'throws. Stage A evaluates the invalidating conditions independently of the state, so no',
+    'condition is masked by another that fired first. Stage B is a first-match ladder. Stage C',
+    'adjusts the state for a waiver. Corroboration is decided after the state.',
+];
+/**
+ * Counts each key across the cases, then reports the first key no case
+ * reached. A zero census is what a narrowed fixture set looks like, and no
+ * regeneration repairs it.
+ */
+const census = (label, keys, countOf) => keys.map((key) => {
+    const count = countOf(key);
+    if (count === 0) {
+        throw new Error(`outcomeDecisionTable: no case reaches ${label} ${key}, so the published census would claim coverage the fixture set does not have`);
+    }
+    return [code(key), String(count)];
+});
+/** The whole document. Throws a worded diagnosis on an empty census cell. */
+export function outcomeDecisionTable(cases, constraints) {
+    if (cases.length === 0) {
+        throw new Error('outcomeDecisionTable: no resolved cases, so every census below would be empty');
+    }
+    const seen = new Set();
+    for (const constraint of constraints.constraints) {
+        if (seen.has(constraint.id)) {
+            throw new Error(`outcomeDecisionTable: two structural constraints share the identifier ${constraint.id}`);
+        }
+        seen.add(constraint.id);
+    }
+    if (constraints.constraints.length === 0) {
+        throw new Error('outcomeDecisionTable: no structural constraints, so the infeasible pairs below rest on nothing');
+    }
+    const conditionRows = INVALIDATING_CONDITIONS.map((condition) => [
+        code(condition.id),
+        condition.guard,
+    ]);
+    const ladderRows = OUTCOME_RULES.map((rule, index) => [
+        String(index + 1),
+        code(rule.id),
+        rule.guard,
+        code(rule.state),
+        rule.resolvesFromCitation ? 'yes' : 'no',
+    ]);
+    const waiverRows = WAIVER_RULES.map((rule) => [
+        code(rule.id),
+        rule.guard,
+        `state becomes ${code(rule.state)}`,
+    ]);
+    const corroborationRows = CORROBORATION_RULES.map((rule, index) => [
+        String(index + 1),
+        code(rule.id),
+        rule.guard,
+        rule.value,
+    ]);
+    const constraintRows = constraints.constraints.map((constraint) => [
+        code(constraint.id),
+        constraint.implication,
+    ]);
+    const infeasibleRows = constraints.infeasiblePairs.map((pair) => [
+        code(pair.left),
+        code(pair.right),
+    ]);
+    const stateCensus = census('the AD-6 state', OUTCOME_STATES, (key) => cases.filter((resolved) => resolved.state === key).length);
+    const ladderCensus = census('the ladder rule', OUTCOME_RULES.map((rule) => rule.id), (key) => cases.filter((resolved) => resolved.rule === key).length);
+    const waiverCensus = census('the waiver rule', WAIVER_RULES.map((rule) => rule.id), (key) => cases.filter((resolved) => resolved.waiverRule === key).length);
+    const corroborationCensus = census('the corroboration rule', CORROBORATION_RULES.map((rule) => rule.id), (key) => cases.filter((resolved) => resolved.corroborationRule === key).length);
+    const conditionCensus = census('the invalidating condition', INVALIDATING_CONDITIONS.map((condition) => condition.id), (key) => cases.filter((resolved) => resolved.invalidatingConditions.some((fired) => fired === key)).length);
+    const lines = [
+        ...HEADER,
+        '',
+        '## Invalidating conditions',
+        '',
+        'Evaluated independently of the state ladder. Every one that holds is returned, sorted.',
+        '',
+        ...table(['Condition', 'Holds when'], conditionRows),
+        '',
+        '## The state ladder',
+        '',
+        'First match wins. The final row carries the stated negation of every guard above it.',
+        '',
+        ...table(['#', 'Rule', 'Guard', 'State', 'Resolves from the citation'], ladderRows),
+        '',
+        '## The waiver adjustment',
+        '',
+        'Applied to the provisional state the ladder produced. Neither rule fires on a waiver of',
+        '`none` or `expired`, and neither fires over a state outside the waivable group.',
+        '',
+        ...table(['Rule', 'Holds when', 'Effect'], waiverRows),
+        '',
+        '## Corroboration',
+        '',
+        'Decided after the final state. First match wins and no row is an `otherwise`.',
+        '',
+        ...table(['#', 'Rule', 'Holds when', 'Value'], corroborationRows),
+        '',
+        '## Structural constraints',
+        '',
+        'Named implications the declared input domains satisfy. Each leaves its offending tuple',
+        'representable and resolvable. The four `cannot-qualify` constraints route theirs to the',
+        'unqualified-probe rule, since the gate that names them sets `probeQualified` false; the other',
+        'three describe what the upstream records can carry, and a tuple violating one still resolves.',
+        '',
+        ...table(['Constraint', 'Implication'], constraintRows),
+        '',
+        '## Infeasible pairs',
+        '',
+        'Pairs of domain values no tuple satisfying the constraints above contains, derived from',
+        'those constraints themselves.',
+        '',
+        ...table(['Left', 'Right'], infeasibleRows),
+        '',
+        '## Census',
+        '',
+        `Over the ${cases.length} resolved fixture cases. Every count is at least one, checked when this`,
+        'document is built.',
+        '',
+        '### By state',
+        '',
+        ...table(['State', 'Cases'], stateCensus),
+        '',
+        '### By ladder rule',
+        '',
+        ...table(['Rule', 'Cases'], ladderCensus),
+        '',
+        '### By waiver rule',
+        '',
+        ...table(['Rule', 'Cases'], waiverCensus),
+        '',
+        '### By corroboration rule',
+        '',
+        ...table(['Rule', 'Cases'], corroborationCensus),
+        '',
+        '### By invalidating condition',
+        '',
+        ...table(['Condition', 'Cases'], conditionCensus),
+    ];
+    return `${lines.join('\n')}\n`;
+}

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

@@ -0,0 +1,466 @@
+/**
+ * AD-33's reference decision procedure: the one component that assigns an AD-6
+ * outcome state.
+ *
+ * Pure and total. Every input value returns a defined resolution, nothing
+ * throws, and no clock, filesystem, or randomness is read. A `RuntimeFault`
+ * raised below propagates undecorated, because AD-28's fault vocabulary and
+ * AD-6's state vocabulary are disjoint.
+ *
+ * Three stages over one input record. Stage A evaluates ten invalidating
+ * conditions independently and unions them, so AD-21 receives every condition
+ * that fired and a persistent judge fault cannot mask a real regression.
+ * Stage B is an ordered first-match ladder of twenty rules producing a
+ * provisional state. Stage C adjusts that state for a waiver over a single
+ * waivable failure. Corroboration is a fourth ordered table decided after the
+ * state, which is how a disposition and a declined citation reach the outcome
+ * without deciding one, since AD-3 forbids a check resolution as the source of
+ * a state.
+ *
+ * All four tables are data, so `outcome-table.ts` emits the published decision
+ * table from them and a byte-exact drift check compares it against the
+ * committed document.
+ */
+import type { CheckResolutionValue, CORROBORATION_VALUES, OUTCOME_STATES, UncitedFindingGap } from '../schemas/evidence-artifact.ts';
+import type { Polarity } from '../schemas/expression.ts';
+import type { Probe } from '../schemas/probe.ts';
+import type { OracleDisposition, SealedRunRecord } from '../schemas/sealed-run-record.ts';
+import type { StepSelection } from './selection.ts';
+import type { ProbeWitnessMatch } from './witness.ts';
+type OutcomeStateValue = (typeof OUTCOME_STATES)[number];
+type CorroborationValue = (typeof CORROBORATION_VALUES)[number];
+/**
+ * The four buckets `mapFindings` sorts a defect finding into, each carrying a
+ * distinct AD consequence. Keyed on the cited finding's own `probeId`, which
+ * is unrelated to whatever probe an outcome row is about.
+ */
+export declare const FINDING_BUCKETS: readonly ["mapped", "unmapped", "dangling", "signatureless"];
+export type FindingBucketValue = (typeof FINDING_BUCKETS)[number];
+/**
+ * AD-6 qualifies `not-applicable` by an unexpired waiver satisfying AD-5.
+ * Completeness is settled at compile time by `checkWaiverCompleteness`, and
+ * `core/score` reads no clock, so both expiry and whether the waiver's opaque
+ * context condition was met arrive already decided.
+ */
+export declare const WAIVER_STATES: readonly ['none', 'applied-condition-met', 'applied-condition-unmet', 'expired'];
+export type WaiverStateValue = (typeof WAIVER_STATES)[number];
+/**
+ * AD-17 names no field for a malformed judge response and `JudgeResult` is
+ * keyed by rubric criterion, so conduct arrives per oracle. `absent` is the
+ * ordinary value: a contract with no rubric produces no judge call.
+ */
+export declare const JUDGE_CONDUCT_STATES: readonly ['absent', 'conforming', 'malformed'];
+export type JudgeConductValue = (typeof JUDGE_CONDUCT_STATES)[number];
+/** The defect finding whose `oracleId` is this oracle, with its bucket. */
+export type CitedFinding = {
+    readonly findingId: string;
+    readonly bucket: FindingBucketValue;
+};
+/**
+ * The fifteen declared inputs. The upstream records travel whole, so the
+ * resolution can return the finding it resolved from and the observation
+ * identifiers it read, which is what AD-33 records on the outcome.
+ *
+ * `disposition` is the whole record, because Stage A and the corroboration
+ * rules read its `observationIds`.
+ *
+ * `probeSigned` is the one field no rule reads. It is declared because the
+ * published table states the relation AD-40 fixes between a signature and a
+ * witness, and a caller assembling a row from a probe already holds it.
+ */
+export type OutcomeInputs = {
+    readonly required: boolean;
+    readonly disposition: OracleDisposition | null;
+    readonly citedFinding: CitedFinding | null;
+    readonly witness: ProbeWitnessMatch | null;
+    readonly selections: readonly StepSelection[];
+    readonly selectorAmbiguity: boolean;
+    readonly checkResolution: CheckResolutionValue['resolution'] | null;
+    readonly polarity: Polarity;
+    readonly probeClass: Probe['probeClass'] | null;
+    readonly expectedClean: boolean | null;
+    readonly probeSigned: boolean | null;
+    readonly probeQualified: boolean | null;
+    readonly waiver: WaiverStateValue;
+    readonly judgeConduct: JudgeConductValue;
+    readonly evaluationFault: boolean;
+};
+export type OutcomeResolution = {
+    readonly rule: OutcomeRuleId;
+    readonly waiverRule: WaiverRuleId | null;
+    readonly corroborationRule: CorroborationRuleId;
+    readonly state: OutcomeStateValue;
+    readonly corroboration: CorroborationValue;
+    readonly resolvedFrom: string | null;
+    readonly selectedObservationIds: readonly string[];
+    /** an `unmapped` or `signatureless` citation the state declined to resolve from. */
+    readonly declinedFindingIds: readonly string[];
+    readonly invalidatingConditions: readonly InvalidatingCondition[];
+};
+declare const probeUnqualified: (inputs: OutcomeInputs) => boolean;
+declare const checkExaminedNothing: (inputs: OutcomeInputs) => boolean;
+declare const dispositionUnsupported: (inputs: OutcomeInputs) => boolean;
+/**
+ * `violated` with no defect finding, `held` with one, or `not-attempted` with
+ * one. A `not-attempted` citing observations is well supported: those are the
+ * observations showing why the evaluator could not proceed. Its contradiction
+ * is a defect finding filed against the same oracle.
+ */
+declare const dispositionContradictsEvidence: (inputs: OutcomeInputs) => boolean;
+declare const citationDeclined: (inputs: OutcomeInputs) => boolean;
+/**
+ * A canary carries no signature, so it has no witness and step reachability is
+ * the only proxy for whether the evaluator took the path. AD-33 names
+ * punishing a contract for the evaluator's path choice as an anti-goal, so the
+ * condition and its ladder row share this guard.
+ */
+declare const canaryUndetected: (inputs: OutcomeInputs) => boolean;
+/**
+ * Stage A. Ten predicates evaluated independently of the state ladder, so a
+ * condition is never masked by another that fired first. Every one that holds
+ * is returned.
+ *
+ * Nine reach AD-21's Invalid rung through an AD-6 invalidating state or, for
+ * `disposition-missing`, by name. `unsupported-disposition` produces no state
+ * and is not in that enumeration; the half enforced here is the corroboration,
+ * which is AD-33's own requirement that an unsupported disposition invalidates
+ * cross-artifact agreement.
+ */
+export declare const INVALIDATING_CONDITIONS: readonly [{
+    readonly id: 'evaluation-fault';
+    readonly guard: 'an AD-26 evaluation fault was recorded';
+    readonly holds: (inputs: OutcomeInputs) => boolean;
+}, {
+    readonly id: 'judge-malformed';
+    readonly guard: 'judge conduct `malformed`';
+    readonly holds: (inputs: OutcomeInputs) => boolean;
+}, {
+    readonly id: 'unqualified-probe-in-sealed-set';
+    readonly guard: 'a probe is present and its qualification failed';
+    readonly holds: typeof probeUnqualified;
+}, {
+    readonly id: 'dangling-probe-citation';
+    readonly guard: "the cited finding's bucket is `dangling`";
+    readonly holds: (inputs: OutcomeInputs) => boolean;
+}, {
+    readonly id: 'unwitnessed-detection-claim';
+    readonly guard: 'witness result `unwitnessed-claim`';
+    readonly holds: (inputs: OutcomeInputs) => boolean;
+}, {
+    readonly id: 'vacuous-signature';
+    readonly guard: 'witness result `vacuous`';
+    readonly holds: (inputs: OutcomeInputs) => boolean;
+}, {
+    readonly id: 'selector-ambiguity';
+    readonly guard: 'a step matched several observations under a single-valued cardinality';
+    readonly holds: (inputs: OutcomeInputs) => boolean;
+}, {
+    readonly id: 'canary-non-detection';
+    readonly guard: 'class `canary`, some selection resolved other than `none`, and no defect finding cites the oracle';
+    readonly holds: typeof canaryUndetected;
+}, {
+    readonly id: 'unsupported-disposition';
+    readonly guard: 'the disposition is `held` or `violated` with empty `observationIds`';
+    readonly holds: typeof dispositionUnsupported;
+}, {
+    readonly id: 'disposition-missing';
+    readonly guard: 'the oracle is required and its disposition is `null`';
+    readonly holds: (inputs: OutcomeInputs) => boolean;
+}];
+export type InvalidatingCondition = (typeof INVALIDATING_CONDITIONS)[number]['id'];
+/**
+ * Row 9. The witness conjunct keeps an unmatched selection from deleting a
+ * witnessed detection, and admits `not-triggered`, the one witness value
+ * carrying no detection to protect. The length conjunct keeps an oracle that
+ * declared no step out, since AD-6 scopes `unreached` to declared steps and
+ * `every` is vacuous over an empty array.
+ */
+declare const stepsUnreached: (inputs: OutcomeInputs) => boolean;
+/** AD-33's first fixed cell. A `zero-action` probe on the seeding branch seeds a defect whose correct behaviour is refusal, so "satisfied" is the signature manifesting and a finding witnessing it, which is `matched`. */
+declare const zeroActionDetected: (inputs: OutcomeInputs) => boolean;
+declare const cleanControlFalsePositive: (inputs: OutcomeInputs) => boolean;
+/**
+ * A clean control whose check examined nothing falls past this row to the
+ * abstention row: AD-4 makes `insufficient-evidence` terminal and AD-6 lands
+ * it on `abstained`, so a build cannot pass green on an oracle that examined
+ * an empty collection. The false-positive row stays above both; a filed
+ * finding survives a check that examined nothing.
+ */
+declare const cleanControlPassed: (inputs: OutcomeInputs) => boolean;
+declare const canaryDetected: (inputs: OutcomeInputs) => boolean;
+/**
+ * The three witness rows above the clean-control pair each carry
+ * `expectedClean`, so AD-9's legal states for a clean control hold over the
+ * whole input type, beyond the tuples the qualification gate can produce. The
+ * unexercised row carries the guard for its own reason: AD-6 legalises
+ * `not-applicable` for a probe AD-40 records as unexercised, and a clean
+ * control carries no signature, so AD-40 records nothing about it.
+ */
+declare const witnessUnexercised: (inputs: OutcomeInputs) => boolean;
+declare const witnessMatched: (inputs: OutcomeInputs) => boolean;
+declare const witnessManifestedUnclaimed: (inputs: OutcomeInputs) => boolean;
+/**
+ * On a witness-free oracle, `mapped` is the one bucket that resolves `caught`.
+ * AD-40 calls an unmapped finding an unexpected real defect and keeps it out
+ * of every catch.
+ */
+declare const oracleCitedDefect: (inputs: OutcomeInputs) => boolean;
+/** Row 20's guard, written out as the negation of every guard above it. */
+declare const outcomeClear: (inputs: OutcomeInputs) => boolean;
+/**
+ * Stage B. First match wins; the identifier of the row that fired is
+ * returned.
+ *
+ * Rows 5, 6, 8, 15, 16, and 19 consume all six witness results, so anything
+ * reaching row 20 carries no witness. Rows 9 and 18 each take a subset of an
+ * earlier row's domain without widening it, which is why the witness rows are
+ * not contiguous. Rows 13 and 14 are deliberately not total over `canary`: an
+ * undetected canary that matched no selection falls past both and lands on row
+ * 18 or row 20 unless row 9 took it.
+ *
+ * Rows 10 and 15 overlap on a `zero-action` probe with a `matched` witness.
+ * Row 10 is kept so AD-33's first fixed cell has a line of its own in the
+ * emitted table.
+ */
+export declare const OUTCOME_RULES: readonly [{
+    readonly id: 'evaluation-fault';
+    readonly guard: 'an AD-26 evaluation fault was recorded';
+    readonly state: 'oracle-error';
+    readonly resolvesFromCitation: false;
+    readonly holds: (inputs: OutcomeInputs) => boolean;
+}, {
+    readonly id: 'judge-malformed';
+    readonly guard: 'judge conduct `malformed`';
+    readonly state: 'judge-error';
+    readonly resolvesFromCitation: false;
+    readonly holds: (inputs: OutcomeInputs) => boolean;
+}, {
+    readonly id: 'probe-unqualified';
+    readonly guard: 'a probe is present and its qualification failed';
+    readonly state: 'infrastructure-error';
+    readonly resolvesFromCitation: false;
+    readonly holds: typeof probeUnqualified;
+}, {
+    readonly id: 'finding-dangling-probe';
+    readonly guard: "the cited finding's bucket is `dangling`";
+    readonly state: 'infrastructure-error';
+    readonly resolvesFromCitation: true;
+    readonly holds: (inputs: OutcomeInputs) => boolean;
+}, {
+    readonly id: 'witness-unwitnessed-claim';
+    readonly guard: 'witness result `unwitnessed-claim`';
+    readonly state: 'infrastructure-error';
+    readonly resolvesFromCitation: false;
+    readonly holds: (inputs: OutcomeInputs) => boolean;
+}, {
+    readonly id: 'witness-vacuous';
+    readonly guard: 'witness result `vacuous`';
+    readonly state: 'infrastructure-error';
+    readonly resolvesFromCitation: false;
+    readonly holds: (inputs: OutcomeInputs) => boolean;
+}, {
+    readonly id: 'selector-ambiguous';
+    readonly guard: 'a step matched several observations under a single-valued cardinality';
+    readonly state: 'infrastructure-error';
+    readonly resolvesFromCitation: false;
+    readonly holds: (inputs: OutcomeInputs) => boolean;
+}, {
+    readonly id: 'witness-unexercised';
+    readonly guard: 'witness result `unexercised` on a probe outside the `expectedClean` branch';
+    readonly state: 'not-applicable';
+    readonly resolvesFromCitation: false;
+    readonly holds: typeof witnessUnexercised;
+}, {
+    readonly id: 'steps-unreached';
+    readonly guard: 'no witness or witness result `not-triggered`; `selections` non-empty; every member resolved `none`';
+    readonly state: 'unreached';
+    readonly resolvesFromCitation: false;
+    readonly holds: typeof stepsUnreached;
+}, {
+    readonly id: 'zero-action-detected';
+    readonly guard: 'class `zero-action` on the seeding branch with witness result `matched`';
+    readonly state: 'caught';
+    readonly resolvesFromCitation: false;
+    readonly holds: typeof zeroActionDetected;
+}, {
+    readonly id: 'clean-control-false-positive';
+    readonly guard: '`expectedClean` and a defect finding cites the oracle';
+    readonly state: 'false-positive';
+    readonly resolvesFromCitation: true;
+    readonly holds: typeof cleanControlFalsePositive;
+}, {
+    readonly id: 'clean-control-passed';
+    readonly guard: '`expectedClean` and the check root did not resolve `insufficient-evidence`';
+    readonly state: 'passed-clean-control';
+    readonly resolvesFromCitation: false;
+    readonly holds: typeof cleanControlPassed;
+}, {
+    readonly id: 'canary-detected';
+    readonly guard: 'class `canary` and a defect finding cites the oracle';
+    readonly state: 'caught';
+    readonly resolvesFromCitation: true;
+    readonly holds: typeof canaryDetected;
+}, {
+    readonly id: 'canary-undetected';
+    readonly guard: 'class `canary`, some selection resolved other than `none`, and no defect finding cites the oracle';
+    readonly state: 'infrastructure-error';
+    readonly resolvesFromCitation: false;
+    readonly holds: typeof canaryUndetected;
+}, {
+    readonly id: 'witness-matched';
+    readonly guard: 'witness result `matched` on a probe outside the `expectedClean` branch';
+    readonly state: 'caught';
+    readonly resolvesFromCitation: false;
+    readonly holds: typeof witnessMatched;
+}, {
+    readonly id: 'witness-manifested-unclaimed';
+    readonly guard: 'witness result `manifested-unclaimed` on a probe outside the `expectedClean` branch';
+    readonly state: 'missed';
+    readonly resolvesFromCitation: false;
+    readonly holds: typeof witnessManifestedUnclaimed;
+}, {
+    readonly id: 'oracle-cited-defect';
+    readonly guard: "no witness and the cited finding's bucket is `mapped`";
+    readonly state: 'caught';
+    readonly resolvesFromCitation: true;
+    readonly holds: typeof oracleCitedDefect;
+}, {
+    readonly id: 'check-insufficient-evidence';
+    readonly guard: 'the check root resolved `insufficient-evidence`';
+    readonly state: 'abstained';
+    readonly resolvesFromCitation: false;
+    readonly holds: typeof checkExaminedNothing;
+}, {
+    readonly id: 'witness-not-triggered';
+    readonly guard: 'witness result `not-triggered`';
+    readonly state: 'confirmed';
+    readonly resolvesFromCitation: false;
+    readonly holds: (inputs: OutcomeInputs) => boolean;
+}, {
+    readonly id: 'outcome-clear';
+    readonly guard: 'the stated negation of every guard above';
+    readonly state: 'confirmed';
+    readonly resolvesFromCitation: false;
+    readonly holds: typeof outcomeClear;
+}];
+export type OutcomeRuleId = (typeof OUTCOME_RULES)[number]['id'];
+/**
+ * A waiver excuses a known gap, and `missed` is the only gap here.
+ * `false-positive` is a clean control's own calibration; `abstained` is an
+ * unknown. AD-7 counts every exercised probe in its denominator, so a waiver
+ * honoured over a `matched` witness would depress the catch rate.
+ */
+export declare const WAIVABLE_FAILURES: readonly ["missed"];
+/**
+ * Neither rule fires on `none` or `expired`, which is AD-21's expired waiver
+ * reinstating its gap. `bypassed` is a gap excused without earning the excuse,
+ * which is the group AD-6 puts it in and the only firing condition the AD
+ * gives it anywhere.
+ */
+export declare const WAIVER_RULES: readonly [{
+    readonly id: 'waiver-honoured';
+    readonly guard: 'waiver `applied-condition-met` over a waivable failure';
+    readonly state: 'not-applicable';
+    readonly holds: (inputs: OutcomeInputs, provisional: "abstained" | "bypassed" | "caught" | "confirmed" | "false-positive" | "infrastructure-error" | "judge-error" | "missed" | "not-applicable" | "oracle-error" | "passed-clean-control" | "unreached") => boolean;
+}, {
+    readonly id: 'waiver-bypassed';
+    readonly guard: 'waiver `applied-condition-unmet` over a waivable failure';
+    readonly state: 'bypassed';
+    readonly holds: (inputs: OutcomeInputs, provisional: "abstained" | "bypassed" | "caught" | "confirmed" | "false-positive" | "infrastructure-error" | "judge-error" | "missed" | "not-applicable" | "oracle-error" | "passed-clean-control" | "unreached") => boolean;
+}];
+export type WaiverRuleId = (typeof WAIVER_RULES)[number]['id'];
+/**
+ * The corroboration table, decided after the final state. First match wins and
+ * no row is an `otherwise`.
+ *
+ * The order carries three obligations. Rows 1 to 3 sit above both
+ * check-derived rows so a disposition and a declined citation are not
+ * believed. Row 4 sits above row 5 so a check that resolved
+ * `insufficient-evidence` never records `not-evaluable`, which AD-33 forbids
+ * and which row 9 of the ladder makes reachable. Rows 6, 7, and 8 partition
+ * satisfaction against citation, so the table is total.
+ *
+ * A `disagrees` is diagnostic and moves nothing on its own, and it carries the
+ * whole cost of the tail collapsing to `confirmed`. Row 3 is where an
+ * `unmapped` or `signatureless` citation records that the evaluator and the
+ * oracle are pointing at different defects.
+ *
+ * Row 5 widens AD-33's `not-evaluable` from unreached steps to any `null` root
+ * resolution, which is the same condition reached by a second route: an oracle
+ * whose `check` is `null`, half of what `oracle-missing-channel` fires on.
+ */
+export declare const CORROBORATION_RULES: readonly [{
+    readonly id: 'disposition-unsupported';
+    readonly guard: 'the disposition is `held` or `violated` with empty `observationIds`';
+    readonly value: '`disagrees`';
+    readonly holds: typeof dispositionUnsupported;
+    readonly corroboration: () => "disagrees";
+}, {
+    readonly id: 'disposition-contradicts-evidence';
+    readonly guard: '`violated` with no defect finding, `held` with one, or `not-attempted` with one';
+    readonly value: '`disagrees`';
+    readonly holds: typeof dispositionContradictsEvidence;
+    readonly corroboration: () => "disagrees";
+}, {
+    readonly id: 'citation-declined';
+    readonly guard: "the cited finding's bucket is `unmapped` or `signatureless`";
+    readonly value: '`disagrees`';
+    readonly holds: typeof citationDeclined;
+    readonly corroboration: () => "disagrees";
+}, {
+    readonly id: 'examined-nothing';
+    readonly guard: 'the check root resolved `insufficient-evidence`';
+    readonly value: '`disagrees` where a defect finding cited the oracle, `agrees` where none did';
+    readonly holds: typeof checkExaminedNothing;
+    readonly corroboration: (inputs: OutcomeInputs) => "agrees" | "disagrees";
+}, {
+    readonly id: 'never-ran';
+    readonly guard: 'the final state is `unreached`, or the check root resolution is `null`';
+    readonly value: '`not-evaluable`';
+    readonly holds: (inputs: OutcomeInputs, state: "abstained" | "bypassed" | "caught" | "confirmed" | "false-positive" | "infrastructure-error" | "judge-error" | "missed" | "not-applicable" | "oracle-error" | "passed-clean-control" | "unreached") => boolean;
+    readonly corroboration: () => "not-evaluable";
+}, {
+    readonly id: 'check-confirms-silence';
+    readonly guard: 'the check satisfies and no defect finding cited the oracle';
+    readonly value: '`agrees`';
+    readonly holds: (inputs: OutcomeInputs) => boolean;
+    readonly corroboration: () => "agrees";
+}, {
+    readonly id: 'check-confirms-finding';
+    readonly guard: 'the check does not satisfy and a defect finding cited the oracle';
+    readonly value: '`agrees`';
+    readonly holds: (inputs: OutcomeInputs) => boolean;
+    readonly corroboration: () => "agrees";
+}, {
+    readonly id: 'check-and-findings-diverge';
+    readonly guard: 'the check satisfies with a finding cited, or does not satisfy with none';
+    readonly value: '`disagrees`';
+    readonly holds: (inputs: OutcomeInputs) => boolean;
+    readonly corroboration: () => "disagrees";
+}];
+export type CorroborationRuleId = (typeof CORROBORATION_RULES)[number]['id'];
+/**
+ * AD-33's total reference decision procedure. One AD-6 state, one
+ * corroboration value, the rules that produced them, and the evidence the
+ * resolution read.
+ */
+export declare function resolveOutcome(inputs: OutcomeInputs): OutcomeResolution;
+/**
+ * The findings citing no oracle. AD-33 keeps them: discarding one would hide
+ * the evaluator-chosen detection AD-23 exists to preserve. Named apart from
+ * the artifact's own `uncitedFindings` field so the two do not collide, and
+ * covering every finding type, since AD-23's carve-out is about the oracle
+ * citation.
+ */
+export declare function uncitedFindingIds(record: Pick<SealedRunRecord, 'findings'>): readonly string[];
+/**
+ * Owed item 5: every uncited `defect` finding, as `UncitedFindingGap`'s
+ * persisted shape. Deliberately not a rename or extension of
+ * `uncitedFindingIds` above: that function is broader (every finding type)
+ * and thinner (an identifier only), and already backs the artifact's own bare
+ * `uncitedFindings` field; this one is narrower (`defect` only, since only
+ * that branch carries `quotedEvidence`) and richer (the full gap record), and
+ * the two coexist rather than one replacing the other.
+ */
+export declare function uncitedDefectFindingGaps(record: Pick<SealedRunRecord, 'findings'>): readonly UncitedFindingGap[];
+export {};