@sanning/proof 0.19.1 → 0.20.0

package/dist/case.js

@@ -1,684 +1,293 @@
 /**
- * One verdict for a CASE, across packs and across organizations (anchor#198).
- *
- * The TypeScript half of `src/sanning_proof/case.py`. Both kernels are held to
- * the same corpus set, `test-vectors/case/`, so neither can pass by agreeing
- * with the other.
- *
- * WHY THIS LAYER EXISTS, AND WHAT IT IS THE CLOSURE FOR
- * =====================================================
- *
- * `envelope-spec.md` 4.1 reads records. `evidence-bundle.md` 5.4 reads one pack
- * against its own declaration. Neither can answer the question an audit team
- * actually asks, and 4.1 (v1.10, A15) and 5.4.2 rule 7 (v1.10) now say so in
- * these words:
- *
- *     **A pack a party assembles about itself is not self-proving about what
- *     that party LEFT OUT.**
- *
- * `handoffs[]` MAY be empty (5.4.1), so a holder declares a record in
- * `records[]` and claims it nowhere: rule 2 cannot reach it because it is
- * declared, rule 7 cannot reach it because it is unclaimed, and the pack reads
- * `verified` with no deviation, which is the same reading the honest pack gets.
- * The corpus pins that pack as EXPECTED
- * (`test-vectors/declaration/declaration-unclaimed-record-01`) rather than
- * leaving it to be rediscovered. Six repairs treated a property of one-sided
- * evidence as a defect in a rule (proof#137, ratified by Phil 2026-09-22), and
- * the omission happens BEFORE any reader runs, so no rule at either of those
- * layers reaches it.
- *
- * **This module is the closure, and the reason it can be is that it reads
- * several parties' packs at once.** A `handoff.sent` with no counterpart among
- * the records of the case is always NAMED, and when a pack signed by the key
- * that record names is in the case, the reading says that pack holds no
- * counterpart. No party can make a missing counterpart read clean.
- *
- * What it does NOT establish is that a party which presented no pack signed by
- * the named key recorded nothing. Nothing binds a pack's wrapper key to the
- * keys its records are signed with, so a counterparty that hands over its
- * account under any other key, or inside an export an issuer signed, or not at
- * all, gets the reading that says only that no pack in the case is signed by
- * the named key. Proving that a party did NOT record something needs that
- * party's account or a completeness mechanism over its records, and which of
- * those this reading waits for is proof#143.
- *
- * WHAT THAT MEANS FOR HOW THE JOIN IS BUILT
- * =========================================
- *
- * **The case reader does not consult `handoffs[]` to pair anything.** That is
- * not an oversight, it is the whole mechanism. The declaration is written by
- * the party being audited, so a join keyed on it inherits exactly the hole it
- * is meant to close: claim the clean pair, keep the tampered receipt
- * unclaimed, and a declaration-keyed reader never grades the receipt at all.
- * This reader pairs records with records, through `readHandoff`, over the
- * union of every record every pack in the case supplied. `handoffs[]` is read
- * for ONE thing and one only: to name a record its own holder DECLARED and
- * claimed nowhere (`RECORD_UNCLAIMED`), which is the pinned vector above
- * becoming visible. That claim check runs over every record a pack declares,
- * and not only over the ones 4.1 governs, because "is this a conformant
- * hand-off record" is an answer the audited party writes.
- *
- * **Matching is on hashes and identifiers alone and NEVER on tenancy**
- * (anchor#198, and DL-60: producer identity gates what the plane accepts and
- * never whether evidence verifies). The union pile is not partitioned by pack,
- * by issuer, by `tenant_id` or by organization anywhere in this module, so a
- * pair assembled by two organizations reads exactly as a pair assembled by
- * one. There is no code path here that reads a tenant.
- *
- * THE DEFECT CLASS THIS MODULE IS WRITTEN AGAINST
- * ===============================================
- *
- * Seventeen findings on this program share one generator: **a deviation
- * designed as a comparison between two present things, where the deviation
- * itself removes one of them, so the code takes the "nothing to compare"
- * branch written for the honest case.** A rule shaped that way reads the
- * absence of a signal as "fine" rather than as "I could not tell", and a real
- * deviation grades clean.
- *
- * Acceptance criterion 3 of anchor#198 is made of exactly that shape: *a
- * one-sided hand-off is an exception, not a failure*. So the four rules below
- * are structural and are the thing to preserve in any change here.
- *
- * 1. **Every exception is NAMED and appears in the output, and every exception
- *    contributes a verdict.** There is no path through this module that
- *    removes a record, a pack or a claim from the reading. An empty
- *    `exceptions` is the ONLY shape a reader may read as clean, and `readCase`
- *    is invariant: `verified` is reachable only when that array is empty.
- * 2. **Nothing a party writes decides whether grading happens.** No graded
- *    value is part of any key that selects a code path. The pile is everything
- *    every pack supplied; there is no filter.
- * 3. **Every field that selects a code path and is chosen by the party being
- *    audited has an accept-set, and an unknown value goes to a named exception
- *    rather than to silence.** `body_type` is `CASE_BODY_TYPES`;
- *    `declaration_version` is `checkDeclaration`'s; `event_type` and
- *    `event.counterparty_public_key` are 4.1's, through `readHandoffs`. A pack
- *    that supplies zero records is `PACK_HOLDS_NO_RECORDS` and a case with no
- *    hand-off record in it at all is `CASE_HOLDS_NO_HANDOFF_RECORDS`, because
- *    "nothing to grade" is never "nothing is wrong".
- * 4. **The 4.1 predicates are CALLED, never restated.** `readHandoffs`,
- *    `normalizedSigningKey` and `packRecords` are the one implementation of
- *    each rule. A validation copied beside the one that enforces it drifts,
- *    and a copy that is looser blesses a value the real one then rejects.
- *
- * EVERY EARLY EXIT IN THIS MODULE, AND WHAT IT SKIPS
- * ==================================================
- *
- * Three defects on this layer were one shape: an exit between a record
- * entering the pile and a check running over it, with the audited party
- * choosing whether the exit was taken. So the exits are enumerated here rather
- * than left to be rediscovered a fourth time. `src/sanning_proof/case.py` has
- * the same exits in the same order, and the pull request that added this list
- * carries the same table.
- *
- * 1. **No packs** (`return`). Skips everything. Reached by the reader, who
- *    chose what to hand in. Named: `CASE_HOLDS_NO_PACKS`.
- * 2. **A wrapper key this reader cannot read** (`continue`). Skips the bundle
- *    verification, the declaration check and every record in the pack. The
- *    holder writes the key, so it steers here freely, and the pack is NAMED
- *    (`PACK_KEY_UNREADABLE`). Both bundle verifiers now refuse every such
- *    spelling in the same words (proof#142), so this exit and exit 3 agree on
- *    which packs they take; it stays first because it names WHY. While any
- *    pack takes this exit, a one-sided record whose named key signed no pack
- *    reads `COUNTERPART_ABSENT_SIGNER_UNKNOWN` and never the innocent
- *    `COUNTERPART_ABSENT`.
- * 3. **The wrapper does not hold** (`continue`): `signatureOk` and
- *    `bodyHashOk` are not both true. Skips the declaration check and every
- *    record in the pack, and the key it claims is never counted as a pack
- *    signer. **This is the forger's case and the only exit that turns on
- *    provenance**: those two fields are the whole of what ties a pack to a
- *    key. Reached by whoever built the pack, and by anyone who alters its
- *    unsigned `signature` field, which is indistinguishable from a forgery.
- *    Named: `PACK_DOES_NOT_VERIFY`, and it moves one-sided records to
- *    `COUNTERPART_ABSENT_SIGNER_UNKNOWN` exactly as exit 2 does.
- *
- *    A pack whose wrapper HOLDS is never sent here, whatever is wrong inside
- *    it (gate 3 on proof#140): its key is counted, its own bundle verdict is
- *    `PACK_BUNDLE_NOT_VERIFIED` when that verdict is not `verified`, and each
- *    record is graded on its own envelope below.
- * 3b. **The bundle verdict is `malformed`** (`continue`, after exit 3 and after
- *    `PACK_BUNDLE_NOT_VERIFIED`). The body is one the verifier could not read,
- *    so it graded no record. The key is already counted.
- * 4. **`body_type` outside `CASE_BODY_TYPES`** (`continue`). Skips the
- *    declaration check and every record in the pack. The holder writes
- *    `body_type`, so the holder steers here freely, which is why it is named
- *    every time (`PACK_BODY_TYPE_UNKNOWN`) and why the pack's wrapper key is
- *    counted ABOVE it: a counterparty cannot leave the damning counterpart
- *    line by choosing a body (F3). `sanning.evidence.export/v2` lands here and
- *    is not unwrapped.
- * 5. **No records** (`continue`). Skips the declaration check, over nothing.
- *    The holder steers here by handing over an empty `events[]`. Named:
- *    `PACK_HOLDS_NO_RECORDS`; the wrapper key is already counted.
- * 5b. **A record under a quarantined profile** and 5c. **a record whose own
- *    envelope does not verify** (`continue`). Each skips 4.1 for that record,
- *    its candidacy for any other record, and the claim check, because 4.1
- *    compares only envelopes that verified (`HeldRecord`). Named:
- *    `RECORD_PROFILE_QUARANTINED` (`incomplete`, pending DL-63) and
- *    `RECORD_ENVELOPE_DOES_NOT_VERIFY` (`failed`). Neither removes a named
- *    failure from another record: the other records of the pack are still
- *    graded, and pairs still form over every record that verified.
- * 6. **`event_bytes` withheld** and 7. **`event_bytes` unreadable**
- *    (`continue`). Each skips 4.1 for that record, its candidacy for any other
- *    record, and the claim check. The holder steers into both by what it
- *    discloses. Each is named in the claim check's place
- *    (`RECORD_BYTES_WITHHELD` `incomplete`, `RECORD_BYTES_UNREADABLE`
- *    `malformed`), so neither buys a cleaner reading than an unclaimed record
- *    would get, and neither decides which counterpart kind another record
- *    gets, since that reads wrapper keys.
- *
- *    Not exits: a record whose envelope verifies and whose content does not
- *    match its commitment is `RECORD_CONTENT_MISMATCH` where that content is
- *    inside the signed body and `RECORD_CONTENT_DEPENDENT` where it was handed
- *    in beside the pack (proof#159), and one that fails
- *    another check inside its pack is `RECORD_DOES_NOT_VERIFY_IN_ITS_PACK`.
- *    Both are named and both STAY in the pile, so neither unsigned content
- *    handed in beside a pack nor a broken inclusion proof removes a record
- *    from pairing.
- * 8. **`not_a_handoff_record`** (`continue`). Skips the hand-off count and the
- *    counterpart, ambiguity and pair reporting, which 4.1 does not give a
- *    record outside its scope. The holder steers here by respelling a field.
- *    It no longer skips the claim check, which runs ABOVE it because it asks
- *    what the pack SAID and not what the record is (F1).
- * 9. **THIS record is malformed** (`continue`). Skips the counterpart,
- *    ambiguity and pair reporting, and 4.1 computed none of them for a
- *    malformed subject, so nothing is lost. A party steers here only by
- *    breaking a record it signed, and the record is named `RECORD_MALFORMED`.
- *    A well formed record whose CANDIDATE is malformed does not take this
- *    exit: it is `COUNTERPART_MALFORMED` and the reporting below still runs
- *    (F2).
- * 10. **`counterpart_absent`** (`continue`). Skips the ambiguity and pair
- *     reporting, and there is nothing to skip: 4.1 emits that finding only
- *     where no candidate is left to read, an EMPTY candidate list or one whose
- *     every candidate another record accounts for (4.1 v1.17, A20). Which of the three counterpart kinds it
- *     gets reads the keys of the packs that verified, counted before exit 4,
- *     and whether any pack took exit 2 or 3.
- *
- * Not an exit, and listed because it is one more place this shape could
- * hide: the claim check runs only where the pack's declaration is READABLE. An
- * absent or unreadable one is named once for the pack (`PACK_UNDECLARED`,
- * `PACK_DECLARATION_UNREADABLE`) rather than once per record.
- *
- * THE VERDICT VOCABULARY IS CLOSED
- * ================================
- *
- * `verified`, `failed`, `partial`, `mixed`, `incomplete` and `malformed`,
- * every one of them already in use (`evidence-bundle.md` 3 and
- * `PACK_VERDICTS`). **No new word is coined anywhere in this module**, and
- * `CASE_VERDICTS` is asserted against `PACK_VERDICTS` by the test suite so a
- * future addition here cannot invent one quietly. Everything this module has
- * to say that is not one of those six is an EXCEPTION KIND reported beside the
- * verdict, exactly as `counterpart_absent` and `not_a_handoff_record` are
- * findings beside a verdict in 4.1.
- *
- * A case with any `failed` contribution is `failed`: a proven failure keeps
- * the headline (5.5.4 v1.16, A17, proof#158). Otherwise a case with more than
- * one outcome is `mixed` (anchor#198, criterion 4).
- *
- * WHAT THIS READER DOES NOT CLAIM
- * ===============================
- *
- * * **Not that the case is complete.** Joining is voluntary. A counterparty
- *   that never handed over a pack leaves `COUNTERPART_ABSENT`, which is an
- *   exception and never a failure. It says that no pack in the case is signed
- *   by the named key, and nothing about what that party recorded.
- * * **Not that a party which presented no pack under the named key recorded
- *   nothing.** See the top of this comment, and proof#143.
- * * **Not that two organizations are independent.** One team holding both keys
- *   proves which agent said what, not that two parties agreed (4.1, 5.4.4).
- * * **Not that a `verified` case has no other problem.** It reads hand-offs.
- *   It runs `verifyEvidenceBundle` over every pack itself, offline and with no
- *   gateways, and a pack whose own bundle verdict is not `verified` is named
- *   with that verdict and its reasons, so the case never reads above its
- *   weakest pack. On-chain re-fetch and `gradePack` are a caller's to run.
- *
- * THE COST OF 4.1's "GRADE EVERY CANDIDATE", AND WHAT IS LEFT OF IT (4.1
- * v1.17, amendment A20, which reopens proof#134). Up to v1.16 a pile holding
- * two or more records of the complementary type signed by one counterparty key
- * could not reach `verified`. 4.1 now sets such a candidate aside where a
- * record the subject's own key signed pairs with it verified at another
- * sequence, so two messages in one direction, and the demo's A to B, B to A,
- * A to B, read clean. What is left surfaces as `COUNTERPART_AMBIGUOUS` beside
- * the failure: fan-in, fan-out, and the same pair in two cases at the same
- * sequence. Narrowing any of it here with `handoffs[]` is precisely the move
- * that would reopen proof#137's door.
+ * One verdict for a case: several packs, possibly from several organizations.
+ * Conformance: `test-vectors/case/`.
+ *
+ * A pack a party assembles about itself is not self-proving about what that
+ * party left out: a holder can declare a record and claim it nowhere, and the
+ * pack still reads `verified` (`declaration-unclaimed-record-01`). Reading
+ * several parties' packs at once closes that. An `agent.handoff.sent` with no
+ * counterpart among the case's records is always named, and when a pack signed
+ * by the key that record names is in the case, the reading says that pack
+ * holds no counterpart. It does not establish that a party which presented no
+ * such pack recorded nothing: nothing binds a pack's wrapper key to its
+ * records' keys.
+ *
+ * How the join works:
+ * - Records pair with records, through `readHandoffs`, over the union of every
+ *   record every pack supplied. `handoffs[]` is written by the audited party,
+ *   so it never selects a pair; it is read only to name a declared record that
+ *   is claimed nowhere (`RECORD_UNCLAIMED`).
+ * - Matching is on hashes and identifiers only, never tenancy. Nothing here
+ *   partitions the pile by pack, issuer, `tenant_id` or organization.
+ *
+ * Structural rules, to preserve in any change:
+ * 1. Every exception is named in the output and contributes a verdict.
+ *    Nothing removes a record, pack or claim from the reading. `verified` is
+ *    reachable only when `exceptions` is empty.
+ * 2. Nothing a party writes decides whether grading happens. The pile is
+ *    everything every pack supplied.
+ * 3. Every party-chosen field that selects a code path has an accept-set, and
+ *    an unknown value is a named exception. "Nothing to grade" is never
+ *    "nothing is wrong".
+ * 4. The §4.1 predicates (`readHandoffs`, `normalizedSigningKey`,
+ *    `packRecords`) are called, never restated.
+ *
+ * Every early exit in `readCase` names its exception, so no exit buys a
+ * cleaner reading than the record or pack would otherwise get. In particular:
+ * - A pack with an unreadable key or a wrapper that does not hold is skipped
+ *   and its key never counted; while any pack takes that exit, a one-sided
+ *   record reads `COUNTERPART_ABSENT_SIGNER_UNKNOWN`, never `COUNTERPART_ABSENT`.
+ * - A wrapper key is counted before the body-type and no-records exits, so
+ *   choosing a body cannot dodge the counterpart line.
+ * - The claim check runs before the not-a-hand-off and malformed exits, so
+ *   respelling or breaking a record cannot switch it off.
+ * - Content and in-pack failures are named and the record stays in the pile.
+ *
+ * The verdict vocabulary is closed: `verified`, `failed`, `incomplete`
+ * (evidence-bundle.md section 3). Every exception maps to one claim and one
+ * state (`claims.ts`), and the case reads its worst pack: any `failed`
+ * contribution makes the case `failed`, otherwise any `incomplete` makes it
+ * `incomplete`, and a reading with no contribution is `verified`.
+ *
+ * Not claimed: that the case is complete (joining is voluntary), that two
+ * organizations are independent (one team can hold both keys), or that a
+ * `verified` case has no other problem. Every pack is verified offline here
+ * and a pack whose bundle is not `verified` is named; on-chain re-fetch and
+ * `gradePack` are the caller's.
+ *
+ * Several records of the complementary type under one counterparty key can
+ * still be ambiguous (fan-in, fan-out, one pair in two cases at one sequence):
+ * that surfaces as `COUNTERPART_AMBIGUOUS`. Narrowing it with `handoffs[]`
+ * would reopen the hole above.
  */
 import { DECLARATION_VERSION, DECLARATION_VERSIONS, checkDeclaration, declarationClaims, packRecords, } from "./declaration.js";
+import { readAgentRecords } from "./agent-record.js";
 import { readChainLinks } from "./chain.js";
-import { NOT_A_HANDOFF_FINDING, normalizedSigningKey, readHandoffs, recordIsMalformed, } from "./handoff.js";
+import { NOT_A_HANDOFF_FINDING, normalizedSigningKey, readHandoffs, recordIsMalformed, recordIsNonconforming, } from "./handoff.js";
 import { coSignaturesPresent, resolveTraceEvents, verifyEvidenceBundle } from "./evidence.js";
 import { accountDisclosure, completenessNotes, gradePack, } from "./grading.js";
 import { renderWitnessTime } from "./witness-cache.js";
-// ---- The vocabulary ---------------------------------------------------------
-/**
- * The verdicts a case can reach. Every one is already in use in
- * `evidence-bundle.md` 3 or `PACK_VERDICTS`, and anchor#198 says in terms that
- * no new verdict word is introduced anywhere.
- */
-export const CASE_VERDICTS = [
-    "verified",
-    "failed",
-    "partial",
-    "mixed",
-    "incomplete",
-    "malformed",
-];
-/**
- * anchor#198 says in terms that no new verdict word is introduced anywhere, and
- * this line is what ENFORCES it rather than asserting it in prose.
- *
- * `tsc` refuses to compile if any member of `CASE_VERDICTS` is not already a
- * `PackVerdict`, so a seventh word added here fails the BUILD rather than
- * reaching a test that might not cover it. The Python half asserts the same
- * containment at run time against `grading.PACK_VERDICTS`, which is that
- * language's equivalent gate.
- */
-const _caseVerdictsAreSharedVocabulary = [...CASE_VERDICTS];
-void _caseVerdictsAreSharedVocabulary;
+import { KIND_CLAIMS, VERDICTS, VERDICT_TITLES, bundleProblems, claimsOf, problem, restOnSigned, verdictOf as claimsVerdictOf, withItems, } from "./claims.js";
+/** The three verdicts (evidence-bundle.md section 3). A case reads its worst pack. */
+export const CASE_VERDICTS = VERDICTS;
 /**
- * The two pack bodies that carry `events[]` and may carry a `declaration`
- * (`evidence-bundle.md` 5.4.1). This is an ACCEPT-SET and not a hint.
- *
- * `body_type` selects a code path and is written by the party assembling the
- * pack. Without this set, a pack whose records live under a key this reader
- * does not know yields zero records, contributes nothing, and lets the rest of
- * the case read clean over it: the exact defect class this module is written
- * against. An unknown value is `PACK_BODY_TYPE_UNKNOWN`.
+ * The pack bodies that carry `events[]` and may carry a `declaration`
+ * (evidence-bundle.md §5.4.1). An accept-set: `body_type` is party-written, so
+ * an unknown value is `PACK_BODY_TYPE_UNKNOWN`, never zero records read clean.
  *
- * **`sanning.evidence.export/v2` is NOT in this set and is NOT unwrapped.** It
- * verifies as a bundle and carries a whole `sanning.anchor.trace/v3` pack under
- * `body.source_bundle`, so its records do not reach the pile and the export is
- * named `PACK_BODY_TYPE_UNKNOWN`, `incomplete`. Reading inside it changes which
- * packs this reader grades, so it is a decision of its own. A reader who needs
- * the records hands in the source bundle as a pack. The export's wrapper key is
- * still read, so wrapping a pack in one does not change which counterpart kind
- * another record gets.
+ * `sanning.evidence.export/v2` is not unwrapped: it is named
+ * `PACK_BODY_TYPE_UNKNOWN`, and a reader who needs its records hands in the
+ * source bundle. Its wrapper key is still read.
  */
 export const CASE_BODY_TYPES = [
     "sanning.anchor.trace/v3",
     "sanning.stamp.evidence/v2",
 ];
 /**
- * The envelope profiles the case reader reads records under: the ratified
- * accept-set (`envelope-spec.md` 5) minus every profile under quarantine in
- * `cross-kernel/accept-set.json`. A test in each kernel derives both arrays
- * from that file, and a test here pins this one equal to this kernel's own
- * `ACCEPTED_SPEC_MAJORS`, which is what `verifyEvidenceBundle` reads under:
- * the Python kernel narrows its verifier to this set for the case reader, and
- * this kernel's verifier already reads exactly it. If this kernel ever admits
- * a quarantined profile, that test fails, and the case reader has to narrow
- * its verifier the way the Python one does before it can pass.
+ * The profiles records are read under: the accept-set (envelope-spec.md §5)
+ * minus quarantined profiles in `cross-kernel/accept-set.json`. A test pins
+ * this equal to `ACCEPTED_SPEC_MAJORS`, which `verifyEvidenceBundle` reads under.
  */
-export const CASE_RECORD_PROFILES = ["sanning.agent/v1", "sanning.events/v2"];
-/** The ratified profiles under quarantine, pending DL-63. */
+export const CASE_RECORD_PROFILES = ["sanning.events/v2"];
+/** Accepted profiles under quarantine. */
 export const CASE_QUARANTINED_PROFILES = ["sanning.mlflow/v1"];
-// ---- The exceptions ---------------------------------------------------------
-//
-// Each of these is a NAME for something a reader would otherwise have to infer
-// from an absence. None of them is a verdict word.
 /**
- * A conformant hand-off record with no counterpart among the records this
- * reader read, where every pack in the case verified under a key this reader
- * can read and NO pack in the case is signed by the key the record names,
- * or where every candidate it had was accounted for by another record under
- * A20 (the exception then carries `count`, and names no pack).
- * **An exception, never a failure** (anchor#198, criterion 3).
- *
- * That is ALL it says. It does not say the counterparty's account is absent,
- * and it does not say nothing was tampered with: a counterparty that signs its
- * own pack under a second key, or hands over an export an issuer signed,
- * reaches this reading too, and nothing offline binds a pack's key to the keys
- * of the records inside it (proof#143). The rendered text states the fact and
- * stops.
- *
- * It says nothing about RECORDS signed by that key either. A party may hold records
- * its counterparty signed, and those are still graded as candidates, but they
- * are not the counterparty's account of itself, so they do not move this
- * record to `COUNTERPART_ABSENT_FROM_COUNTERPARTY_RECORDS`.
+ * A conformant hand-off record with no counterpart, where every pack verified
+ * under a readable key and none is signed by the key the record names, or every
+ * candidate was accounted for by another record (then `count` is set and no
+ * pack is named). An exception, never a failure. It says only that no pack is
+ * signed by the named key; records that key signed and others hold are not that
+ * party's own account and do not change it.
  */
 export const COUNTERPART_ABSENT = "counterpart_absent";
 /**
- * THE CLOSURE anchor#198 exists for.
- *
- * A conformant hand-off record with no counterpart, where a pack that VERIFIES
- * and is SIGNED by the key this record names is in the case, and not one
- * record this reader could read is this record's counterpart. It states that a
- * pack signed by the named key is present and holds no counterpart this reader
- * could read, and nothing more. 4.1 (v1.10, A15) and 5.4.2 rule 7 (v1.10) both point here, and
- * `declaration/declaration-unclaimed-record-01` is the pack that reaches this
- * line.
- *
- * **"Its own account" is read from the key that signed the PACK, and never
- * from the keys that signed records.** A pack's wrapper key signs `body_hash`
- * and `body` carries the declaration (`evidence-bundle.md` 5.4, "Who signs
- * it"), so a wrapper signed by B is provenance the accusing party cannot forge
- * without B's private key. Records signed by B that A merely HOLDS are not B's
- * account of itself: keyed on record keys, one pack from A plus one unrelated
- * record B signed at some other time reached this line when B had handed over
- * nothing at all.
- *
- * What it does NOT prove, stated so no surface claims it: that B handed the
- * pack over for THIS case. A pack B signed for some other purpose and a third
- * party replayed reads the same, because the only values that could say
- * otherwise (the declaration's `case_id` and `period`) are written by B and
- * would let B leave this line by writing them differently. The cost the other
- * way: a pack B assembles under any key other than the one its records name, a
- * per-organization hand-over key (anchor#196) included, reads
- * `COUNTERPART_ABSENT`, because nothing in the case binds that key to B. That
- * reading is still true: no pack signed by the named key is here. So a
- * counterparty can AVOID this line by choosing the key it signs under; what it
- * cannot do is make the missing counterpart read clean.
- *
- * It is deliberately NOT also conditioned on a record signed by B being in the
- * pile. B's pack can hold none this reader reads (a body it does not unwrap,
- * bytes B withheld, an empty `events[]`), and each of those is a choice B makes
- * and is named on its own. A second conjunct on them hands B the innocent line
- * for making one.
- *
- * It is a DISTINCT kind from `COUNTERPART_ABSENT` and not a louder spelling of
- * it. Collapsing the two would be the defect class again: "the counterparty
- * never joined" and "the counterparty joined and its own account does not
- * contain this hand-off" are the honest reading and the damning one, and one
- * name for both lets the second read as the first.
- *
- * It is still an EXCEPTION and not a failure, which criterion 3 requires and
- * which is also the honest call: the counterparty's pack is a selection over
- * its own interval, and a hand-off outside that interval is legitimately not
- * in it. What this names is that the question can now be ASKED of the other
- * party's own evidence, which is what no single pack could ever support.
+ * A conformant hand-off record with no counterpart, where a verified pack
+ * signed by the key the record names is in the case and holds no counterpart.
+ * The closure this module exists for (`declaration-unclaimed-record-01`).
+ *
+ * "Its own account" is read from the key that signed the pack, never from
+ * record keys: a wrapper signed by B is provenance an accuser cannot forge, but
+ * records signed by B that A holds are not B's account.
+ *
+ * Not proven: that B handed the pack over for this case. A pack B signs under
+ * any other key reads `COUNTERPART_ABSENT`, which is still true; B can avoid
+ * this line by choice of key, but cannot make the missing counterpart read
+ * clean. Not conditioned on B's records being readable, since each way B could
+ * make them unreadable is its own named choice.
+ *
+ * A distinct kind from `COUNTERPART_ABSENT`: one name for both would let the
+ * damning reading pass as the honest one. Still `incomplete`, not a failure: a
+ * hand-off outside the interval B's pack covers is legitimately absent.
  */
 export const COUNTERPART_ABSENT_FROM_COUNTERPARTY_RECORDS = "counterpart_absent_from_counterparty_records";
 /**
- * A conformant hand-off record with no counterpart, no VERIFIED pack in the
- * case signed by the key it names, and at least one pack in the case that this
- * reader could not tie to a key: its wrapper key is unreadable
- * (`PACK_KEY_UNREADABLE`) or it does not verify (`PACK_DOES_NOT_VERIFY`).
- * Whether a pack signed by the named key is in the case is UNKNOWN, so neither
- * of the other two kinds is true.
- *
- * The gate on the previous version of this reader showed why it exists. A
- * counterparty that signed its own pack under `" " + key` got
- * `PACK_KEY_UNREADABLE` for the pack and the innocent `COUNTERPART_ABSENT` for
- * the record, and the output contradicted itself: whose pack it was is
- * UNKNOWN, and then no pack is signed by the named key. The second sentence
- * was not established.
- *
- * `incomplete`, like the other two one-sided kinds: "I could not tell".
+ * A conformant hand-off record with no counterpart, no verified pack signed by
+ * the key it names, and at least one pack whose signer is unknown
+ * (`PACK_KEY_UNREADABLE` or `PACK_DOES_NOT_VERIFY`). Whether the named key
+ * signed a pack is unknown, so neither other kind is true. `incomplete`.
  */
 export const COUNTERPART_ABSENT_SIGNER_UNKNOWN = "counterpart_absent_signer_unknown";
 /**
- * More than one candidate counterpart that nothing accounts for (4.1 v1.17,
- * A20). The reading is the worst of them and the ambiguity is named: a reader
- * permitted to take one match can be handed an honest decoy beside a tampered
- * record. `count` is how many of the candidates are live, which is the number
- * the ambiguity is about.
+ * More than one live candidate counterpart (§4.1). The reading is the worst of
+ * them and the ambiguity is named, so an honest decoy cannot hide a tampered
+ * record. `count` is the number of live candidates.
  */
 export const COUNTERPART_AMBIGUOUS = "counterpart_ambiguous";
+/** A formed pair that failed checks, listed in §4.1's fixed order. */
+export const PAIR_FAILED = "pair_failed";
+/** This record itself is malformed under §4.1 (`recordIsMalformed`). */
+export const RECORD_MALFORMED = "record_malformed";
 /**
- * A formed pair that failed a check. Carries which checks, from 4.1's own
- * fixed order, so a reader is told the record AND the check.
+ * A candidate counterpart is malformed and this record is not. §4.1 reports
+ * the worst candidate, so without this kind one junk record signed by the
+ * counterparty's key would blame the honest record and drop its other failures.
+ * `incomplete`: the defect is the candidate's, which carries its own
+ * `RECORD_MALFORMED`.
  */
-export const PAIR_FAILED = "pair_failed";
+export const COUNTERPART_MALFORMED = "counterpart_malformed";
 /**
- * THIS record is wrong: 4.1 governs it and `recordIsMalformed` says so of the
- * record itself. A statement about the record this exception names, and about
- * no other.
+ * This record is one of the two hand-off types, signed and intact, and does
+ * not follow its vocabulary (`recordIsNonconforming`). A producer's error,
+ * never a proven alteration.
  */
-export const RECORD_MALFORMED = "record_malformed";
+export const RECORD_NONCONFORMING = "record_nonconforming";
 /**
- * A CANDIDATE counterpart of this record is malformed, and this record is not.
- *
- * 4.1 grades every candidate and reports the worst of them, and `malformed`
- * outranks `failed`, so one junk record signed by the counterparty's key makes
- * the reading of a perfectly well formed record `malformed` too. Filed under
- * `RECORD_MALFORMED`, that read as "this record is not a well formed hand-off
- * record" about the HONEST record, and the branch it took skipped the
- * counterpart, ambiguity and `failedChecks` reporting entirely: one junk record
- * both blamed the wrong party and stripped a named `message_hash` failure out
- * of the case. That is proof#133 ruling 6, which 4.1 closed by keeping the
- * UNION of `failedChecks`, reappearing one layer out because this layer
- * discarded that union.
- *
- * A record's own conformance and its candidate's are different facts and do
- * not share a kind. This one is `incomplete` and not `malformed`: the proven
- * defect belongs to the candidate, which carries its own `RECORD_MALFORMED`
- * line, and what is true of THIS record is that its pairing could not be
- * determined. Contributing `malformed` here would attribute the candidate's
- * defect to the record a party being accused did not write.
+ * A candidate counterpart is nonconforming and this record is not.
+ * `incomplete` for the reason `COUNTERPART_MALFORMED` is: the defect is the
+ * candidate's, which carries its own `RECORD_NONCONFORMING`.
  */
-export const COUNTERPART_MALFORMED = "counterpart_malformed";
+export const COUNTERPART_NONCONFORMING = "counterpart_nonconforming";
 /**
- * A record that its own pack DECLARES and its own pack's READABLE declaration
- * claims in no `handoffs[]` entry. This is proof#137's door, named at the layer
- * that can see it: the holder declared the record and claimed it nowhere, so
- * neither 5.4.2 rule 2 nor rule 7 reaches it and the pack reads `verified`.
- *
- * **It turns on what the PACK said about the record, and never on whether 4.1
- * governs it.** Gating it on "is this a conformant hand-off record" put it
- * behind a value the audited party writes: the same second receipt, respelled
- * with an `ff` ligature in `event_type` and a Cyrillic `е` in
- * `counterparty_public_key`, left 4.1's scope, took the `not_a_handoff_record`
- * branch, and bought a case reading of `verified` with zero exceptions where
- * the conformant spelling read `mixed` with four. proof#136 ratified that a
- * respelling buys a DIFFERENT LINE rather than no line; at this layer it
- * bought no line at all, and a strictly better outcome than honesty.
- *
- * It is not an accusation. `handoffs[]` MAY be empty and an unclaimed record
- * may be entirely innocent. What it is, is the end of the silence: the reader
- * cannot tell whether an unclaimed record is part of the hand-over the holder
- * meant to give or one it is keeping out of its own account, and that is "I
- * could not tell", which is why it carries `incomplete` and not `verified`.
- *
- * THE COST, stated rather than left to be found: a pack that declares records
- * which are not hand-off sides at all, an ordinary log line among them, is
- * named once per such record, so a case holding one cannot read `verified`.
- * That is the price of a rule with no branch the holder selects, and the only
- * narrower rule available keys on a value the holder writes. A surface that
- * wants the two apart reads `CaseRecordReading.findings`, where
- * `not_a_handoff_record` still says which is which.
+ * A record its pack declares and its pack's readable declaration claims in no
+ * `handoffs[]` entry (§5.4.2 rules 2 and 7 cannot reach it). Turns on what the
+ * pack said, never on whether §4.1 governs the record, so respelling
+ * `event_type` cannot move a record out of this check.
+ *
+ * Not an accusation: `handoffs[]` may be empty and the record innocent, so it
+ * is `incomplete`. The cost is that a declared non-hand-off record (a log line)
+ * is named too; `CaseRecordReading.findings` tells the two apart.
  */
 export const RECORD_UNCLAIMED = "record_unclaimed_by_its_pack";
 /**
- * The pack supplied no `event_bytes` for a record, so this reader cannot see
- * what the record IS in either direction.
- *
- * `event_bytes` is OPTIONAL (5.1, 5.3) and withholding it is minimum
- * disclosure, which the corpus calls a customer's right and not a defect
- * (proof#137, defect 3), so this is not a deviation and does not fail. It is
- * still SAID, because a withheld record is exactly where a missing counterpart
- * would hide, and a reader that dropped it silently would read a trimmed pack
- * as an honest one.
+ * The pack withheld `event_bytes` for a record. Withholding is minimal
+ * disclosure (§5.1, §5.3), not a deviation, but it is said: a withheld record is
+ * where a missing counterpart would hide.
  */
 export const RECORD_BYTES_WITHHELD = "record_bytes_withheld";
 /**
- * The pack SUPPLIED `event_bytes` this reader cannot read as
- * `JCS(event record)` (5.4.2 rule 7's parser rule, one implementation in
- * `packRecords`). Bytes the holder handed over that do not decode are a defect
- * in what was handed over, not an absence, so this one is `malformed`.
+ * The pack supplied `event_bytes` that do not read as `JCS(event record)`.
+ * A defect in what was handed over, so `malformed`.
  */
 export const RECORD_BYTES_UNREADABLE = "record_bytes_unreadable";
-/**
- * The pack deviates from its own declaration (5.4.2). A proven mismatch, so it
- * fails: a case cannot be clean over a pack that is proven to be trimmed.
- */
+/** The pack deviates from its own declaration (§5.4.2). A proven mismatch: `failed`. */
 export const PACK_DECLARATION_DEVIATES = "pack_declaration_deviates";
 /**
- * The pack and the UNSIGNED content handed in beside it do not line up (5.4.2
- * rules 3 and 4, proof#147, ratified by Phil 2026-09-22). A record the pack
- * declares `disclosed` for which no bytes reached this reader, or one it
- * declares `content_withheld` for which bytes reached this reader from the
- * side-content map alone.
+ * The pack and the unsigned content beside it do not line up (§5.4.2 rules 3
+ * and 4): a record declared `disclosed` with no bytes, or declared
+ * `content_withheld` with bytes from the side-content map alone.
  *
- * `incomplete` and never `failed`, which is the whole point of the kind. 5.4
- * grades a pack's declaration partly against content the READER was handed,
- * and whoever assembles a case fills that map in. Under
- * `PACK_DECLARATION_DEVIATES` an accuser could put an intact pack into a
- * `failed` case WITH NO KEY AT ALL: supply bytes for a record its holder
- * declared withheld, or drop the bytes of one it declared disclosed. The pack
- * was intact, its wrapper verified, and its holder had done nothing. This is
- * the mirror of proof#143, where a counterparty makes ITSELF look better by
- * choosing what it hands over.
- *
- * It is emitted BESIDE `PACK_DECLARATION_DEVIATES` where a pack does both,
- * because the two say different things about different records.
+ * `incomplete`, never `failed`: whoever assembles a case fills in that map, so
+ * otherwise an accuser could fail an intact pack with no key. Emitted beside
+ * `PACK_DECLARATION_DEVIATES` when a pack does both.
  */
 export const PACK_DECLARATION_CONTENT_DEPENDENT = "pack_declaration_content_dependent";
 /**
- * The pack carries a `declaration` this reader cannot read (5.4.3): an unknown
- * `declaration_version`, an absent or `null` one, a non-object, or one that
- * does not satisfy 5.4.1. `declaration_version` is chosen by the same party
- * that assembles the pack and has no accept-set of its own, so this is UNKNOWN
- * and never clean.
+ * The pack's `declaration` cannot be read (§5.4.3). Its version is chosen by
+ * the pack's assembler with no accept-set, so this is unknown, never clean.
  */
 export const PACK_DECLARATION_UNREADABLE = "pack_declaration_unreadable";
 /**
- * The pack carries no `declaration` member at all, so it never said what it
- * holds. `partial` is 5.4.3's own word for a claim nobody made: never
- * `verified`, because there is nothing to check the pack against, and never
- * `failed`, because nothing is wrong.
+ * The pack carries no `declaration`. `partial` (§5.4.3): nothing to check
+ * against, and nothing wrong.
  */
 export const PACK_UNDECLARED = "pack_undeclared";
-/**
- * The pack's `body_type` is not one this reader knows to carry `events[]`
- * (`CASE_BODY_TYPES`).
- */
+/** The pack's `body_type` is not in `CASE_BODY_TYPES`. */
 export const PACK_BODY_TYPE_UNKNOWN = "pack_body_type_unknown";
-/**
- * The pack carries a body this reader knows and no records in it. A pack that
- * contributes nothing is named rather than passed over.
- */
+/** The pack carries a known body with no records. */
 export const PACK_HOLDS_NO_RECORDS = "pack_holds_no_records";
 /**
- * The key the pack's wrapper names is not one this reader can read as a key
- * (`normalizedSigningKey` returns nothing for it), so who signed the pack is
- * UNKNOWN. The pack is not verified and none of its records are read, and
- * every one-sided record whose named key signed no verified pack reads
- * `COUNTERPART_ABSENT_SIGNER_UNKNOWN`.
- *
- * Found by constructing it, while enumerating this module's exits: the wrapper
- * key is the ONE input that separates the two counterpart kinds, and a key this
- * reader could not read used to drop out of that set in silence. The Python
- * `verify_evidence_bundle` accepts a wrapper `public_key` with ASCII
- * whitespace inside it or around it (`bytes.fromhex` skips it; this kernel's
- * verifier rejects it), so a counterparty that signed its own pack under
- * `" " + key` handed a Python reader a pack that verified, contributed no key,
- * and moved the subject from `COUNTERPART_ABSENT_FROM_COUNTERPARTY_RECORDS` to
- * the innocent `COUNTERPART_ABSENT`. The same repair 4.1 made for a RECORD
- * whose envelope key it cannot read (proof#133, fourth hunt): a key a reader
- * holds and cannot read is named, never treated as absent. It is `incomplete`
- * rather than `malformed` because whether the spelling verifies is the envelope
- * layer's call (proof#135), and this reader only knows it cannot read it.
+ * The pack's wrapper key cannot be read (`normalizedSigningKey` returns
+ * nothing), so its signer is unknown. None of its records are read, and a
+ * one-sided record whose named key signed no verified pack reads
+ * `COUNTERPART_ABSENT_SIGNER_UNKNOWN`. A key a reader holds and cannot read is
+ * named, never treated as absent. `incomplete`: whether the spelling verifies
+ * is the envelope layer's call.
  */
 export const PACK_KEY_UNREADABLE = "pack_key_unreadable";
 /**
- * The pack does not verify as a bundle: `verifyEvidenceBundle`, run here
- * offline over the pack and its side content, returned `failed` or
- * `malformed`. None of its records are read, because a record from it would
- * reach 4.1 without the verified envelope `HeldRecord` requires, and the key
- * its wrapper claims is never counted as a pack signer: an unverified wrapper
- * claiming the counterparty's key is exactly what an accusing party would
- * forge.
- *
- * `partial` is not this exception. `partial` means the wrapper signature and
- * `body_hash` held and part of the body could not be determined, which is what
- * an unknown body or withheld bytes produce, and those are named on their own.
- *
- * `failed`: a pack in the case is proven broken.
+ * The pack's `bundle.json` cannot be read as JSON: it does not parse, nests too deep, or
+ * names one member twice. The pack is not verified and none of its records are read, and
+ * every other pack in the case still is. `incomplete`: the signature could not be checked.
+ */
+export const PACK_UNREADABLE = "pack_unreadable";
+/**
+ * `verifyEvidenceBundle`, run offline here, returned `failed` or `malformed`.
+ * None of its records are read (§4.1 requires verified envelopes), and its
+ * wrapper key is never counted as a pack signer: an unverified wrapper claiming
+ * the counterparty's key is what an accuser would forge. `failed`.
  */
 export const PACK_DOES_NOT_VERIFY = "pack_does_not_verify";
 /**
- * The pack's wrapper HOLDS and its CASE GRADE is not `verified`
- * (evidence-bundle 5.5.1 step 1 v1.20, A23; it replaces
- * `pack_bundle_not_verified`, which carried the bundle status alone). The case
- * grade is the pack grade of 5.4.5, taken twice: the SIGNED grade over the run
- * with the side map empty, and the FULL grade over the run with it. The signed
- * grade decides where it is `failed` or `malformed`; a failure only the full
- * grade reaches is `incomplete`, because it rests on bytes nobody signed;
- * otherwise the full grade. A body the verifier could not read is `malformed`,
- * a body that is not one of the two event-carrying bodies takes the signed
- * run's status, and a verifier that graded a different number of records than
- * the pack holds takes the signed status, or `malformed` where that status is
+ * The pack's wrapper holds and its case grade is not `verified`
+ * (evidence-bundle §5.5.1). The case grade is the §5.4.5 pack grade taken
+ * twice: signed (side map empty) and full (with it). The signed grade decides
+ * where it is `failed` or `malformed`; a failure only the full grade reaches is
+ * `incomplete`, since it rests on unsigned bytes; otherwise the full grade.
+ * An unreadable body is `malformed`; a non-event body takes the signed status;
+ * a record-count mismatch takes the signed status, or `malformed` where that is
  * `verified`.
  *
- * The exception carries `status`, the case grade; `causes`, the 5.4.5 cause
- * kinds of the grade that decided it (none in the first three branches); and
- * `reasons`, the verifier's reasons from the run with the side map empty. It
- * CONTRIBUTES the grade, and `incomplete` for `pending`, `not_found` or
- * `mixed`, so the case verdict never reads above its weakest pack.
+ * Carries `status`, `causes` (the deciding grade's cause kinds) and `reasons`
+ * (from the signed run). Contributes the grade, or `incomplete` for `pending`,
+ * `not_found` or `mixed`, so the case never reads above its weakest pack.
  */
 export const PACK_GRADE_NOT_VERIFIED = "pack_grade_not_verified";
 /**
- * A record in a pack whose wrapper holds, whose OWN envelope does not verify
- * (`EventResult.envelopeOk` is false). Not read by 4.1, and NAMED with the
- * verifier's reasons. `failed`: a pack its holder signed carries a record that
- * is proven not to verify. As a reason to drop the whole pack it let the
- * counterparty add one junk event to its own pack, re-seal it, and strip a
- * proven `message_hash` failure out of the case (gate 3 on proof#140).
+ * A record whose own envelope does not verify, in a pack whose wrapper holds.
+ * Not read by §4.1. `failed`. Scoped to the record so one junk event cannot
+ * drop the whole pack and a proven failure with it.
  */
 export const RECORD_ENVELOPE_DOES_NOT_VERIFY = "record_envelope_does_not_verify";
 /**
- * A record whose envelope verifies and which fails another check the bundle
- * verifier grades it on inside its pack (its inclusion proof, its join to a
- * checkpoint or stamp, a retired field name). NAMED with the verifier's
- * reasons, `failed`, and the record STAYS in the pile: a holder that could
- * remove its own tampered receipt from pairing by breaking that receipt's
- * inclusion proof would be choosing its own reading.
+ * A record whose envelope verifies but which fails another check in its pack
+ * (inclusion proof, checkpoint or stamp join, a retired field). `failed`, and
+ * the record stays in the pile, so breaking its own proof cannot remove a
+ * tampered receipt from pairing.
  */
 export const RECORD_DOES_NOT_VERIFY_IN_ITS_PACK = "record_does_not_verify_in_its_pack";
 /**
- * A record whose envelope verifies and whose disclosed content does not hash to
- * the hash it commits to, its `content_hash` or a hand-off record's
- * `message_hash` (evidence-bundle v1.19, A20) (`EventResult.contentOk` is false), with the
- * side map EMPTY: the content is inside the signed body. The same mismatch from
- * content handed in beside the pack is `RECORD_CONTENT_DEPENDENT` (proof#159).
- * `failed`, and the record STAYS in the pile: content beside a pack is unsigned and often
- * supplied by whoever assembled the case, and gate 3 on proof#140 showed that
- * party erasing an honest verified pair by swapping it.
+ * A record whose disclosed content does not hash to its `content_hash` (or a
+ * hand-off record's `message_hash`) with the side map empty: the content is in
+ * the signed body. `failed`, and the record stays in the pile.
  */
 export const RECORD_CONTENT_MISMATCH = "record_content_mismatch";
 /**
- * The two readings proof#147 did not reach, given its shape (proof#159, ruled
- * by Phil 2026-09-22, evidence-bundle.md 5.5.4 v1.16, A17). A pack whose
- * bundle verdict is `failed` ONLY when read with the unsigned content handed
- * in beside it, and `failed` no longer when read with that map empty, is
- * `PACK_BUNDLE_CONTENT_DEPENDENT`; a record whose content mismatch comes from
- * that map alone is `RECORD_CONTENT_DEPENDENT`. Both are `incomplete`: the
- * reader established that the bytes it was handed are not the bytes the record
- * commits to, and nothing about the party that signed the record, because
- * whoever assembled the case chose those bytes with no key. Up to v1.15 both
- * readings carried `failed`, and one flipped nibble of accuser-supplied content
- * put a `failed` against an intact pack; under A17's headline rule that would
- * have become the case's headline.
- *
- * The test that separates the two is the one proof#159 states for the inverse:
- * every deviation a signature covers still reads `failed` with the side map
- * EMPTY. So the pack is verified twice, with the map and without it, and what
- * fails without it is `PACK_GRADE_NOT_VERIFIED`, `RECORD_CONTENT_MISMATCH`
- * (content inside the signed body) or `RECORD_DOES_NOT_VERIFY_IN_ITS_PACK`,
- * each still `failed`. Emptying the map is the most a party that signed
- * nothing can do to starve the check, and it cannot remove any of those.
+ * A pack whose bundle verdict is `failed` only with the unsigned side content,
+ * and a record whose content mismatch comes from that content alone
+ * (evidence-bundle §5.5.4). Both `incomplete`: whoever assembled the case chose
+ * those bytes with no key. Every deviation a signature covers still fails with
+ * the side map empty, so starving the check cannot hide one.
  */
 export const PACK_BUNDLE_CONTENT_DEPENDENT = "pack_bundle_content_dependent";
 export const RECORD_CONTENT_DEPENDENT = "record_content_dependent";
 /**
- * A record signed under a ratified profile that is under quarantine
- * (`CASE_QUARANTINED_PROFILES`, pending DL-63). Not read, in any kernel.
- * `incomplete`: whether it verifies is what the kernels disagree about.
+ * A record under a quarantined profile (`CASE_QUARANTINED_PROFILES`). Not read.
+ * `incomplete`.
  */
 export const RECORD_PROFILE_QUARANTINED = "record_profile_quarantined";
 /** The reader was handed no packs at all. */
 export const CASE_HOLDS_NO_PACKS = "case_holds_no_packs";
 /**
- * The three NOTEs (5.5.3 v1.20, extended proof#148): findings on the reading
- * with no contribution, printed in the scope sentence so a clean verdict
- * never hides any of them. `pack_undeclared` is a note only where the
- * reading holds no hand-off record; where it holds one, it is the exception
- * of that name.
+ * Notes (§5.5.3): findings with no verdict contribution, printed in the scope
+ * sentence so a clean verdict never hides them. `pack_undeclared` is a note
+ * only where the reading holds no hand-off record; otherwise it is the
+ * exception.
  */
 export const CONTENT_WITHHELD_BY_DECLARATION = "content_withheld_by_declaration";
 /**
- * A pack's wrapper carries a present `co_signatures` (evidence-bundle.md §2,
- * decided by Phil 2026-09-24 on proof#148). The field verifies nothing and
- * sits outside the wrapper's signed scope, so the case reading names it
- * rather than presenting it as evidence, and it contributes no verdict.
+ * A pack's wrapper carries `co_signatures` (evidence-bundle section 2). It verifies
+ * nothing and sits outside the signed scope, so it is named, not presented as
+ * evidence.
  */
 export const CO_SIGNATURES_PRESENT = "co_signatures_present";
 export const CASE_NOTE_KINDS = [
@@ -686,18 +295,17 @@ export const CASE_NOTE_KINDS = [
     CONTENT_WITHHELD_BY_DECLARATION,
     CO_SIGNATURES_PRESENT,
 ];
-/**
- * Every exception this reader can report, as a closed set. A surface may render
- * them and a test may assert over them; nothing outside this array is emitted.
- */
+/** Every exception this reader can report. Nothing outside this set is emitted. */
 export const CASE_EXCEPTION_KINDS = [
     COUNTERPART_ABSENT,
     COUNTERPART_ABSENT_FROM_COUNTERPARTY_RECORDS,
     COUNTERPART_ABSENT_SIGNER_UNKNOWN,
     COUNTERPART_AMBIGUOUS,
     COUNTERPART_MALFORMED,
+    COUNTERPART_NONCONFORMING,
     PAIR_FAILED,
     RECORD_MALFORMED,
+    RECORD_NONCONFORMING,
     RECORD_UNCLAIMED,
     RECORD_BYTES_WITHHELD,
     RECORD_BYTES_UNREADABLE,
@@ -707,6 +315,7 @@ export const CASE_EXCEPTION_KINDS = [
     PACK_UNDECLARED,
     PACK_BODY_TYPE_UNKNOWN,
     PACK_HOLDS_NO_RECORDS,
+    PACK_UNREADABLE,
     PACK_KEY_UNREADABLE,
     PACK_DOES_NOT_VERIFY,
     PACK_GRADE_NOT_VERIFIED,
@@ -719,141 +328,57 @@ export const CASE_EXCEPTION_KINDS = [
     CASE_HOLDS_NO_PACKS,
 ];
 /**
- * The status every record in every pack carries (evidence-bundle 5.5.4
- * v1.35, A43, proof#204), as a closed set. A record is listed for each element
- * of its pack's `body.events` as `packRecords` reads them, or, for a
- * `sanning.evidence.export/v2` pack, of the events of the inline source
- * bundle it wraps (`resolveTraceEvents`), and gets exactly one:
- *
- * - `read_clean`: the record went into the pile, no exception carries its
- *   `packIndex` and `recordIndex`, and its pack's declaration check
- *   names it by nothing (`declarationFindings` is empty). It says nothing
- *   about its PACK: the pack's own grade and exceptions are on the pack, and a
- *   surface MUST show that grade beside the status.
- * - `read_flagged`: the record went into the pile, and at least one
- *   exception carries its `packIndex` and `recordIndex`, or its pack's
- *   declaration check names its `eventId` by a deviation or a content
- *   finding (`declarationFindings` is not empty; under an `eventId` the
- *   pack carries twice, every record with that id). An exception about the
- *   pack alone flags no record.
- * - `not_read`: the record never went into the pile. `reason` is the kind
- *   of the exception that says why, on the record
- *   (`record_profile_quarantined`, `record_envelope_does_not_verify`,
- *   `record_bytes_withheld`, `record_bytes_unreadable`) or on its pack
- *   (`pack_key_unreadable`, `pack_does_not_verify`,
- *   `pack_body_type_unknown`, `pack_grade_not_verified` where the body
- *   could not be read or the verifier graded a different number of records).
- *   An export's wrapped records carry the reason of the exception their pack
- *   actually got: `pack_body_type_unknown` where its wrapper holds, and
- *   otherwise `pack_key_unreadable`, `pack_does_not_verify` or
- *   `pack_grade_not_verified`.
- *
- * Before A43 the reading listed only the records it read, so a surface had to
- * work out which records were missing, and why, by a rule of its own.
+ * The status each record of each pack gets (evidence-bundle §5.5.4), one per
+ * element of `body.events` (or, for an export, its source bundle's events):
+ *
+ * - `read_clean`: in the pile, named by no exception and no declaration
+ *   finding. Says nothing about its pack; a surface must show the pack grade
+ *   beside it.
+ * - `read_flagged`: in the pile, and named by an exception or a declaration
+ *   finding (every record sharing a duplicated `eventId`). A pack-only
+ *   exception flags no record.
+ * - `not_read`: never in the pile. `reason` is the record or pack exception
+ *   that says why; an export's wrapped records take their pack's exception.
  */
 export const CASE_RECORD_STATUSES = ["read_clean", "read_flagged", "not_read"];
 /**
- * What each exception kind contributes to the case verdict. It is a TABLE and
- * not a chain of branches, so "which exceptions move the verdict" is one thing
- * a reader can read, and so that adding a kind without deciding what it means
- * is a missing entry rather than a quiet `verified`.
- *
- * Read the `incomplete` rows as "I could not tell", which is the distinction
- * this whole module turns on. None of them is `verified`: an exception never
- * contributes a clean verdict, which is what makes the invariant in `verdictOf`
- * hold.
- *
- * `PACK_GRADE_NOT_VERIFIED` is the one row that is not a constant: it
- * contributes the pack's case grade, which is never `verified` (the exception
- * is emitted only when it is not). `null` marks that row, and `readCase` fills
- * it from `status`.
- */
-const EXCEPTION_VERDICT = {
-    [COUNTERPART_ABSENT]: "incomplete",
-    [COUNTERPART_ABSENT_FROM_COUNTERPARTY_RECORDS]: "incomplete",
-    [COUNTERPART_ABSENT_SIGNER_UNKNOWN]: "incomplete",
-    [COUNTERPART_AMBIGUOUS]: "incomplete",
-    [COUNTERPART_MALFORMED]: "incomplete",
-    [PAIR_FAILED]: "failed",
-    [RECORD_MALFORMED]: "malformed",
-    [RECORD_UNCLAIMED]: "incomplete",
-    [RECORD_BYTES_WITHHELD]: "incomplete",
-    [RECORD_BYTES_UNREADABLE]: "malformed",
-    [PACK_DECLARATION_DEVIATES]: "failed",
-    [PACK_DECLARATION_CONTENT_DEPENDENT]: "incomplete",
-    [PACK_DECLARATION_UNREADABLE]: "incomplete",
-    [PACK_UNDECLARED]: "partial",
-    [PACK_BODY_TYPE_UNKNOWN]: "incomplete",
-    [PACK_HOLDS_NO_RECORDS]: "incomplete",
-    [PACK_KEY_UNREADABLE]: "incomplete",
-    [PACK_DOES_NOT_VERIFY]: "failed",
-    [PACK_GRADE_NOT_VERIFIED]: null,
-    [PACK_BUNDLE_CONTENT_DEPENDENT]: "incomplete",
-    [RECORD_ENVELOPE_DOES_NOT_VERIFY]: "failed",
-    [RECORD_DOES_NOT_VERIFY_IN_ITS_PACK]: "failed",
-    [RECORD_CONTENT_MISMATCH]: "failed",
-    [RECORD_CONTENT_DEPENDENT]: "incomplete",
-    [RECORD_PROFILE_QUARANTINED]: "incomplete",
-    [CASE_HOLDS_NO_PACKS]: "partial",
-};
-/**
- * The case grades `PACK_GRADE_NOT_VERIFIED` contributes as themselves. Every
- * other grade a pack can reach (`pending`, `not_found`, `mixed`, which a pack
- * grade passes through and a case verdict never issues) is `incomplete`.
+ * What each exception kind contributes to the case verdict, read off the claim it maps to
+ * (`KIND_CLAIMS` in `claims.ts`): a disproof is `failed`, anything not proven
+ * `incomplete`. A kind with no mapping throws rather than reading as a quiet `verified`.
+ * `null` marks `PACK_GRADE_NOT_VERIFIED`, which contributes the pack's case grade from
+ * `status`.
  */
-const GRADE_CONTRIBUTES = new Set([
-    "partial",
-    "incomplete",
-    "failed",
-    "malformed",
-]);
-// ---- The reading ------------------------------------------------------------
+const EXCEPTION_VERDICT = Object.fromEntries(CASE_EXCEPTION_KINDS.map((kind) => {
+    if (kind === PACK_GRADE_NOT_VERIFIED)
+        return [kind, null];
+    const mapping = KIND_CLAIMS[kind];
+    if (mapping === undefined)
+        throw new Error(`KeyError: '${kind}'`);
+    return [kind, mapping[1] === "disproven" ? "failed" : "incomplete"];
+}));
 const bodyTypeOf = (bundle) => typeof bundle === "object" && bundle !== null
     ? bundle["body_type"]
     : undefined;
 /**
- * The key that SIGNED the pack wrapper, which is the key that signed the pack's
- * declaration.
- *
- * The wrapper signature covers `body_hash` and `body` carries the
- * `declaration` (`evidence-bundle.md` 5.1, 5.4.1), so this key is the party
- * whose signed account of itself this pack is. Read from the ENVELOPE of the
- * pack and never from `issuer`: `issuer` is a label and DL-60 keeps it out of
- * every reading, while `public_key` is the value the signature binds.
- *
- * It means something only for a pack whose wrapper HOLDS, which is why
- * `readCase` counts it only after its own `verifyEvidenceBundle` call over the
- * pack returned `signatureOk` and `bodyHashOk`.
+ * The key that signed the pack wrapper, and so the pack's declaration
+ * (evidence-bundle §5.1, §5.4.1). Read from `public_key`, never `issuer`, which
+ * is a label. Meaningful only once the wrapper is verified to hold.
  */
 const holderKeyOf = (bundle) => typeof bundle === "object" && bundle !== null
     ? bundle["public_key"]
     : undefined;
 /**
- * Provenance, and nothing else: the wrapper signature over `body_hash` verified
- * and `body_hash` is the hash of the body (evidence-bundle.md 5.5.1 step 1).
- * Nothing inside the body is part of this answer.
- */
-const wrapperHolds = (result) => result.signatureOk && result.bodyHashOk;
-/**
- * Why the pack reads what it reads, as the verifier said it: its bundle errors,
- * then each stamp's, then each checkpoint's, then each event's behind the
- * event's own id.
- *
- * The event errors are here as well as on the records' own exceptions on
- * purpose. A pack whose only defect is one record reads `failed` with no
- * bundle-level error at all, and an exception that named the verdict and no
- * reason would send a reader looking for a defect in the pack as a whole.
+ * Provenance only: the wrapper signature verified and `body_hash` matches the
+ * body (evidence-bundle §5.5.1). Under a version this verifier does not know, the
+ * signature alone ties the pack to its key, and the body is not read.
  */
+const wrapperHolds = (result) => result.signatureOk && (result.bodyHashOk || result.versionUnknown === true);
 /**
- * The reasons a reading carries only because of the side map, in the order the
- * verifier wrote them: what the content-dependent kinds are about, and nothing
- * a signature covers.
+ * Reasons present only with the side map: what the content-dependent kinds are
+ * about, and nothing a signature covers.
  */
 const onlyIn = (withMap, withoutMap) => withMap.filter((reason) => !withoutMap.includes(reason));
-/**
- * Whether a side-content map holds any key. Python's `if pack.content` is
- * the twin: `None` and an empty map both mean the two verify runs are one run.
- */
+/** `null`, `undefined` and an empty map all mean the two verify runs are one. */
 function sideMapHasKeys(content) {
     if (content === null || content === undefined)
         return false;
@@ -861,6 +386,11 @@ function sideMapHasKeys(content) {
         return content.size > 0;
     return Object.keys(content).length > 0;
 }
+/**
+ * The verifier's reasons for a pack: bundle, then stamps, checkpoints and
+ * events (prefixed with the event id). Event errors are included because a pack
+ * whose only defect is one record has no bundle-level error.
+ */
 const bundleReasons = (result) => [
     ...result.errors,
     ...(result.stamps ?? []).flatMap((stamp) => stamp.errors),
@@ -868,9 +398,8 @@ const bundleReasons = (result) => [
     ...result.events.flatMap((ev) => ev.errors.map((e) => `${ev.eventId}: ${e}`)),
 ];
 /**
- * The `spec_version` of the envelope of `body.events[index]`, as written.
- * `packRecords` and the bundle verifier both walk `body.events` in order, so
- * `index` is the same record in both.
+ * The `spec_version` of `body.events[index]`'s envelope. `packRecords` and the
+ * verifier walk events in the same order.
  */
 function recordSpecVersion(bundle, index) {
     const at = (v, k) => typeof v === "object" && v !== null ? v[k] : undefined;
@@ -878,8 +407,8 @@ function recordSpecVersion(bundle, index) {
     return Array.isArray(events) ? at(at(events[index], "envelope"), "spec_version") : undefined;
 }
 /**
- * `specVersion` is a quarantined profile, on the same token boundary the
- * envelope layer's own accept-check uses (`specVersionSupported`).
+ * Whether `specVersion` is quarantined, on the token boundary
+ * `specVersionSupported` uses.
  */
 function underQuarantine(specVersion) {
     if (typeof specVersion !== "string")
@@ -894,96 +423,235 @@ function underQuarantine(specVersion) {
     });
 }
 /**
- * The case verdict, from the contributions alone.
- *
- * **A proven failure keeps the headline** (`evidence-bundle.md` 5.5.4 v1.16,
- * A17, proof#158): if any contribution is `failed`, the case is `failed`,
- * whatever else contributes, and every other exception stays named beside it.
- * Otherwise one outcome is that outcome, and more than one is `mixed`
- * (anchor#198, criterion 4), so `mixed` never holds a `failed`. `malformed`
- * does NOT keep the headline: it says a record cannot be read, not that a
- * check ran and did not pass. `mixed` is in the 3 vocabulary and coins no word.
+ * The case verdict, from the contributions alone: `failed` where any contribution is,
+ * else `incomplete` where any is, else `verified`. A case reads its worst pack, and every
+ * exception is still named beside it.
  *
- * THE INVARIANT, stated so a mutation test has something to kill: `verified` is
- * reachable ONLY when `exceptions` is empty. Every exception kind carries a
- * non-`verified` contribution (`EXCEPTION_VERDICT`), so this falls out of the
- * table rather than being enforced by a second rule that could drift from it.
- * The assertion is here anyway, because that is the property every one of the
- * seventeen findings on this program violated.
+ * Invariant: `verified` only when `exceptions` is empty. It follows from
+ * `EXCEPTION_VERDICT` and is asserted anyway.
  */
 function verdictOf(exceptions, contributions, holdsPacks = true) {
-    // A reading that holds at least one pack and no contribution at all is
-    // `verified` (5.5.4 v1.20, A23): every pack in it graded `verified` and
-    // nothing in it was an exception. Every exception contributes, so no
-    // contribution means no exception. A reading with no packs always carries
-    // `case_holds_no_packs`, and is defended here anyway: an empty aggregate over
-    // nothing reading as `verified` is the defect class itself.
+    // No contribution means every pack graded `verified` and no exception. A
+    // reading with no packs is `incomplete`, never `verified` over nothing.
     if (contributions.length === 0) {
         if (exceptions.length > 0) {
             throw new Error(`exceptions with no contribution: ${exceptions.map((e) => e.kind).join(", ")}`);
         }
-        return holdsPacks ? "verified" : "partial";
+        return holdsPacks ? "verified" : "incomplete";
     }
     const outcomes = new Set(contributions.map(([, v]) => v));
     const verdict = outcomes.has("failed")
         ? "failed"
-        : outcomes.size === 1
-            ? [...outcomes][0]
-            : "mixed";
+        : outcomes.has("incomplete")
+            ? "incomplete"
+            : "verified";
     if (verdict === "verified" && exceptions.length > 0) {
         throw new Error(`verified over a non-empty exception list: ${exceptions.map((e) => e.kind).join(", ")}`);
     }
     return verdict;
 }
+function at(pack, record = null) {
+    return [[pack, record]];
+}
+// The envelope faults a record's pack already names with their own claim, so the case does
+// not also call the envelope one whose signature fails.
+const ENVELOPE_FAULTS_OF_THE_PACK = [
+    "payload_unbound",
+    "not_an_envelope",
+    "key_unreadable",
+    "spec_version_unknown",
+    "nonconforming",
+];
+/** A pack's own problems (read at position 0) at its position in the case. */
+function moved(problems, position) {
+    return problems.map((p) => withItems(p, p.items.map(([, ...rest]) => [position, ...rest])));
+}
 /**
- * Read a whole case: several packs in, one verdict and its exceptions out.
- *
- * The order of the work, and why it is this order:
- *
- * 1. **Each pack is read into records**, through `packRecords`, which is the
- *    one implementation of "what does this pack hold". A pack whose `body_type`
- *    this reader does not know, or which holds no records, is NAMED here and
- *    its records are not silently zero.
- * 2. **Each pack is graded against its own declaration**, through
- *    `checkDeclaration`, which is the one implementation of 5.4. A pack proven
- *    to deviate from its own claim fails the case.
- * 3. **Every record every pack supplied goes into ONE pile**, with no partition
- *    by pack, by issuer or by organization, and the pile is read by
- *    `readHandoffs`, which is the one implementation of 4.1. This is where
- *    matching happens, and it is on keys and hashes alone.
- * 4. **Each reading becomes an exception or a clean contribution**, and the two
- *    counterpart kinds are separated by asking whether a pack SIGNED by the
- *    counterparty's key is in the case, a key read from every pack's wrapper
- *    before any exit can skip it.
- *
- * A record whose bytes the pack did not supply never reaches the pile, because
- * there is nothing to put in it. That is exactly the shape this module has to
- * refuse to pass over in silence, so it is named at step 1 and carries
- * `incomplete`: the reader genuinely cannot tell whether the record it cannot
- * see is the counterpart that is missing.
+ * Every exception, mapped to its claim and state, in exception order. A pack grade
+ * carries its own problems; a pack grade with none (a defence) reads as its status.
+ */
+export function caseProblems(exceptions) {
+    const out = [];
+    for (const e of exceptions) {
+        let items;
+        if (e.recordIndex !== undefined)
+            items = at(e.packIndex ?? null, e.recordIndex);
+        else if (e.packIndex !== undefined)
+            items = at(e.packIndex);
+        else
+            items = at(null);
+        if (e.kind === PACK_GRADE_NOT_VERIFIED) {
+            if (e.problems !== undefined && e.problems.length > 0)
+                out.push(...e.problems);
+            else if (e.status === "failed")
+                out.push(problem("bundle_does_not_verify", items));
+            else
+                out.push(problem("bundle_not_checked", items));
+            continue;
+        }
+        if (e.kind === PAIR_FAILED && e.failedChecks !== undefined && e.failedChecks.length > 0) {
+            // One problem per check that failed, so each is said in its own words.
+            for (const c of e.failedChecks)
+                out.push(problem(e.kind, items, { rule: c }));
+            continue;
+        }
+        out.push(problem(e.kind, items, {
+            key: e.kind.startsWith("counterpart_absent") ? (e.counterpartyKey ?? null) : null,
+        }));
+    }
+    return out;
+}
+/**
+ * The reading, with its problems and the verdict they give, which must be the verdict
+ * the contributions give: two derivations of one answer, held to agree.
+ */
+function withProblems(reading) {
+    const problems = caseProblems(reading.exceptions);
+    const outcome = claimsVerdictOf(claimsOf(problems));
+    if (outcome.status !== reading.verdict) {
+        throw new Error(`two derivations of one verdict disagree: ${outcome.status} and ${reading.verdict}`);
+    }
+    return {
+        ...reading,
+        ...(outcome.reason_kind === undefined ? {} : { reasonKind: outcome.reason_kind }),
+        problems,
+    };
+}
+/**
+ * The pack's grade, read as `verify --logs` reads it: no disproof rests on bytes nobody
+ * signed.
+ */
+async function gradeInCase(pack, verified, signed, position) {
+    const bodyType = bodyTypeOf(pack.bundle);
+    const records = packRecords(pack.bundle, pack.content);
+    // Per-record gradings are joined to `records` by index. A pack whose
+    // `body_hash` does not cover its body reads `failed` with no events, so a
+    // count mismatch is graded, never indexed into.
+    const ungraded = verified.events.length !== records.length || signed.events.length !== records.length;
+    const knownBody = CASE_BODY_TYPES.includes(bodyType);
+    // The pack's grade propagates: the case never reads above its weakest pack.
+    let check = null;
+    let full = null;
+    let causes = [];
+    let grade;
+    let packProblems = bundleProblems(signed, position);
+    if (signed.unreadable === true) {
+        // A body that cannot be read under a wrapper whose time breaks its format fails.
+        grade = signed.status === "failed" ? "failed" : "incomplete";
+    }
+    else if (!knownBody) {
+        grade = signed.status;
+    }
+    else if (ungraded) {
+        grade = signed.status === "verified" ? "incomplete" : signed.status;
+        if (signed.status === "verified")
+            packProblems = [problem("bundle_not_checked", at(position))];
+    }
+    else {
+        // The declaration's chain rule reads the same signed chain links for both
+        // checks (evidence-bundle §5.4.2).
+        const chainLinks = await readChainLinks(pack.bundle);
+        check = checkDeclaration(pack.bundle, pack.content, chainLinks);
+        const completeness = completenessNotes(pack.bundle);
+        full = gradePack(verified, accountDisclosure(pack.bundle, pack.content ?? {}), completeness, check);
+        const bareGrade = gradePack(signed, accountDisclosure(pack.bundle, {}), completeness, checkDeclaration(pack.bundle, null, chainLinks));
+        // No disproof here rests on unsigned bytes: each disproof the pack read with the
+        // bytes beside it makes and the signed reading does not is not proven, as `verify`
+        // reads it, and everything else is the reading with those bytes, so a pack's logs/
+        // count in `case` as they do in `verify --logs`.
+        packProblems = moved(restOnSigned(full.problems, bareGrade.problems), position);
+        grade = claimsVerdictOf(claimsOf(packProblems)).status;
+        causes = full.causes.map((c) => c.kind);
+    }
+    return { grade, problems: packProblems, causes, check, full, records, ungraded, knownBody };
+}
+/**
+ * Each pack that reads as a pack, verified twice: with the side map, and with
+ * it empty. What fails only in the first rests on bytes nobody
+ * signed. One run where there is no map. Offline, no gateways.
+ */
+async function verifyPacks(packs) {
+    const runs = new Map();
+    for (const [position, pack] of packs.entries()) {
+        if (typeof pack.unreadable === "string")
+            continue;
+        const verified = await verifyEvidenceBundle(pack.bundle, {
+            content: (pack.content ?? undefined),
+        });
+        const signed = sideMapHasKeys(pack.content)
+            ? await verifyEvidenceBundle(pack.bundle, {})
+            : verified;
+        runs.set(position, [verified, signed]);
+    }
+    return runs;
+}
+/**
+ * Read the agent records of every pack as one pile and put each reading on
+ * both runs of its pack, in place of the reading over its own pack alone
+ * (agent-events.md section 10 step 7): pairing, chains and closing lists span packs.
+ * A record takes part where its pack's wrapper holds, its pack's records are
+ * all graded, and its envelope verified with its record bytes bound to it.
+ */
+async function readAgentRecordsAcross(packs, runs) {
+    const items = [];
+    const where = [];
+    for (const [position, [verified, signed]] of runs) {
+        if (!wrapperHolds(verified))
+            continue;
+        const records = packRecords(packs[position].bundle, packs[position].content);
+        if (verified.events.length !== records.length || signed.events.length !== records.length)
+            continue;
+        for (const [index, record] of records.entries()) {
+            const graded = verified.events[index];
+            graded.agent = null;
+            signed.events[index].agent = null;
+            if (graded.envelopeOk && graded.payloadBindingOk === true && record.record !== null) {
+                items.push({ event_id: record.eventId, public_key: record.publicKey, record: record.record });
+                where.push([position, index]);
+            }
+        }
+    }
+    const readings = await readAgentRecords(items);
+    for (const [i, [position, index]] of where.entries()) {
+        const [verified, signed] = runs.get(position);
+        verified.events[index].agent = readings[i];
+        signed.events[index].agent = readings[i];
+    }
+}
+/**
+ * Reads a case: packs in, one verdict and its exceptions out.
+ *
+ * 1. Each pack is read into records (`packRecords`); an unknown body or no
+ *    records is named.
+ * 2. Each pack is graded against its own declaration (`checkDeclaration`).
+ * 3. Every record goes into one pile, unpartitioned, read by `readHandoffs`.
+ * 4. Each reading becomes an exception or a clean contribution. The
+ *    counterpart kinds are told apart by whether a pack signed by the
+ *    counterparty's key is in the case, read from every wrapper before any exit.
+ *
+ * Before step 1 the agent records of every pack are read as one pile
+ * (agent-events.md section 10), and each pack is graded with those readings
+ * (evidence-bundle.md section 5.4.5, section 5.5.1).
  */
 export async function readCase(packs) {
-    // A `null` slot is held for each pack that carries no declaration, and
-    // settled once the pile says whether the reading holds a hand-off record.
+    // A `null` slot is held for each undeclared pack until the pile says whether
+    // the reading holds a hand-off record.
     const exceptions = [];
     const contributions = [];
     const note = (kind, fields = {}) => {
         exceptions.push({ kind, ...fields });
-        // `null` is PACK_GRADE_NOT_VERIFIED: the pack's case grade, never
-        // verified, and `incomplete` for a word a pack grade passes through and a
-        // case verdict never issues (5.5.1 step 1 v1.20).
+        // `null` is PACK_GRADE_NOT_VERIFIED: contribute the pack's case grade, never
+        // verified (section 5.5.1 step 1).
         let contribution = EXCEPTION_VERDICT[kind];
-        if (contribution === null) {
-            const status = fields.status;
-            contribution = GRADE_CONTRIBUTES.has(status) ? status : "incomplete";
-        }
+        if (contribution === null)
+            contribution = fields.status;
         contributions.push([fields.eventId ?? fields.packRef ?? "case", contribution]);
     };
     if (packs.length === 0) {
         note(CASE_HOLDS_NO_PACKS);
         const named = exceptions;
         const contributed = contributions;
-        return {
+        return withProblems({
             verdict: verdictOf(named, contributed, false),
             exceptions: named,
             records: [],
@@ -992,85 +660,81 @@ export async function readCase(packs) {
             onChainChecked: false,
             notes: [],
             packs: [],
-        };
+        });
     }
-    // Step 1 and 2, pack by pack, in the order the reader was given them.
-    // Whether every pack's witness was re-fetched on chain, ALL over the packs
-    // this reader verified. It passes no gateways, so this stays false and the
-    // reading says so (see `CaseReading.onChainChecked`).
+    // Steps 1 and 2, pack by pack. No gateways, so `witnessChecked` stays false.
     const witnessChecked = [];
     const held = [];
-    // The pack and the `event_id` behind each pile member, kept beside the pile
-    // rather than parsed back out of a reference string. A reference is for a
-    // human to read; a join rebuilt by splitting one is a join on a value a
-    // holder can put a separator in.
+    // Pack and `event_id` per pile member, kept beside the pile rather than
+    // parsed from a reference string a holder could put a separator in.
     const provenance = [];
-    // Every record of every pack, in pack order and bundle order (A43): where it
-    // went into the pile, its place there (`heldAt`), and where it did not, the
-    // kind of the exception that says why. Nothing is listed only where the pack
-    // body carries no `events` array, and that pack's own exception says why.
+    // Every record of every pack, in order: its pile position, or the exception
+    // kind that kept it out.
     const slots = [];
     const unread = (position, packRef, listed, reason) => {
         listed.forEach((record, recordIndex) => slots.push({ position, packRef, recordIndex, eventId: record.eventId, heldAt: null, reason }));
     };
-    // The kinds each pack's declaration check names each record by, keyed by the
-    // pack's POSITION and then by `eventId` (A43). The check names a record by
-    // `event_id` alone, so under an id the pack carries twice every record with
-    // that id is named: failing closed, rather than guessing which of the two the
-    // check meant.
+    // Declaration-check findings per pack position, then `eventId`. A duplicated
+    // id names every record with it: fail closed rather than guess.
     const declarationFindings = new Map();
-    // Keyed by the pack's POSITION and never by its `ref`. `ref` is the reader's
-    // own name for a pack, and nothing stops two packs in one archive carrying
-    // the same one: keyed by ref, the second pack's claims silently replaced the
-    // first's and records from one pack were graded against another pack's
-    // declaration. Found by a constructed archive rather than by reading, which
-    // is the only way this class of defect is ever found.
+    // Keyed by pack position, never `ref`: two packs can carry one ref, and a
+    // record must never be graded against another pack's declaration.
     const claimsByPack = new Map();
-    // Every key that SIGNED A PACK in this case: the wrapper key, which is the
-    // key that signs the pack's declaration. This is the ONE input that separates
-    // the two counterpart kinds (see `COUNTERPART_ABSENT_FROM_COUNTERPARTY_RECORDS`),
-    // and it replaces a set of every key that signed a RECORD anywhere in the
-    // case.
-    //
-    // The record-key set was wrong twice over, and both times in the direction
-    // that matters. It let the ACCUSER manufacture the damning line: one pack,
-    // plus one unrelated record the counterparty signed at some other time, read
-    // "the counterparty's OWN records ARE here" when the counterparty had handed
-    // over nothing (F4). And it let the COUNTERPARTY choose the innocent line: it
-    // was filled inside the record loop, which the `body_type` and no-records
-    // exits `continue` past, so a counterparty that wrapped its own pack in a body
-    // this reader does not read took its keys out of the set (F3), the third
-    // instance of a route already closed once for withheld `event_bytes`.
-    //
-    // A wrapper key closes both. The accuser cannot forge one without the
-    // counterparty's private key, and it is read HERE, first, before any exit
-    // below, from the pack envelope and never from the body, so no body type, no
-    // disclosure choice and no record content decides whether it is read.
+    // Every key that signed a pack wrapper (and so its declaration): the one
+    // input that separates the counterpart kinds. Wrapper keys, not record keys:
+    // an accuser cannot forge one, and it is read before any exit, from the
+    // envelope, so no body type or disclosure choice decides whether it counts.
     const holderKeys = new Set();
-    // One reading per pack, in the order the reader was given them (5.5.4 v1.20).
     const packReadings = [];
-    // The NOTEs (5.5.3 v1.20), with the pack position they are about.
     const caseNotes = [];
-    // The role each pack's readable v2 declaration signs for each record, keyed
-    // by the pack's POSITION for the reason `claimsByPack` is.
+    // Keyed by pack position, as `claimsByPack` is.
     const rolesByPack = new Map();
-    // The undeclared packs' slots, settled after the pile is read.
+    // Undeclared packs' held slots, settled after the pile is read.
     const undeclaredSlots = [];
-    // How many packs this reader could not tie to a key: an unreadable wrapper
-    // key, or a wrapper that does not hold. While it is not zero, "no pack in this
-    // case is signed by the named key" is not established, so the innocent
-    // one-sided kind is not available (COUNTERPART_ABSENT_SIGNER_UNKNOWN).
+    // Packs not tied to a key (unreadable key, or wrapper does not hold). While
+    // non-zero, the innocent `COUNTERPART_ABSENT` is not established.
     let unattributed = 0;
+    const runs = await verifyPacks(packs);
+    await readAgentRecordsAcross(packs, runs);
+    // The agent reading of each record that went into the pile, by pack and record position.
+    const agentReadings = new Map();
     for (let position = 0; position < packs.length; position += 1) {
         const pack = packs[position];
+        if (typeof pack.unreadable === "string") {
+            note(PACK_UNREADABLE, { packRef: pack.ref, packIndex: position, reasons: [pack.unreadable] });
+            unattributed += 1;
+            packReadings.push({
+                index: position,
+                ref: pack.ref,
+                signingKey: null,
+                grade: null,
+                recordsWithheld: 0,
+                declarationVersion: null,
+            });
+            continue;
+        }
         const holder = normalizedSigningKey(holderKeyOf(pack.bundle));
         if (holder === null) {
-            // Named, never skipped: a pack whose key this reader cannot read is a
-            // pack whose signer is UNKNOWN, and not a pack nobody signed. Checked
-            // BEFORE verification, because the two bundle verifiers disagree on some
-            // of these spellings (proof#135) and the reading must not.
+            // Signer unknown, not unsigned. Checked before verification so verifier
+            // differences over key spelling cannot change the reading.
             note(PACK_KEY_UNREADABLE, { packRef: pack.ref, packIndex: position });
             unattributed += 1;
+            // `signed` is not proven on that claim only: a pack that can be read is still graded,
+            // so a forged record inside it, or a `body_hash` that does not hold, fails it. Its
+            // records do not join the pile, since no key ties them to a party.
+            const [keyless, keylessSigned] = runs.get(position);
+            const keylessGrade = await gradeInCase(pack, keyless, keylessSigned, position);
+            const inside = keylessGrade.problems.filter((p) => p.kind !== PACK_KEY_UNREADABLE);
+            if (inside.length > 0 && keylessSigned.unreadable !== true) {
+                note(PACK_GRADE_NOT_VERIFIED, {
+                    packRef: pack.ref,
+                    packIndex: position,
+                    status: claimsVerdictOf(claimsOf(inside)).status,
+                    causes: keylessGrade.causes,
+                    reasons: bundleReasons(keylessSigned),
+                    problems: inside,
+                });
+            }
             unread(position, pack.ref, listedRecords(pack.bundle, pack.content), PACK_KEY_UNREADABLE);
             packReadings.push({
                 index: position,
@@ -1082,23 +746,9 @@ export async function readCase(packs) {
             });
             continue;
         }
-        // The precondition `HeldRecord` states, met HERE rather than trusted to a
-        // caller: every key this module compares is an envelope `public_key`, and
-        // "unforgeable" is a property of a VERIFIED envelope. Offline, no
-        // gateways: this reader makes no network call. This kernel's verifier
-        // reads envelopes under exactly CASE_RECORD_PROFILES (pinned by a test).
-        const verified = await verifyEvidenceBundle(pack.bundle, {
-            content: (pack.content ?? undefined),
-        });
+        const [verified, signed] = runs.get(position);
         witnessChecked.push(verified.onChainChecked);
-        // The same pack with the side map EMPTY (proof#159): what fails here is
-        // what a signature covers, and what fails only above rests on bytes nobody
-        // signed. Skipped where there is no map, because the two runs are then the
-        // same run.
-        const signed = sideMapHasKeys(pack.content)
-            ? await verifyEvidenceBundle(pack.bundle, {})
-            : verified;
-        // WHOSE PACK IS IT. The wrapper, and only the wrapper.
+        // Whose pack it is: the wrapper, and only the wrapper.
         if (!wrapperHolds(verified)) {
             note(PACK_DOES_NOT_VERIFY, { packRef: pack.ref, packIndex: position });
             unattributed += 1;
@@ -1115,74 +765,19 @@ export async function readCase(packs) {
         }
         holderKeys.add(holder);
         if (coSignaturesPresent(pack.bundle)) {
-            // A NOTE, with no contribution (5.5.3 v1.20, proof#148): the wrapper's
-            // co_signatures verifies nothing and sits outside its signed scope, so
-            // the case reading names it rather than moving anything on its account.
+            // A note, no contribution: `co_signatures` verifies nothing.
             caseNotes.push({
                 position,
                 note: { kind: CO_SIGNATURES_PRESENT, packRef: pack.ref, packIndex: position },
             });
         }
-        const bodyType = bodyTypeOf(pack.bundle);
-        const records = packRecords(pack.bundle, pack.content);
-        // The per-record gradings below are joined to `records` BY INDEX, so a
-        // verifier that graded a different number of records than the pack holds
-        // leaves this loop with no grading to read. That is not hypothetical: a
-        // pack whose `body_hash` does not cover its body reads `failed` with
-        // `events` EMPTY while `packRecords` reads every record in it, and only
-        // `wrapperHolds` above stands between that pack and this loop. A reader
-        // must never crash on a pack a party can build, so the gap is graded rather
-        // than indexed into, and the pack's records are dropped exactly as a
-        // `malformed` pack's are (gate 4 on proof#140, finding 3).
-        const ungraded = verified.events.length !== records.length || signed.events.length !== records.length;
-        const knownBody = CASE_BODY_TYPES.includes(bodyType);
-        // WHAT IS WRONG INSIDE IT, from here on. First the pack's own GRADE, which
-        // propagates: the case never reads above its weakest pack (5.5.1 step 1
-        // v1.20, A23; up to v1.19 it was the bundle status).
-        let check = null;
-        let full = null;
-        let causes = [];
-        let grade;
-        if (signed.status === "malformed") {
-            grade = "malformed";
-        }
-        else if (!knownBody) {
-            grade = signed.status;
-        }
-        else if (ungraded) {
-            grade = signed.status === "verified" ? "malformed" : signed.status;
-        }
-        else {
-            // Rule 11 reads the chain links of the same pack, and the reader reads
-            // only the signed body, so the bare check below takes the same reading
-            // (evidence-bundle.md 5.4.2 v1.36, A45).
-            const chainLinks = await readChainLinks(pack.bundle);
-            check = checkDeclaration(pack.bundle, pack.content, chainLinks);
-            const completeness = completenessNotes(pack.bundle);
-            full = gradePack(verified, accountDisclosure(pack.bundle, pack.content ?? {}), completeness, check);
-            const bareGrade = gradePack(signed, accountDisclosure(pack.bundle, {}), completeness, checkDeclaration(pack.bundle, null, chainLinks));
-            // NO `failed` HERE RESTS ON BYTES NOBODY SIGNED. The signed grade decides
-            // where it is `failed` or `malformed`; a failure only the side map
-            // produced is `incomplete`; otherwise the full grade.
-            if (bareGrade.verdict === "failed" || bareGrade.verdict === "malformed") {
-                grade = bareGrade.verdict;
-                causes = bareGrade.causes.map((c) => c.kind);
-            }
-            else if (full.verdict === "failed" || full.verdict === "malformed") {
-                grade = "incomplete";
-                causes = full.causes.map((c) => c.kind);
-            }
-            else {
-                grade = full.verdict;
-                causes = full.causes.map((c) => c.kind);
-            }
-        }
+        const graded = await gradeInCase(pack, verified, signed, position);
+        const { grade, check, full, causes, records, ungraded, knownBody } = graded;
+        const packProblems = graded.problems;
         if (grade !== "verified") {
             const reasons = bundleReasons(signed);
-            if (knownBody && ungraded && signed.status !== "malformed") {
-                // Said, because nothing else says it: the verifier's own reasons are
-                // about the bundle, and this pack's records are dropped for a reason
-                // of this reader's.
+            if (knownBody && ungraded && signed.unreadable !== true) {
+                // The verifier's reasons are about the bundle; this one is ours.
                 reasons.push(`this verifier graded ${verified.events.length} of the ${records.length} ` +
                     "record(s) the pack holds, so none of them is read");
             }
@@ -1192,6 +787,7 @@ export async function readCase(packs) {
                 status: grade,
                 causes,
                 reasons,
+                problems: packProblems,
             });
         }
         if (verified.status === "failed" && signed.status !== "failed") {
@@ -1211,9 +807,8 @@ export async function readCase(packs) {
             declarationVersion: knownBody ? declarationVersionOf(pack.bundle) : null,
         });
         if (recordsWithheld > 0) {
-            // A NOTE, with no contribution (5.5.3 v1.20): the holder signed that
-            // these records' content does not travel, and the scope sentence counts
-            // them, so a clean verdict never hides them.
+            // A note, no contribution: the holder signed that this content does not
+            // travel, and the scope sentence counts it.
             caseNotes.push({
                 position,
                 note: {
@@ -1224,28 +819,20 @@ export async function readCase(packs) {
                 },
             });
         }
-        // The body is one the verifier could not read, so it graded no record, and
-        // nothing below has a grading to read. Named above.
-        if (signed.status === "malformed") {
+        // The verifier graded no record; named above.
+        if (signed.unreadable === true) {
             unread(position, pack.ref, listedRecords(pack.bundle, pack.content), PACK_GRADE_NOT_VERIFIED);
             continue;
         }
         if (!knownBody) {
-            // `sanning.evidence.export/v2` lands here, and it is NOT unwrapped: its
-            // records sit under `body.source_bundle`, and reading them is a change to
-            // which packs this reader grades, so it is a decision of its own and not
-            // a repair (evidence-bundle.md 5.5.1 step 1 says so too). What this exit
-            // costs is that pack's RECORDS, and it is named every time. It no longer
-            // costs the pack's KEY: that was read above.
+            // Not unwrapped (evidence-bundle §5.5.1). Costs the pack's records, never
+            // its key, which was read above.
             note(PACK_BODY_TYPE_UNKNOWN, { packRef: pack.ref, packIndex: position });
-            // Listed, and not read: the records a `sanning.evidence.export/v2` wraps
-            // are listed from its inline source bundle, so a reading never says "0
-            // not read" of a pack that holds records (A43).
+            // Listed, not read, so a pack holding records never reads "0 not read".
             unread(position, pack.ref, listedRecords(pack.bundle, pack.content), PACK_BODY_TYPE_UNKNOWN);
             continue;
         }
-        // Graded above (`malformed` where the verifier called it `verified`), and
-        // none of its records are read.
+        // Graded above; none of its records are read.
         if (ungraded) {
             unread(position, pack.ref, records, PACK_GRADE_NOT_VERIFIED);
             continue;
@@ -1267,10 +854,8 @@ export async function readCase(packs) {
         }
         declarationFindings.set(position, namedByCheck);
         if (checked.contentFindings.length > 0) {
-            // BESIDE the deviation exception and never instead of it: a pack can do
-            // both, over different records, and the two say different things. This
-            // one is `incomplete` because whoever assembled the case chose the bytes
-            // it turns on (proof#147).
+            // Beside the deviation exception, never instead: they concern different
+            // records. `incomplete` because the case assembler chose the bytes.
             note(PACK_DECLARATION_CONTENT_DEPENDENT, {
                 packRef: pack.ref,
                 packIndex: position,
@@ -1278,38 +863,31 @@ export async function readCase(packs) {
             });
         }
         if (checked.verdict === "failed") {
-            note(PACK_DECLARATION_DEVIATES, {
-                packRef: pack.ref,
-                packIndex: position,
-                count: checked.deviations.length,
-            });
+            // A declaration that does not parse deviates from nothing: the pack grade names it as
+            // a declaration that breaks its own format.
+            if (checked.deviations.length === 0 ||
+                checked.deviations.some((d) => d.kind !== "declaration_malformed")) {
+                note(PACK_DECLARATION_DEVIATES, {
+                    packRef: pack.ref,
+                    packIndex: position,
+                    count: checked.deviations.length,
+                });
+            }
         }
         else if (checked.contentFindings.length > 0) {
-            // Already named above. `partial` here is not "the reader cannot read the
-            // claim": the claim was read, and part of it rests on bytes nobody
-            // signed.
+            // Named above: the claim was read, and part of it rests on unsigned bytes.
         }
         else if (checked.verdict === "verified") {
-            // A pack that agrees with its own claim contributes NOTHING, rather than
-            // a `verified` of its own. The case verdict is over the hand-off
-            // readings, and criterion 4's "mixed" is about mixed HAND-OFF outcomes: a
-            // pack-level clean contribution would put `verified` into the set on
-            // every case, so one broken pair beside two honest declarations would
-            // read `mixed` and the failure would be the quieter half of a two-word
-            // answer. A pack-level PROBLEM still contributes, through its exception.
+            // A clean pack contributes nothing, so the case verdict reflects hand-off
+            // outcomes: a `verified` per pack would turn one broken pair into `mixed`.
         }
         else if (checked.present) {
-            // `partial` with a declaration present is 5.4.3's "a claim this reader
-            // cannot read", which `gradePack` already carries to `incomplete`. The
-            // same posture here, for the same reason: the field has no accept-set and
-            // the holder writes it.
+            // A claim this reader cannot read (§5.4.3); the holder writes the field.
             note(PACK_DECLARATION_UNREADABLE, { packRef: pack.ref, packIndex: position });
         }
         else {
-            // WHAT IT CONTRIBUTES TURNS ON THE WHOLE READING (5.5.1 step 2 v1.20,
-            // A23, I4): `partial` where the reading holds a hand-off record, and a
-            // NOTE where it holds none. That is not known until the pile is read, so
-            // the slot is held HERE, in pack order, and settled below.
+            // `partial` if the reading holds a hand-off record, else a note (§5.5.1).
+            // Not known until the pile is read, so hold the slot.
             undeclaredSlots.push({
                 exceptionAt: exceptions.length,
                 contributionAt: contributions.length,
@@ -1319,25 +897,27 @@ export async function readCase(packs) {
             exceptions.push(null);
             contributions.push(null);
         }
-        // Each record on its OWN envelope. `packRecords` and the verifier both walk
-        // `body.events` in order and emit one entry per element, so the index is
-        // the join, exactly as `held`, `provenance` and `readings` below.
+        // Each record on its own envelope, joined by index.
         for (let index = 0; index < records.length; index += 1) {
             const record = records[index];
             const graded = verified.events[index];
             const bare = signed.events[index];
-            // Which pack and which record, by position: the two names that are
-            // unique in the reading whatever the reader called the pack and whatever
-            // the holder wrote as `event_id` (A43).
+            // Pack and record by position: unique whatever `ref` or `event_id` say.
             const at = {
                 packRef: pack.ref,
                 packIndex: position,
                 eventId: record.eventId,
                 recordIndex: index,
             };
-            // Not read: listed with the kind of the exception that says why.
+            // Not read: listed with the kind of the exception that says why. Signed bytes that
+            // bind and are not JSON, and an envelope that cannot be read, names a version this
+            // verifier does not know or breaks its format under a signature that holds, are their
+            // pack's own problems, so no exception is noted here.
             const skip = (kind, fields = {}) => {
-                note(kind, { ...at, ...fields });
+                if (!(kind === RECORD_BYTES_UNREADABLE && bare.recordNotJson === true) &&
+                    !(kind === RECORD_ENVELOPE_DOES_NOT_VERIFY && ENVELOPE_FAULTS_OF_THE_PACK.includes(graded.envelopeFault ?? ""))) {
+                    note(kind, { ...at, ...fields });
+                }
                 slots.push({ position, packRef: pack.ref, recordIndex: index, eventId: record.eventId, heldAt: null, reason: kind });
             };
             if (underQuarantine(recordSpecVersion(pack.bundle, index))) {
@@ -1356,9 +936,8 @@ export async function readCase(packs) {
                 skip(RECORD_BYTES_UNREADABLE);
                 continue;
             }
-            // Named, and the record stays in the pile (see the kinds). A mismatch
-            // the signed body carries on its own is `failed`; one that appears only
-            // with the side map is `incomplete` (proof#159).
+            // Named, and the record stays in the pile. A mismatch in the signed body
+            // is `failed`; one only with the side map is `incomplete`.
             if (bare.contentOk === false) {
                 note(RECORD_CONTENT_MISMATCH, {
                     ...at,
@@ -1371,10 +950,12 @@ export async function readCase(packs) {
                     reasons: onlyIn(graded.errors, bare.errors),
                 });
             }
-            // Every other check on the SIGNED reading, so side content can neither
-            // add a failure here nor take one away.
-            if (!(bare.inclusionOk && bare.checkpointBound) ||
-                (!bare.ok && bare.contentOk !== false)) {
+            // Every other check on the signed reading, so side content can neither
+            // add a failure here nor remove one. A stamp the pack does not hold, and signed
+            // bytes that are not JSON, are their pack's own problems (not proven, and a
+            // producer's error), never a record that does not match its pack.
+            if (!(bare.stampAbsent === true || bare.recordNotJson === true) &&
+                (!(bare.inclusionOk && bare.checkpointBound) || (!bare.ok && bare.contentOk !== false))) {
                 note(RECORD_DOES_NOT_VERIFY_IN_ITS_PACK, {
                     ...at,
                     reasons: [...bare.errors],
@@ -1388,41 +969,30 @@ export async function readCase(packs) {
                 heldAt: held.length,
                 reason: null,
             });
+            const agent = graded.agent;
+            agentReadings.set(`${position}:${index}`, agent);
             held.push({
                 publicKey: record.publicKey,
                 record: record.record,
                 ref: `${pack.ref}/${record.eventId}`,
+                agentNonconforming: agent !== null && agent.verdict === "failed",
             });
             provenance.push({ position, packRef: pack.ref, eventId: record.eventId, recordIndex: index });
         }
     }
-    // Step 3. ONE pile, no partition. This is the line anchor#198 turns on and
-    // the line DL-60 constrains: there is nothing here that reads a tenant, an
-    // issuer or an organization, so a pair across two organizations' packs is
-    // read exactly as a pair inside one.
+    // Step 3: one pile, no partition by tenant, issuer or organization.
     const readings = readHandoffs(held);
     // Step 4.
     let handoffRecords = 0;
     for (let index = 0; index < readings.length; index += 1) {
         const reading = readings[index];
         const { position, packRef, eventId, recordIndex } = provenance[index];
-        // The record this reading is about, by position (A43).
         const at = { packRef, packIndex: position, eventId, recordIndex };
-        // proof#137's door, named. Read from the ONE reader of the declaration
-        // (`declarationClaims`), never from a second parse here. Only a READABLE
-        // declaration can make a record unclaimed: where the claim itself is absent
-        // or unreadable, that pack already carries its own exception and naming
-        // every record in it again would report one defect many times.
-        //
-        // ABOVE the two `continue`s below, deliberately. This check asks what the
-        // PACK said about the record, which is independent of whether 4.1 governs
-        // the record and of whether the record is well formed. Behind the
-        // `not_a_handoff_record` exit it was a check the audited party switched off
-        // by respelling two fields, and behind the `malformed` exit it was one a
-        // party switched off by breaking its own record.
-        //
-        // v1's ALONE (5.5.1 v1.20, A21). A v2 pack's claim check is rule 9, which
-        // the declaration check already ran on the signed body.
+        // Read from `declarationClaims`, never a second parse. Only a readable
+        // declaration makes a record unclaimed; otherwise the pack's own exception
+        // covers it. Runs above both `continue`s below, so neither respelling a
+        // record out of §4.1 nor breaking it switches the check off. v1 only: a v2
+        // pack's claim check already ran inside the declaration check.
         const claims = claimsByPack.get(position);
         if (claims !== undefined &&
             claims.readable &&
@@ -1431,50 +1001,41 @@ export async function readCase(packs) {
             note(RECORD_UNCLAIMED, at);
         }
         if (reading.findings.includes(NOT_A_HANDOFF_FINDING)) {
-            // 4.1 (v1.9, A14): information, not absence. A record 4.1 does not govern
-            // is not a hand-off exception, and it is still in `records` and still
-            // subject to the claim check above.
+            // Not a hand-off exception; still listed and still claim-checked above.
             continue;
         }
         handoffRecords += 1;
-        if (reading.verdict === "malformed") {
-            // Whose defect is it? `recordIsMalformed` is 4.1's own predicate, CALLED
-            // and not restated, and it answers about THIS record. A `malformed`
-            // aggregate over a record that is itself well formed is a malformed
-            // CANDIDATE, so it is a different kind, it does not `continue`, and the
-            // counterpart, ambiguity and `failedChecks` reporting below all keep
-            // running over it.
+        if (reading.findings.includes("malformed_record")) {
+            // `recordIsMalformed` answers about this record. A malformed aggregate
+            // over a well-formed record is a malformed candidate, and reporting
+            // continues for it.
             if (recordIsMalformed(held[index])) {
                 note(RECORD_MALFORMED, at);
                 continue;
             }
             note(COUNTERPART_MALFORMED, at);
         }
+        else if (reading.findings.includes("nonconforming_record")) {
+            // The same question for the other defect: this record's own, or a candidate's.
+            if (recordIsNonconforming(held[index])) {
+                note(RECORD_NONCONFORMING, at);
+                continue;
+            }
+            note(COUNTERPART_NONCONFORMING, at);
+        }
         if (reading.findings.includes(COUNTERPART_ABSENT)) {
-            // `held`, `provenance` and `readings` are three views of one list in one
-            // order, built together and never filtered, so the index is the join.
-            // Deliberately not a lookup by reference string: a reference is for a
-            // person to read, and a join rebuilt by splitting one is a join on a
-            // value a holder can put a separator inside.
+            // `held`, `provenance` and `readings` share one order, never filtered, so
+            // the index is the join.
             const subject = held[index];
             const event = subject.record["event"];
             const named = normalizedSigningKey(typeof event === "object" && event !== null
                 ? event["counterparty_public_key"]
                 : undefined);
-            // A VERIFIED pack SIGNED by the named key is in the case, and nothing
-            // else. Records signed by that key which some other party holds are not
-            // that party's pack. Where some pack could not be tied to a key, "no
-            // pack is signed by the named key" is not established and the reading
-            // says it could not tell.
-            //
-            // EXCEPT where 4.1 set every candidate aside (v1.17, A20). There the
-            // absence is a finding about the candidates the reader DID read, each
-            // paired `verified` with another record the subject's own signer made,
-            // and not a finding about any pack. 4.1 and evidence-bundle A16 name the
-            // neutral kind for it, and the damning one would put the audited party's
-            // own unfaithful record on the counterparty's pack as a statement
-            // against it. `count` is how many candidates were set aside, which is
-            // also what tells the rendered sentence which absence this is.
+            // The damning kind needs a verified pack signed by the named key; with
+            // any unattributed pack, the reading says it could not tell. Where every
+            // candidate was set aside (each paired with another record by the
+            // subject's own signer), the absence is about those candidates, not any
+            // pack, so the neutral kind carries `count`.
             const graded = reading.candidateReadings;
             const setAside = graded.length > 0 && graded.every((c) => c.accountedFor !== null)
                 ? graded.length
@@ -1497,13 +1058,9 @@ export async function readCase(packs) {
                 count: reading.candidateReadings.filter((c) => c.accountedFor === null).length,
             });
         }
-        // ON `failedChecks` AND NOT ON THE VERDICT WORD. 4.1 keeps the UNION of
-        // every candidate's failed checks precisely so a junk record cannot strip a
-        // named failure out of the report (proof#133 ruling 6), and reading the
-        // verdict instead threw that union away: `malformed` outranks `failed`, so
-        // one junk candidate took the branch below and a proven `message_hash`
-        // failure disappeared from the case. A named failed check is a named failed
-        // check whatever the aggregate word is.
+        // On `failedChecks`, not the verdict word: `malformed` outranks `failed`,
+        // and §4.1 keeps the union of failed checks so a junk candidate cannot hide
+        // a proven failure.
         if (reading.failedChecks.length > 0) {
             note(PAIR_FAILED, {
                 ...at,
@@ -1514,11 +1071,8 @@ export async function readCase(packs) {
             contributions.push([`${packRef}/${eventId}`, "verified"]);
         }
     }
-    // A reading with no hand-off record in it is not an exception (5.5.3 v1.20,
-    // A23, D6). The undeclared packs, settled: the exception `pack_undeclared`,
-    // contributing `partial`, in the slot it was given in pack order where the
-    // reading holds a hand-off record; a NOTE with no contribution where it holds
-    // none.
+    // Undeclared packs: the `pack_undeclared` exception, contributing `incomplete`,
+    // where the reading holds a hand-off record; otherwise a note (§5.5.3).
     for (const slot of undeclaredSlots) {
         if (handoffRecords > 0) {
             exceptions[slot.exceptionAt] = {
@@ -1537,17 +1091,13 @@ export async function readCase(packs) {
     }
     const named = exceptions.filter((e) => e !== null);
     const contributed = contributions.filter((c) => c !== null);
-    // Pack order, stable. A pack carries at most one note: one with no
-    // declaration withholds nothing by one.
+    // Pack order, stable.
     const notes = caseNotes
         .map((n, i) => ({ ...n, i }))
         .sort((a, b) => a.position - b.position || a.i - b.i)
         .map((n) => n.note);
-    // Every record of every pack, with its status (A43). A record that went
-    // into the pile is `read_flagged` where any exception names it by pack and
-    // record position, or its pack's declaration check names it (by deviation
-    // or by content finding), and `read_clean` where neither does; every other
-    // record is `not_read`, with the kind of the exception that says why.
+    // Read records are `read_flagged` when an exception or declaration finding
+    // names them, else `read_clean`; the rest are `not_read`.
     const flagged = new Set(named
         .filter((e) => e.packIndex !== undefined && e.recordIndex !== undefined)
         .map((e) => `${e.packIndex}:${e.recordIndex}`));
@@ -1570,6 +1120,7 @@ export async function readCase(packs) {
                 failedChecks: [],
                 counterparts: [],
                 role: null,
+                agent: null,
             };
         }
         const reading = readings[slot.heldAt];
@@ -1585,9 +1136,10 @@ export async function readCase(packs) {
             failedChecks: [...reading.failedChecks],
             counterparts: [...reading.candidates],
             role: rolesByPack.get(slot.position)?.get(slot.eventId) ?? null,
+            agent: agentReadings.get(`${slot.position}:${slot.recordIndex}`) ?? null,
         };
     });
-    return {
+    return withProblems({
         verdict: verdictOf(named, contributed),
         exceptions: named,
         records,
@@ -1596,14 +1148,11 @@ export async function readCase(packs) {
         onChainChecked: witnessChecked.length > 0 && witnessChecked.every((c) => c),
         notes,
         packs: packReadings,
-    };
+    });
 }
 /**
- * The records a pack LISTS where this reader does not read them one by one
- * (A43): the events `resolveTraceEvents` presents, which unwraps a
- * `sanning.evidence.export/v2` to its inline source bundle, and otherwise
- * `body.events` as `packRecords` reads it. Listing is not reading: every record
- * listed here is `not_read`.
+ * The records a pack lists when this reader does not read them one by one,
+ * unwrapping an export to its source bundle. Every one is `not_read`.
  */
 function listedRecords(bundle, content) {
     const events = resolveTraceEvents(bundle);
@@ -1611,10 +1160,7 @@ function listedRecords(bundle, content) {
         return packRecords(bundle, content);
     return packRecords({ body: { events } }, content);
 }
-/**
- * `body.declaration.declaration_version` where it is one this reader knows,
- * and `null` otherwise.
- */
+/** The pack's known `declaration_version`, or `null`. */
 function declarationVersionOf(bundle) {
     const at = (v, k) => typeof v === "object" && v !== null && !Array.isArray(v)
         ? v[k]
@@ -1628,15 +1174,11 @@ function declarationVersionOf(bundle) {
         ? version
         : null;
 }
-// ---- Presentation (optional) ------------------------------------------------
+const because = (reasons) => reasons !== undefined && reasons.length > 0 ? `: ${reasons.join("; ")}` : "";
 /**
- * The house wording for one exception.
- *
- * Offered, not imposed, exactly as `renderDeviation` is: what must not vary
- * between surfaces is the verdict and the set of exceptions, and those come
- * from `readCase`. Both kernels return this same text for the same exception.
+ * The house wording for one exception. Optional: the verdict and the set of
+ * exceptions are what must not vary between surfaces.
  */
-const because = (reasons) => reasons !== undefined && reasons.length > 0 ? `: ${reasons.join("; ")}` : "";
 export function renderException(exception) {
     const where = `${exception.packRef}/${exception.eventId}`;
     switch (exception.kind) {
@@ -1653,78 +1195,82 @@ export function renderException(exception) {
                 "and no pack in this case is signed by the key it names");
         case COUNTERPART_ABSENT_FROM_COUNTERPARTY_RECORDS:
             return (`${where} has no counterpart among the records this verifier read, ` +
-                "and a pack signed by the key it names IS in this case and holds " +
+                "and a pack signed by the key it names is in this case and holds " +
                 "no counterpart this verifier could read");
         case COUNTERPART_ABSENT_SIGNER_UNKNOWN:
             return (`${where} has no counterpart among the records this verifier read, ` +
                 "and a pack in this case could not be tied to a signing key, so " +
                 "whether a pack signed by the key it names is in this case is " +
-                "UNKNOWN");
+                "unknown");
         case COUNTERPART_AMBIGUOUS:
             return (`${where} has ${exception.count} candidate counterparts, so the ` +
                 "reading is the worst of them and no one match was chosen");
         case PAIR_FAILED:
-            return `${where} FAILED on ${(exception.failedChecks ?? []).join(", ")}`;
+            return `${where} failed on ${(exception.failedChecks ?? []).join(", ")}`;
         case RECORD_MALFORMED:
             return `${where} is not a well formed hand-off record`;
         case COUNTERPART_MALFORMED:
             return (`${where} is well formed and a candidate counterpart of it is not, ` +
-                "so what this record pairs with is UNKNOWN");
+                "so what this record pairs with is unknown");
+        case RECORD_NONCONFORMING:
+            return (`${where} is signed and intact and does not follow its vocabulary, ` +
+                "so nothing is proven altered and it cannot be paired");
+        case COUNTERPART_NONCONFORMING:
+            return (`${where} conforms and a candidate counterpart of it does not, ` +
+                "so what this record pairs with is unknown");
         case RECORD_UNCLAIMED:
             return (`${where} is a record its own pack declares and claims in no ` +
                 "hand-off pair, so whether the holder meant to hand it over is " +
-                "UNKNOWN");
+                "unknown");
         case RECORD_BYTES_WITHHELD:
-            return `${where} travels with no record bytes, so what that record IS is UNKNOWN`;
+            return `${where} travels with no record bytes, so what that record is, is unknown`;
         case RECORD_BYTES_UNREADABLE:
             return `${where} travels with record bytes this verifier cannot read`;
         case PACK_DECLARATION_DEVIATES:
-            // "read together with" and not "deviates", flat: 5.4 grades the pack
-            // against the content the reader was handed, and content beside a pack is
-            // unsigned. Whoever assembles a case can swap it, so the sentence names
-            // what was compared rather than only the pack.
+            // Names what was compared: the side content is unsigned and swappable.
             return (`${exception.packRef}, read together with any content handed in ` +
-                `beside it, DEVIATES from its own declaration, in ` +
+                `beside it, deviates from its own declaration, in ` +
                 `${exception.count} way(s)`);
         case PACK_DECLARATION_CONTENT_DEPENDENT:
-            // Says what this verifier could not establish, and names the content
-            // rather than the pack's holder: the bytes are unsigned and whoever
-            // assembled the case chose them.
+            // Names what could not be established and the content, never the holder:
+            // the bytes are unsigned and the case assembler chose them.
             return (`${exception.packRef} agrees with its own declaration everywhere its ` +
                 `signature reaches, and in ${exception.count} way(s) it does not line ` +
                 "up with the unsigned content handed in beside it, which anyone could " +
-                "have supplied, so whether it holds what it declares is UNKNOWN");
+                "have supplied, so whether it holds what it declares is unknown");
         case PACK_DECLARATION_UNREADABLE:
             return (`${exception.packRef} says what it holds in a declaration this ` +
-                "verifier cannot read, so whether it is complete is UNKNOWN");
+                "verifier cannot read, so whether it is complete is unknown");
         case PACK_UNDECLARED:
             return (`${exception.packRef} does not say what it holds, so whether it is ` +
-                "complete is UNKNOWN");
+                "complete is unknown");
         case PACK_BODY_TYPE_UNKNOWN:
             return (`${exception.packRef} is a pack body this verifier does not read, so ` +
-                "what it holds is UNKNOWN");
+                "what it holds is unknown");
         case PACK_HOLDS_NO_RECORDS:
             return `${exception.packRef} holds no records this verifier can read`;
+        case PACK_UNREADABLE:
+            return (`${exception.packRef} cannot be read: its bundle.json ` +
+                `${(exception.reasons ?? []).join("; ")}, so who signed it is unknown and none of its ` +
+                "records are read");
         case PACK_KEY_UNREADABLE:
             return (`${exception.packRef} names a signing key this verifier cannot ` +
-                "read, so who signed it is UNKNOWN and none of its records are read");
+                "read, so who signed it is unknown and none of its records are read");
         case PACK_DOES_NOT_VERIFY:
             return (`${exception.packRef} carries a wrapper signature over its body that ` +
                 "does not verify, so none of its records are read and the key it " +
                 "names is not counted as its signer");
         case PACK_GRADE_NOT_VERIFIED: {
-            let head = `${exception.packRef} grades ${(exception.status ?? "").toUpperCase()} as a pack`;
+            let head = `${exception.packRef} grades ${exception.status} as a pack`;
             if (exception.causes !== undefined && exception.causes.length > 0) {
                 head += ` (${exception.causes.join(", ")})`;
             }
-            if (exception.status === "malformed")
-                head += ", so none of its records are read";
             return head + because(exception.reasons);
         }
         case PACK_BUNDLE_CONTENT_DEPENDENT:
-            return (`${exception.packRef} reads FAILED as a bundle only together with ` +
+            return (`${exception.packRef} reads failed as a bundle only together with ` +
                 "the unsigned content handed in beside it, which anyone could have " +
-                "supplied, so whether that failure is the pack's is UNKNOWN" +
+                "supplied, so whether that failure is the pack's is unknown" +
                 because(exception.reasons));
         case RECORD_ENVELOPE_DOES_NOT_VERIFY:
             return (`${where} is in a pack whose wrapper verifies, and its own envelope ` +
@@ -1741,23 +1287,24 @@ export function renderException(exception) {
         case RECORD_CONTENT_DEPENDENT:
             return (`${where} commits to content that the unsigned content handed in ` +
                 "beside its pack does not match, and anyone could have supplied " +
-                "that content, so what it says about the record is UNKNOWN; the " +
+                "that content, so what it says about the record is unknown; the " +
                 "record is still read as a hand-off record" +
                 because(exception.reasons));
         case RECORD_PROFILE_QUARANTINED:
             return (`${where} is signed under a profile this case reader does not read ` +
-                "while its admission is undecided, so what it says is UNKNOWN");
+                "while its admission is undecided, so what it says is unknown");
         case CASE_HOLDS_NO_PACKS:
             return "this case holds no packs";
         default:
             return exception.kind;
     }
 }
-/** The house wording for one NOTE. Offered, not imposed, as `renderException` is. */
+/** The house wording for one note. */
 export function renderCaseNote(note) {
     switch (note.kind) {
         case CONTENT_WITHHELD_BY_DECLARATION:
-            return (`${note.packRef} withholds the content of ${note.count} record(s) by ` +
+            return (`${note.packRef} withholds the content of ${note.count} ` +
+                `${note.count === 1 ? "record" : "records"} by ` +
                 "its own signed declaration: their signatures and commitments were " +
                 "checked, their content was not");
         case PACK_UNDECLARED:
@@ -1770,18 +1317,11 @@ export function renderCaseNote(note) {
     }
 }
 /**
- * The scope sentence, printed directly under the headline (evidence-bundle
- * 5.5.6 v1.20, A26), byte for byte the text `render_case_summary` returns.
- *
- * The packs in the reading; the distinct keys, compared as keys, that signed
- * the wrapper of a pack whose wrapper held; the hand-off records; the
- * exceptions; and that the reading was made offline. Where any pack holds
- * records withheld by its declaration, their total; where any pack is noted
- * `pack_undeclared`, how many. Those two lines are part of what the headline
- * MEANS, and a surface MUST print them with it.
- *
- * What was not checked on the public record is no longer a clause here. It is
- * the witness line (`renderWitnessLine`), printed with every headline.
+ * The scope sentence printed under the headline (evidence-bundle §5.5.6): packs,
+ * distinct signing keys of packs whose wrapper held, hand-off records,
+ * exceptions, and that it was read offline, plus withheld and undeclared
+ * counts where non-zero. Those counts are part of what the headline means, and
+ * a surface must print them with it.
  */
 export function renderCaseSummary(reading) {
     const keys = new Set(reading.packs.filter((p) => p.grade !== null).map((p) => p.signingKey));
@@ -1800,66 +1340,43 @@ export function renderCaseSummary(reading) {
         lines.push(`${undeclared} pack(s) do not say what they hold.`);
     return lines.join(" ");
 }
-// ---- The headline and the witness line (evidence-bundle 5.5.6 v1.20) -------
 /**
- * The one display title of each of the eight 3 words. A surface prints the
- * title, never the word, and never a title of its own (#173, A18). The wording
- * is Will's to change through the glossary (DL-71); what each MEANS is pinned
- * in the spec.
+ * The one display title of each of the three section 3 verdicts. A surface prints the
+ * title, never the word, and never a title of its own.
  */
-export const VERDICT_DISPLAY_TITLES = {
-    verified: "Verified",
-    partial: "Partial",
-    pending: "Pending",
-    incomplete: "Incomplete",
-    failed: "Failed",
-    malformed: "Not readable",
-    not_found: "Not found",
-    mixed: "Mixed",
-};
+export const VERDICT_DISPLAY_TITLES = { ...VERDICT_TITLES };
 /**
- * What a reader may rely on, for each of the six words a case reading reaches
- * (5.5.6 v1.20, A26; the `verified` text at v1.28, A35), the same for every
- * drop. `pending` and `not_found` never head a case reading: they are
- * witness states. `verified` is the base sentence, printed alone where the
- * drop holds no hand-off record; a caller reads `caseReliance` for
- * `verified`, never this mapping directly.
+ * What a reader may rely on, for each verdict a case reading reaches (section 5.5.6), the
+ * same for every drop, keyed by the verdict and, for `failed`, its reason kind. Call
+ * `caseReliance` rather than reading `verified` here directly.
  */
 export const CASE_RELIANCE = {
     verified: "Every pack in this drop is genuine, unaltered, and matches its own " +
         "signed declaration. Every record in it was signed by its holder's " +
         "key. This was read offline, on this device. It does not say this " +
         "drop holds everything that was recorded.",
-    partial: "Nothing here was proven wrong, and a check could not be completed: a " +
-        "pack names no witness, or a pack in a hand-off reading does not say " +
-        "what it holds. The exceptions say which.",
     incomplete: "Nothing here was proven wrong, and part of it could not be checked: " +
         "the other side of a hand-off is not in this drop, bytes were not " +
-        "handed over, or a claim could not be read. Each exception says what " +
-        "is missing and, where a key is known, whose pack would supply it.",
+        "handed over or could not be read, a pack names no witness, or a " +
+        "claim could not be read. Do not rely on the parts that are not " +
+        "proven. Each exception says what is missing and, where a key is " +
+        "known, whose pack would supply it.",
     failed: "A check ran and did not pass. Do not rely on this drop until the " +
         "named failure is explained. The failure is named on the pack or " +
         "record it is about, and every other exception is listed beside it.",
-    malformed: "Part of this drop could not be read as evidence, and nothing was " +
-        "proven wrong. The exceptions name what could not be read.",
-    mixed: "The readings here differ and none of them failed: some are verified " +
-        "and some could not be checked. Read each pack's row and each " +
-        "exception before relying on any of it.",
+    failed_nonconforming: "A record in this drop is signed and unaltered and does not follow " +
+        "the vocabulary it names: its producer wrote something the " +
+        "specification does not allow. Nothing was proven altered. The " +
+        "exceptions name the record and the rule it breaks.",
 };
 /**
- * The clause a `verified` drop that holds a hand-off record gains, inserted
- * after `CASE_RELIANCE`'s first sentence (5.5.6, A35). Never printed alone,
- * and never where `handoffRecords` is zero: most drops hold one agent's
- * pack and no hand-off to say anything about.
+ * Added to a `verified` reliance line after its first sentence, only where the
+ * drop holds a hand-off record.
  */
 export const CASE_RELIANCE_HANDOFF_CLAUSE = "Every hand-off with both sides in this drop is intact.";
 /**
- * The sentence a case reading's reliance line gains where its packs hold an
- * envelope signed `environment: "dev"` (5.5.6, A48), keyed by the environment
- * marker (`environmentMarker`): `dev` where every envelope is signed dev,
- * `mixed` where only some are. Inserted after the line's first sentence, for
- * every verdict word. A drop with no `dev` envelope has no marker and gains
- * nothing.
+ * Added after the reliance line's first sentence, for every verdict, where the
+ * drop holds `environment: "dev"` envelopes: `dev` if all are, `mixed` if some.
  */
 export const CASE_RELIANCE_SANDBOX = {
     dev: "The records in this drop are sandbox records, signed environment " +
@@ -1868,21 +1385,12 @@ export const CASE_RELIANCE_SANDBOX = {
         "dev: those are not production evidence.",
 };
 /**
- * What a reader may rely on for one case reading (5.5.6 v1.38, A35 and A48),
- * byte for byte the text `case_reliance`'s Python sibling returns.
- *
- * For every word but `verified` the base is `CASE_RELIANCE` unchanged. For
- * `verified`, the hand-off clause is inserted after the first sentence
- * where `handoffRecords` is not zero, and left out where it is zero: the
- * base sentence never claims a hand-off the drop does not hold.
- *
- * Where `environmentMarker` is `dev` or `mixed`, the `CASE_RELIANCE_SANDBOX`
- * sentence for it is inserted after the first sentence, for every word, so
- * it directly follows the claim it qualifies (and precedes the hand-off
- * clause). Where it is null or absent, the text is exactly what it was
- * before A48.
+ * What a reader may rely on for one case reading (§5.5.6). The sandbox
+ * sentence, if any, follows the first sentence and precedes the hand-off
+ * clause, which a `verified` reading gains only with `handoffRecords > 0`, so
+ * the line never claims a hand-off the drop does not hold.
  */
-export function caseReliance(verdict, handoffRecords, environmentMarker = null) {
+export function caseReliance(verdict, handoffRecords, environmentMarker = null, reasonKind = null) {
     let first;
     let rest;
     if (verdict === "verified" && handoffRecords > 0) {
@@ -1893,13 +1401,13 @@ export function caseReliance(verdict, handoffRecords, environmentMarker = null)
                 "device. It does not say this drop holds everything that was recorded.";
     }
     else {
-        const base = CASE_RELIANCE[verdict];
+        const key = verdict === "failed" && reasonKind === "nonconforming" ? "failed_nonconforming" : verdict;
+        const base = CASE_RELIANCE[key];
         const cut = base.indexOf(". ");
         first = base.slice(0, cut + 1);
         rest = base.slice(cut + 2);
     }
-    // Only `dev` and `mixed` add the sentence. Any other value, which the type
-    // forbids but an untyped caller can pass, reads as no marker.
+    // An untyped caller can pass any value; only `dev` and `mixed` add a sentence.
     const sandbox = environmentMarker === "dev" || environmentMarker === "mixed"
         ? CASE_RELIANCE_SANDBOX[environmentMarker]
         : null;
@@ -1907,22 +1415,21 @@ export function caseReliance(verdict, handoffRecords, environmentMarker = null)
         return `${first} ${rest}`;
     return `${first} ${sandbox} ${rest}`;
 }
-/** The three witness states, and how each is printed (5.5.6, D7). No other. */
+/** The three witness states and how each is printed (§5.5.6). No others. */
 export const WITNESS_STATES = {
     confirmed: "Confirmed on the public record",
     not_checked: "Not checked",
     differs: "The public record holds different bytes",
 };
-/** The line printed where no lookup ran, which is every reading this kernel produces on its own. */
+/** The line where no lookup ran: every reading this module produces on its own. */
 export const WITNESS_NOT_LOOKED_UP = Object.freeze({
     state: "not_checked",
     reasons: ["no lookup was run"],
     services: [],
 });
-/** The witness line as both kernels print it. */
-/** How a witness time a pack caches is printed where nothing checked it (5.5.6, 5.6.6, v1.25, A30). */
+/** A cached witness time no lookup checked (§5.6.6). */
 export const WITNESS_TIME_CACHED = "the pack dates the witness, not checked";
-/** How a witness time the public record returned is printed where it matched the cache. */
+/** A witness time the public record returned that matched the cache. */
 export const WITNESS_TIME_RECORDED = "the public record dates the witness";
 function witnessTimes(times) {
     return times.map(([h, t]) => renderWitnessTime(h, t)).join(", ");