@colophon-claims/verify 0.2.0 → 0.2.1

package/dist/profile/claim.js

@@ -27,13 +27,19 @@
  * disclosure. The one deliberate exception to "never cross-check here": `buildClaimPackage`
  * THROWS when the stated primitives disagree with what the sealed Run record's own policy
  * carries — a claim stating primitives the sealed Run does not carry would be dishonest.
+ *
+ * Issue #3205: the claim id is chosen on TWO independent axes — anchored or not, and
+ * qualification-projecting or not — which is four allocations, not three. `claim-package/5` is
+ * the fourth cell; before it existed an anchored binary-instrument run could not produce a
+ * claim at all, which made anchoring and binary-instrument benchmarking mutually exclusive.
  */
 import { z } from "zod";
 import { Buffer } from "node:buffer";
 import { validateBinaryInstrumentQualificationProjection } from "@jinn-network/benchmarking-aggregate";
 import { BENCHMARKING_METHOD_IDS, BENCHMARKING_METHOD_VERSION } from "@jinn-network/benchmarking-records";
 import { canonicalJsonBytes } from "@jinn-network/trust-core";
-import { PUBLIC_BUNDLE_COMPATIBLE_VERIFICATION_COMMAND, PUBLIC_BUNDLE_VERIFICATION_CHECKS as READER_VERIFICATION_CHECKS, PUBLIC_BUNDLE_VERIFICATION_COMMAND as READER_VERIFICATION_COMMAND, PUBLIC_BUNDLE_V6_CHECKS as READER_ANCHORED_VERIFICATION_CHECKS, PUBLIC_BUNDLE_V6_COMPATIBLE_VERIFICATION_COMMAND, PUBLIC_BUNDLE_V6_VERIFICATION_COMMAND, } from "../reader-instructions.js";
+import { PUBLIC_BUNDLE_COMPATIBLE_VERIFICATION_COMMAND, PUBLIC_BUNDLE_VERIFICATION_CHECKS as READER_VERIFICATION_CHECKS, PUBLIC_BUNDLE_VERIFICATION_COMMAND as READER_VERIFICATION_COMMAND, PUBLIC_BUNDLE_V6_CHECKS as READER_ANCHORED_VERIFICATION_CHECKS, PUBLIC_BUNDLE_V6_COMPATIBLE_VERIFICATION_COMMAND, PUBLIC_BUNDLE_V6_VERIFICATION_COMMAND, PUBLIC_BUNDLE_V7_CHECKS as READER_ANCHORED_QUALIFICATION_VERIFICATION_CHECKS, PUBLIC_BUNDLE_V7_COMPATIBLE_VERIFICATION_COMMAND, PUBLIC_BUNDLE_V7_VERIFICATION_COMMAND, PUBLIC_BUNDLE_V8_CHECKS as READER_DISCLOSED_VERIFICATION_CHECKS, } from "../reader-instructions.js";
+import { ClaimDisclosureSectionSchema } from "./disclosure.js";
 import { PROMPTED_SCREENING_PROFILE } from "../admission/contracts.js";
 import { ClaimAnchorSchema, SELF_RUN_TRUST_ROOT, anchoredTrustRoot } from "./anchor-claims.js";
 export const CLAIM_PACKAGE_SCHEMA_ID = "benchmark-product.claim-package/1";
@@ -45,10 +51,34 @@ export const BINARY_QUALIFICATION_CLAIM_PACKAGE_SCHEMA_ID = "benchmark-product.c
  * own later allocation.
  */
 export const ANCHORED_CLAIM_PACKAGE_SCHEMA_ID = "benchmark-product.claim-package/4";
+/**
+ * The anchored binary-qualification claim package (issue #3205): claim-package/2's exact
+ * qualification projection plus claim-package/4's `anchors` section, carried by
+ * `benchmark-product-public-bundle/7`. This is the "later allocation" both earlier guards named:
+ * /2 has no anchors slot and /4 has no qualification slot, so before this number existed an
+ * anchored run of a binary-instrument benchmark could not produce a claim at all. The allocation is
+ * an ADDITION — /1, /2, /3, and /4 keep their meanings and their bytes.
+ */
+export const ANCHORED_BINARY_QUALIFICATION_CLAIM_PACKAGE_SCHEMA_ID = "benchmark-product.claim-package/5";
+/**
+ * The disclosed anchored binary-qualification claim package (issue #2839,
+ * disclosure-specification-record design §6.5/§6.6): claim-package/5 exactly, plus the
+ * `disclosure` section, carried by `benchmark-product-public-bundle/8`.
+ *
+ * The design reserved `/5` for its own disclosure allocation on the UNANCHORED qualified branch, on
+ * the premise (its §12.2) that anchoring and qualification could never combine. Issue #3205 both
+ * took `/5` and dissolved that premise, so per the design's own §6.5 rule — the implementation
+ * packet takes the then-next free numbers if a line has advanced — this is `/6`, and it stacks on
+ * the ANCHORED branch so the real flagship bundle can carry its disclosure record without giving up
+ * its anchor. The allocation is an ADDITION: /1, /2, /3, /4, and /5 keep their meanings and bytes.
+ */
+export const DISCLOSED_CLAIM_PACKAGE_SCHEMA_ID = "benchmark-product.claim-package/6";
 export const BINARY_QUALIFICATION_VERIFICATION_COMMAND = "npx @colophon-claims/verify@0.1.0 <bundle-dir>";
 export const BINARY_QUALIFICATION_COMPATIBLE_VERIFICATION_COMMAND = "npx @colophon-claims/verify@0.1 <bundle-dir>";
 /** Prompted-screening v2 claims require the verifier release that carries that admission surface. */
-export const PROMPTED_BINARY_QUALIFICATION_VERIFICATION_COMMAND = "npx @colophon-claims/verify@0.2.0 <bundle-dir>";
+export const PROMPTED_BINARY_QUALIFICATION_VERIFICATION_COMMAND = "npx @colophon-claims/verify@0.2.1 <bundle-dir>";
+/** Previously materialized prompted bundles remain valid under their immutable 0.2.0 claim. */
+export const LEGACY_PROMPTED_BINARY_QUALIFICATION_VERIFICATION_COMMAND = "npx @colophon-claims/verify@0.2.0 <bundle-dir>";
 export const PROMPTED_BINARY_QUALIFICATION_COMPATIBLE_VERIFICATION_COMMAND = "npx @colophon-claims/verify@0.2 <bundle-dir>";
 const Sha256HexSchema = z.string().regex(/^[a-f0-9]{64}$/, "must be a lowercase sha256 hex digest");
 /** Mirrors `../run/preview-log.ts`'s own (unexported) `Rfc3339Schema` — restated here rather than
@@ -189,6 +219,8 @@ const ClaimPackageWireSchema = z.object({
         z.literal(CLAIM_PACKAGE_SCHEMA_ID),
         z.literal(BINARY_QUALIFICATION_CLAIM_PACKAGE_SCHEMA_ID),
         z.literal(ANCHORED_CLAIM_PACKAGE_SCHEMA_ID),
+        z.literal(ANCHORED_BINARY_QUALIFICATION_CLAIM_PACKAGE_SCHEMA_ID),
+        z.literal(DISCLOSED_CLAIM_PACKAGE_SCHEMA_ID),
     ]),
     scope: z.object({
         draftId: z.string().min(1),
@@ -248,35 +280,70 @@ const ClaimPackageWireSchema = z.object({
      * headline, comparison, threshold, selection, or ranking projection. */
     qualification: z.unknown().optional(),
     /** anchor-evidence §7.4: one entry per AnchorEvidence record the bundle carries, in record-digest
-     * order, each carrying only the facts embedded in the proof's own bytes. Present exactly on
-     * claim-package/4 — the schema-level refine below refuses it on /1 and /2, so an unanchored claim
-     * cannot grow an anchors section and an anchored one cannot be published without it. */
+     * order, each carrying only the facts embedded in the proof's own bytes. Present exactly on the
+     * two anchored allocations, claim-package/4 and claim-package/5 — the schema-level refine below
+     * refuses it on /1 and /2, so an unanchored claim cannot grow an anchors section and an anchored
+     * one cannot be published without it. */
     anchors: z.array(ClaimAnchorSchema).optional(),
+    /** disclosure-specification-record design §6.6: the sealed record's digest plus the facts embedded
+     * in its own bytes, each variable entry VERBATIM. Nothing here is summarized, counted, ranked, or
+     * reworded, and nothing here is derived from anything but the record. Present exactly on
+     * claim-package/6 — the refine below refuses it on every earlier allocation, so a claim cannot
+     * grow a disclosure section without moving to the closure whose check reads it. */
+    disclosure: ClaimDisclosureSectionSchema.optional(),
 }).superRefine((claim, ctx) => {
-    if (claim.claimSchema !== ANCHORED_CLAIM_PACKAGE_SCHEMA_ID && claim.anchors !== undefined) {
+    // The two anchored allocations differ only in which method projection they carry: /4 takes the
+    // headline/comparison family, /5 (issue #3205) the binary qualification. Both carry the section.
+    // The disclosed allocation is the anchored binary one plus a section, so it inherits BOTH parents'
+    // rules by falling through every branch below that /5 falls through (issue #2839).
+    const disclosedClosure = claim.claimSchema === DISCLOSED_CLAIM_PACKAGE_SCHEMA_ID;
+    if (!disclosedClosure && claim.disclosure !== undefined) {
+        ctx.addIssue({
+            code: "custom",
+            message: `only ${DISCLOSED_CLAIM_PACKAGE_SCHEMA_ID} carries a disclosure section`,
+            path: ["disclosure"],
+        });
+    }
+    if (disclosedClosure && claim.disclosure === undefined) {
+        // Unlike `anchors`, this section has no legal EMPTY form: all six variables are structurally
+        // required, so a disclosed bundle with nothing to disclose is not a thing that exists. Omitting
+        // the section while claiming the closure would leave the check reading a record that no reader
+        // of the claim alone can see.
+        ctx.addIssue({
+            code: "custom",
+            message: `${DISCLOSED_CLAIM_PACKAGE_SCHEMA_ID} must carry its disclosure section`,
+            path: ["disclosure"],
+        });
+    }
+    const anchoredClosure = claim.claimSchema === ANCHORED_CLAIM_PACKAGE_SCHEMA_ID
+        || claim.claimSchema === ANCHORED_BINARY_QUALIFICATION_CLAIM_PACKAGE_SCHEMA_ID
+        // /6 is /5 plus a disclosure section, so it is anchored by inheritance: it carries the anchors
+        // section under the same presence rule, and an omitted one refuses identically.
+        || disclosedClosure;
+    if (!anchoredClosure && claim.anchors !== undefined) {
+        ctx.addIssue({
+            code: "custom",
+            message: `only ${ANCHORED_CLAIM_PACKAGE_SCHEMA_ID} and ${ANCHORED_BINARY_QUALIFICATION_CLAIM_PACKAGE_SCHEMA_ID} carry an anchors section`,
+            path: ["anchors"],
+        });
+    }
+    if (anchoredClosure && claim.anchors === undefined) {
+        // Present, not necessarily non-empty. An empty section is legal on exactly one bundle: one
+        // whose sealed Run declared anchoring intent that no carried anchor satisfies (§7.3). That
+        // bundle must still be on the anchored closure so the check that reports the absence runs,
+        // and its claim must therefore still state the closure's seven checks. What no claim may do
+        // is omit the section while claiming the closure, or carry one while claiming an earlier one.
         ctx.addIssue({
             code: "custom",
-            message: `only ${ANCHORED_CLAIM_PACKAGE_SCHEMA_ID} carries an anchors section`,
+            message: `${claim.claimSchema} must carry its anchors section, even when the section is empty`,
             path: ["anchors"],
         });
     }
     if (claim.claimSchema === ANCHORED_CLAIM_PACKAGE_SCHEMA_ID) {
-        if (claim.anchors === undefined) {
-            // Present, not necessarily non-empty. An empty section is legal on exactly one bundle: one
-            // whose sealed Run declared anchoring intent that no carried anchor satisfies (§7.3). That
-            // bundle must still be on the anchored closure so the check that reports the absence runs,
-            // and its claim must therefore still state the closure's seven checks. What no claim may do
-            // is omit the section while claiming the closure, or carry one while claiming an earlier one.
-            ctx.addIssue({
-                code: "custom",
-                message: `${ANCHORED_CLAIM_PACKAGE_SCHEMA_ID} must carry its anchors section, even when the section is empty`,
-                path: ["anchors"],
-            });
-        }
         if (claim.qualification !== undefined) {
             ctx.addIssue({
                 code: "custom",
-                message: "the anchored binary-qualification closure is a later allocation, not claim-package/4",
+                message: `the anchored binary-qualification closure is ${ANCHORED_BINARY_QUALIFICATION_CLAIM_PACKAGE_SCHEMA_ID}, not claim-package/4`,
                 path: ["qualification"],
             });
         }
@@ -365,6 +432,30 @@ const ClaimPackageWireSchema = z.object({
     if (!exactResult) {
         ctx.addIssue({ code: "custom", message: "qualification must exactly equal the Report's one F6 per-subject result", path: ["qualification"] });
     }
+    if (claim.claimSchema === ANCHORED_BINARY_QUALIFICATION_CLAIM_PACKAGE_SCHEMA_ID
+        || disclosedClosure) {
+        // No released reader before 0.2.1 understands `benchmark-product-public-bundle/7` or `/8`, so
+        // both allocations pin that line unconditionally rather than inheriting /2's prompted/unprompted
+        // split — a claim naming an older reader would be an instruction to fail.
+        const expectedChecks = disclosedClosure
+            ? READER_DISCLOSED_VERIFICATION_CHECKS
+            : READER_ANCHORED_QUALIFICATION_VERIFICATION_CHECKS;
+        if (claim.verification.command !== PUBLIC_BUNDLE_V7_VERIFICATION_COMMAND
+            || claim.verification.compatibleCommand !== PUBLIC_BUNDLE_V7_COMPATIBLE_VERIFICATION_COMMAND) {
+            ctx.addIssue({ code: "custom", message: "anchored binary claim package must pin verifier 0.2.1/@0.2", path: ["verification"] });
+        }
+        if (claim.verification.checks.length !== expectedChecks.length
+            || claim.verification.checks.some((check, index) => check !== expectedChecks[index])) {
+            ctx.addIssue({
+                code: "custom",
+                message: disclosedClosure
+                    ? "disclosed claim package must retain the seven anchored verification checks plus disclosure-specification, in order"
+                    : "anchored binary claim package must retain the six frozen verification checks plus integrity-anchors, in order",
+                path: ["verification", "checks"],
+            });
+        }
+        return;
+    }
     const prompted = claim.method.parameters["promptedScreeningProfile"] === PROMPTED_SCREENING_PROFILE;
     const command = prompted
         ? PROMPTED_BINARY_QUALIFICATION_VERIFICATION_COMMAND
@@ -372,8 +463,12 @@ const ClaimPackageWireSchema = z.object({
     const compatibleCommand = prompted
         ? PROMPTED_BINARY_QUALIFICATION_COMPATIBLE_VERIFICATION_COMMAND
         : BINARY_QUALIFICATION_COMPATIBLE_VERIFICATION_COMMAND;
-    if (claim.verification.command !== command || claim.verification.compatibleCommand !== compatibleCommand) {
-        ctx.addIssue({ code: "custom", message: `binary claim package must pin verifier ${prompted ? "0.2.0/@0.2" : "0.1.0/@0.1"}`, path: ["verification"] });
+    const promptedCommandAccepted = prompted
+        && (claim.verification.command === PROMPTED_BINARY_QUALIFICATION_VERIFICATION_COMMAND
+            || claim.verification.command === LEGACY_PROMPTED_BINARY_QUALIFICATION_VERIFICATION_COMMAND);
+    if ((prompted ? !promptedCommandAccepted : claim.verification.command !== command)
+        || claim.verification.compatibleCommand !== compatibleCommand) {
+        ctx.addIssue({ code: "custom", message: `binary claim package must pin verifier ${prompted ? "0.2.1 (or historical 0.2.0)/@0.2" : "0.1.0/@0.1"}`, path: ["verification"] });
     }
     if (claim.verification.checks.length !== READER_VERIFICATION_CHECKS.length
         || claim.verification.checks.some((check, index) => check !== READER_VERIFICATION_CHECKS[index])) {
@@ -400,7 +495,7 @@ function exactBinaryClaimControls(input) {
     // control-shape failure. Neither judge field is ever set on an actual binary-instrument claim
     // (`methodProjection`'s dispatch is exclusive), so admitting them here is defense in depth, not
     // a widening any real claim exercises.
-    return exactKeys(input, ["claimSchema", "scope", "records", "method", "results", "completeness", "attrition", "conflicted", "assurance", "disclosures", "limitations", "venueHonesty", "verification", "rehearsal", "qualification", "anchors", "pairwiseDisagreement", "pairedMajorityDelta"])
+    return exactKeys(input, ["claimSchema", "scope", "records", "method", "results", "completeness", "attrition", "conflicted", "assurance", "disclosures", "limitations", "venueHonesty", "verification", "rehearsal", "qualification", "anchors", "disclosure", "pairwiseDisagreement", "pairedMajorityDelta"])
         && exactKeys(scope, ["draftId", "benchmarkSha256", "taskCount", "arms", "replicates", "venue"])
         && Array.isArray(scope.arms)
         && (scope.arms).every((arm) => exactKeys(arm, ["armId", "pinning"]))
@@ -415,9 +510,17 @@ function exactBinaryClaimControls(input) {
         && exactKeys(verification, ["command", "compatibleCommand", "checks", "trustRoot"])
         && (input.rehearsal === undefined || exactKeys(input.rehearsal, ["previewCount", "timestamps"]));
 }
+/** Both binary allocations pass through the same anti-conclusion control-shape gate: /5 is /2's
+ * projection plus an anchors section, so smuggling a ranking into it must fail identically. */
+const BINARY_CLAIM_PACKAGE_SCHEMA_IDS = [
+    BINARY_QUALIFICATION_CLAIM_PACKAGE_SCHEMA_ID,
+    ANCHORED_BINARY_QUALIFICATION_CLAIM_PACKAGE_SCHEMA_ID,
+    // /6 is /5 plus a section, so a ranking smuggled into it must fail identically (issue #2839).
+    DISCLOSED_CLAIM_PACKAGE_SCHEMA_ID,
+];
 export const ClaimPackageSchema = z.preprocess((input) => {
     if (typeof input === "object" && input !== null && !Array.isArray(input)
-        && input.claimSchema === BINARY_QUALIFICATION_CLAIM_PACKAGE_SCHEMA_ID
+        && BINARY_CLAIM_PACKAGE_SCHEMA_IDS.includes(input.claimSchema)
         && !exactBinaryClaimControls(input)) {
         return { claimSchema: "invalid-binary-claim-control-shape" };
     }
@@ -619,6 +722,8 @@ function summedPinningUnverifiableCounts(perSubject) {
 export const CLAIM_VERIFICATION_CHECKS = READER_VERIFICATION_CHECKS;
 /** The anchored closure's list: the six frozen checks plus `integrity-anchors` (§8). */
 export const ANCHORED_CLAIM_VERIFICATION_CHECKS = READER_ANCHORED_VERIFICATION_CHECKS;
+/** The disclosed closure's list: the anchored seven plus `disclosure-specification` (design §7). */
+export const DISCLOSED_CLAIM_VERIFICATION_CHECKS = READER_DISCLOSED_VERIFICATION_CHECKS;
 export const PUBLIC_BUNDLE_VERIFICATION_COMMAND = READER_VERIFICATION_COMMAND;
 /** The unconditional trust-root sentence, re-exported unchanged. It is DEFINED once beside its
  * anchored replacement in `anchor-claims.ts`: one sentence written out twice, in two mirrored
@@ -657,16 +762,32 @@ export function buildClaimPackage(input) {
     // this builder produced before the feature existed.
     const anchors = input.anchors ?? [];
     const anchored = input.anchors !== undefined;
-    if (anchored && projection.qualification !== undefined) {
-        throw new Error("claim package: the anchored binary-qualification closure is a later allocation"
-            + " — claim-package/4 has no qualification projection");
+    // Strictly opt-in, exactly like `anchors`: a run with no sealed disclosure declaration produces
+    // the claim this builder produced before the feature existed, byte for byte (issue #2839).
+    const disclosure = input.disclosure;
+    // Four allocations across two independent axes (anchored yes/no × qualification yes/no). The
+    // fourth cell, anchored+qualification, is claim-package/5 (issue #3205); before it existed this
+    // pairing threw, which made anchoring and binary-instrument benchmarking mutually exclusive.
+    const anchoredQualification = anchored && projection.qualification !== undefined;
+    // The disclosed allocation is the anchored QUALIFICATION cell plus a section, and there is no
+    // other disclosed cell (issue #2839). A run publishes one bundle per analysis, and its sibling
+    // headline/comparison analyses project no qualification, so they have nowhere to put the section.
+    // Refusing here rather than dropping it silently is what makes the caller state which entry the
+    // record belongs to instead of discovering later that one bundle quietly lost it.
+    if (disclosure !== undefined && !anchoredQualification) {
+        throw new Error("claim package: only the anchored binary-qualification closure carries a disclosure section"
+            + " — this projection has no qualification, and no other closure version expresses one");
     }
     return {
-        claimSchema: anchored
-            ? ANCHORED_CLAIM_PACKAGE_SCHEMA_ID
-            : projection.qualification === undefined
-                ? CLAIM_PACKAGE_SCHEMA_ID
-                : BINARY_QUALIFICATION_CLAIM_PACKAGE_SCHEMA_ID,
+        claimSchema: anchoredQualification && disclosure !== undefined
+            ? DISCLOSED_CLAIM_PACKAGE_SCHEMA_ID
+            : anchoredQualification
+                ? ANCHORED_BINARY_QUALIFICATION_CLAIM_PACKAGE_SCHEMA_ID
+                : anchored
+                    ? ANCHORED_CLAIM_PACKAGE_SCHEMA_ID
+                    : projection.qualification === undefined
+                        ? CLAIM_PACKAGE_SCHEMA_ID
+                        : BINARY_QUALIFICATION_CLAIM_PACKAGE_SCHEMA_ID,
         scope: {
             draftId: input.draftId,
             benchmarkSha256: input.benchmarkSha256,
@@ -707,26 +828,36 @@ export function buildClaimPackage(input) {
         limitations: [...(reportRecord.limitations ?? [])],
         venueHonesty: input.venueHonesty,
         verification: {
-            command: anchored
-                ? PUBLIC_BUNDLE_V6_VERIFICATION_COMMAND
-                : promptedScreening
-                    ? PROMPTED_BINARY_QUALIFICATION_VERIFICATION_COMMAND
-                    : projection.qualification === undefined
-                        ? PUBLIC_BUNDLE_VERIFICATION_COMMAND
-                        : BINARY_QUALIFICATION_VERIFICATION_COMMAND,
-            compatibleCommand: anchored
-                ? PUBLIC_BUNDLE_V6_COMPATIBLE_VERIFICATION_COMMAND
-                : promptedScreening
-                    ? PROMPTED_BINARY_QUALIFICATION_COMPATIBLE_VERIFICATION_COMMAND
-                    : projection.qualification === undefined
-                        ? PUBLIC_BUNDLE_COMPATIBLE_VERIFICATION_COMMAND
-                        : BINARY_QUALIFICATION_COMPATIBLE_VERIFICATION_COMMAND,
-            checks: anchored ? [...ANCHORED_CLAIM_VERIFICATION_CHECKS] : [...CLAIM_VERIFICATION_CHECKS],
+            command: anchoredQualification
+                ? PUBLIC_BUNDLE_V7_VERIFICATION_COMMAND
+                : anchored
+                    ? PUBLIC_BUNDLE_V6_VERIFICATION_COMMAND
+                    : promptedScreening
+                        ? PROMPTED_BINARY_QUALIFICATION_VERIFICATION_COMMAND
+                        : projection.qualification === undefined
+                            ? PUBLIC_BUNDLE_VERIFICATION_COMMAND
+                            : BINARY_QUALIFICATION_VERIFICATION_COMMAND,
+            compatibleCommand: anchoredQualification
+                ? PUBLIC_BUNDLE_V7_COMPATIBLE_VERIFICATION_COMMAND
+                : anchored
+                    ? PUBLIC_BUNDLE_V6_COMPATIBLE_VERIFICATION_COMMAND
+                    : promptedScreening
+                        ? PROMPTED_BINARY_QUALIFICATION_COMPATIBLE_VERIFICATION_COMMAND
+                        : projection.qualification === undefined
+                            ? PUBLIC_BUNDLE_COMPATIBLE_VERIFICATION_COMMAND
+                            : BINARY_QUALIFICATION_COMPATIBLE_VERIFICATION_COMMAND,
+            checks: anchoredQualification && disclosure !== undefined
+                ? [...DISCLOSED_CLAIM_VERIFICATION_CHECKS]
+                : anchored ? [...ANCHORED_CLAIM_VERIFICATION_CHECKS] : [...CLAIM_VERIFICATION_CHECKS],
             // §9.2: the trust-root sentence is replaced only by a governing lock anchor. A bundle whose
             // only anchors are pending, or cover the Matrix alone, keeps the unconditional sentence.
             trustRoot: anchoredTrustRoot(anchors),
         },
         ...(anchored ? { anchors: anchors.map((anchor) => ({ ...anchor })) } : {}),
+        // Copied through, never rebuilt here: the section is `deriveDisclosureSpecification`'s output
+        // over the sealed record's exact bytes, and this builder is not entitled to a second opinion
+        // about what that record says (issue #2839, design §6.6).
+        ...(disclosure === undefined ? {} : { disclosure }),
         ...(input.previewDisclosure !== undefined
             ? {
                 rehearsal: {

package/dist/profile/disclosure.d.ts

@@ -0,0 +1,273 @@
+/**
+ * The disclosed closure's projection and check (disclosure-specification-record design §6.4, §6.6,
+ * §7; issue #2839).
+ *
+ * This module is **single-sourced, not mirrored**, exactly as `anchor-claims.ts` is: `@colophon-
+ * claims/core` already depends on this package, so the producer and the standalone verifier call
+ * ONE `deriveDisclosureSpecification`. The claim-consistency byte-compare then compares one
+ * function's output over two byte sets rather than two implementations' guesses.
+ *
+ * The one posture that matters more than any mechanism here (design R4):
+ *
+ *   **The verifier AUTHENTICATES measurements and CARRIES assertions.**
+ *
+ * A `measured-here` variable must cite records the bundle actually carries, under a role admissible
+ * for the citation. A `disclosed-by-publisher` variable is checked for internal well-formedness and
+ * for nothing else — no lookup, no fetch, no cross-check against the Matrix or the Report, no status
+ * upgrade or downgrade. An assertion that turns out to be false is a false assertion in a valid
+ * record; that is the correct outcome and the honest one, and a verifier that refused it would be
+ * claiming a power it does not have.
+ *
+ * What this check deliberately does NOT do (design §8, each one a thing a well-meaning implementer
+ * would add):
+ *
+ * - It does not reconcile against `Report.disclosures.perSubject[].pinning`. Those counts answer
+ *   "how well did each executed axis pin"; this record answers "which variables were executed at
+ *   all". Two surfaces restating one fact are two surfaces that can disagree.
+ * - It does not infer a status from the bundle. A bundle that plainly executed a judge model does
+ *   not license marking `judge-model` as `measured-here` if the record says otherwise.
+ * - It does not fetch anything, ever. A verifier that reached the network would make its own result
+ *   depend on when it ran.
+ * - It does not rank, score, compare, or aggregate. There is no disclosure-completeness score:
+ *   counting statuses would create a number publishers optimize against, and a six-of-six record
+ *   with six vague assertions would outscore a two-of-six record with two proofs.
+ */
+import { z } from "zod";
+import { SIX_VARIABLE_DISCLOSURE_SPECIFICATION, type DisclosureEvidenceRole, type DisclosureVariableEntry, type DisclosureVariableKey, type DisclosureVariableStatus } from "@jinn-network/benchmarking-records";
+import type { BundleV4EvidenceRole } from "../schema.js";
+/** The evidence-catalog role a disclosure-specification record carries, and the ONLY one it may
+ * carry: a record bearing this token together with any second role refuses (§7 step 1). */
+export declare const DISCLOSURE_SPECIFICATION_BUNDLE_ROLE: "disclosure-specification";
+/**
+ * §6.4's binding profile: which of this carrier's evidence roles satisfy which of the standard's two
+ * portable disclosure roles. Jinn-side mapping, deliberately NOT part of the portable record — the
+ * mapping from the standard's roles onto a specific carrier's record roles is the carrier's business.
+ *
+ * v1 deliberately does not narrow the admissible set per variable. Which record species fixes
+ * `judge-model` depends on the judge profile packet P0 is freezing, and encoding a guess here would
+ * put this module in P0's lane. Reserved as a v2 tightening once P0's record vocabulary merges.
+ */
+export declare const DISCLOSURE_ROLE_BINDING: Readonly<Record<DisclosureEvidenceRole, readonly BundleV4EvidenceRole[]>>;
+/** The claim package's `disclosure` section (§6.6). Every variable entry is its record entry
+ * VERBATIM: nothing is summarized, counted, ranked, or reworded (R5). */
+export interface ClaimDisclosureSection {
+    readonly recordSha256: string;
+    /** The literal standard identifier, not any string: this section names the standard the record
+     * claims compliance with, and a section naming a different one is not this record's projection. */
+    readonly specification: typeof SIX_VARIABLE_DISCLOSURE_SPECIFICATION;
+    readonly subjectSha256: string;
+    readonly variables: Readonly<Record<DisclosureVariableKey, DisclosureVariableEntry>>;
+}
+/**
+ * The claim section's own grammar, single-sourced from the record's schema so the section cannot
+ * describe a variable entry the record could not have carried. It is a second line of defense
+ * rather than the primary one: `assertClaimConsistency`'s whole-claim byte-compare against the
+ * rebuilt claim is what actually proves the section is this record's projection.
+ */
+export declare const ClaimDisclosureSectionSchema: z.ZodObject<{
+    recordSha256: z.ZodString;
+    specification: z.ZodLiteral<"https://spec.jinn.network/disclosure/six-variable/v1">;
+    subjectSha256: z.ZodString;
+    variables: z.ZodObject<{
+        "ingestion-model": z.ZodDiscriminatedUnion<[z.ZodObject<{
+            status: z.ZodLiteral<"measured-here">;
+            statement: z.ZodString;
+            evidence: z.ZodArray<z.ZodObject<{
+                role: z.ZodEnum<{
+                    "pinned-configuration": "pinned-configuration";
+                    "execution-observation": "execution-observation";
+                }>;
+                digest: z.ZodObject<{
+                    sha256: z.ZodString;
+                }, z.core.$strict>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>, z.ZodObject<{
+            status: z.ZodLiteral<"disclosed-by-publisher">;
+            statement: z.ZodString;
+            sources: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                uri: z.ZodString;
+            }, z.core.$strict>>>;
+        }, z.core.$strict>, z.ZodObject<{
+            status: z.ZodLiteral<"undisclosed">;
+            reason: z.ZodEnum<{
+                "not-stated": "not-stated";
+                "stated-without-identifiers": "stated-without-identifiers";
+                "outside-this-experiment": "outside-this-experiment";
+            }>;
+        }, z.core.$strict>], "status">;
+        "retrieval-config": z.ZodDiscriminatedUnion<[z.ZodObject<{
+            status: z.ZodLiteral<"measured-here">;
+            statement: z.ZodString;
+            evidence: z.ZodArray<z.ZodObject<{
+                role: z.ZodEnum<{
+                    "pinned-configuration": "pinned-configuration";
+                    "execution-observation": "execution-observation";
+                }>;
+                digest: z.ZodObject<{
+                    sha256: z.ZodString;
+                }, z.core.$strict>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>, z.ZodObject<{
+            status: z.ZodLiteral<"disclosed-by-publisher">;
+            statement: z.ZodString;
+            sources: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                uri: z.ZodString;
+            }, z.core.$strict>>>;
+        }, z.core.$strict>, z.ZodObject<{
+            status: z.ZodLiteral<"undisclosed">;
+            reason: z.ZodEnum<{
+                "not-stated": "not-stated";
+                "stated-without-identifiers": "stated-without-identifiers";
+                "outside-this-experiment": "outside-this-experiment";
+            }>;
+        }, z.core.$strict>], "status">;
+        "answer-model": z.ZodDiscriminatedUnion<[z.ZodObject<{
+            status: z.ZodLiteral<"measured-here">;
+            statement: z.ZodString;
+            evidence: z.ZodArray<z.ZodObject<{
+                role: z.ZodEnum<{
+                    "pinned-configuration": "pinned-configuration";
+                    "execution-observation": "execution-observation";
+                }>;
+                digest: z.ZodObject<{
+                    sha256: z.ZodString;
+                }, z.core.$strict>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>, z.ZodObject<{
+            status: z.ZodLiteral<"disclosed-by-publisher">;
+            statement: z.ZodString;
+            sources: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                uri: z.ZodString;
+            }, z.core.$strict>>>;
+        }, z.core.$strict>, z.ZodObject<{
+            status: z.ZodLiteral<"undisclosed">;
+            reason: z.ZodEnum<{
+                "not-stated": "not-stated";
+                "stated-without-identifiers": "stated-without-identifiers";
+                "outside-this-experiment": "outside-this-experiment";
+            }>;
+        }, z.core.$strict>], "status">;
+        "answer-prompt": z.ZodDiscriminatedUnion<[z.ZodObject<{
+            status: z.ZodLiteral<"measured-here">;
+            statement: z.ZodString;
+            evidence: z.ZodArray<z.ZodObject<{
+                role: z.ZodEnum<{
+                    "pinned-configuration": "pinned-configuration";
+                    "execution-observation": "execution-observation";
+                }>;
+                digest: z.ZodObject<{
+                    sha256: z.ZodString;
+                }, z.core.$strict>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>, z.ZodObject<{
+            status: z.ZodLiteral<"disclosed-by-publisher">;
+            statement: z.ZodString;
+            sources: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                uri: z.ZodString;
+            }, z.core.$strict>>>;
+        }, z.core.$strict>, z.ZodObject<{
+            status: z.ZodLiteral<"undisclosed">;
+            reason: z.ZodEnum<{
+                "not-stated": "not-stated";
+                "stated-without-identifiers": "stated-without-identifiers";
+                "outside-this-experiment": "outside-this-experiment";
+            }>;
+        }, z.core.$strict>], "status">;
+        "judge-model": z.ZodDiscriminatedUnion<[z.ZodObject<{
+            status: z.ZodLiteral<"measured-here">;
+            statement: z.ZodString;
+            evidence: z.ZodArray<z.ZodObject<{
+                role: z.ZodEnum<{
+                    "pinned-configuration": "pinned-configuration";
+                    "execution-observation": "execution-observation";
+                }>;
+                digest: z.ZodObject<{
+                    sha256: z.ZodString;
+                }, z.core.$strict>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>, z.ZodObject<{
+            status: z.ZodLiteral<"disclosed-by-publisher">;
+            statement: z.ZodString;
+            sources: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                uri: z.ZodString;
+            }, z.core.$strict>>>;
+        }, z.core.$strict>, z.ZodObject<{
+            status: z.ZodLiteral<"undisclosed">;
+            reason: z.ZodEnum<{
+                "not-stated": "not-stated";
+                "stated-without-identifiers": "stated-without-identifiers";
+                "outside-this-experiment": "outside-this-experiment";
+            }>;
+        }, z.core.$strict>], "status">;
+        "judge-prompt": z.ZodDiscriminatedUnion<[z.ZodObject<{
+            status: z.ZodLiteral<"measured-here">;
+            statement: z.ZodString;
+            evidence: z.ZodArray<z.ZodObject<{
+                role: z.ZodEnum<{
+                    "pinned-configuration": "pinned-configuration";
+                    "execution-observation": "execution-observation";
+                }>;
+                digest: z.ZodObject<{
+                    sha256: z.ZodString;
+                }, z.core.$strict>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>, z.ZodObject<{
+            status: z.ZodLiteral<"disclosed-by-publisher">;
+            statement: z.ZodString;
+            sources: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                uri: z.ZodString;
+            }, z.core.$strict>>>;
+        }, z.core.$strict>, z.ZodObject<{
+            status: z.ZodLiteral<"undisclosed">;
+            reason: z.ZodEnum<{
+                "not-stated": "not-stated";
+                "stated-without-identifiers": "stated-without-identifiers";
+                "outside-this-experiment": "outside-this-experiment";
+            }>;
+        }, z.core.$strict>], "status">;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export declare class DisclosureProjectionError extends Error {
+    constructor(message: string);
+}
+/**
+ * The one shared projection, called by BOTH the workspace producer and the standalone verifier.
+ *
+ * It carries only facts embedded in the record's own bytes, plus the record's digest — which is the
+ * digest of the very bytes handed in, never a separately supplied one. It exists at all so a reader
+ * of `claim-package.json` alone sees all six statuses without opening an evidence record, and so
+ * `assertClaimConsistency`'s existing whole-claim byte-compare covers the disclosure without a
+ * second bespoke comparison.
+ */
+export declare function deriveDisclosureSpecification(recordBytes: Uint8Array): ClaimDisclosureSection;
+/** The disclosed statuses, surfaced on the verification result (§7 step 11). Disclosed facts, never
+ * folded into a single badge — the same posture `anchors` takes. */
+export interface DisclosureSpecificationReport {
+    readonly recordSha256: string;
+    readonly specification: string;
+    readonly subjectSha256: string;
+    readonly statuses: Readonly<Record<DisclosureVariableKey, DisclosureVariableStatus>>;
+}
+export interface AssertDisclosureSpecificationInput {
+    /** The Report extension's descriptor digest — what the carrier says the record is. */
+    readonly extensionDigestSha256: string;
+    /** Every evidence-catalog record's declared roles, keyed by record digest. */
+    readonly catalogRoles: ReadonlyMap<string, ReadonlySet<string>>;
+    /** The exact carried bytes for every evidence record, keyed by digest. */
+    readonly recordBytes: ReadonlyMap<string, Uint8Array>;
+    /** The bundle's own Matrix digest — the record's one legal subject (R1). */
+    readonly matrixSha256: string;
+    /** The verified Report's author IRI. */
+    readonly reportAuthor: string;
+    /** Refuses with the verifier's own typed refusal, so this module raises no error class of its own
+     * at the call boundary and every path lands in the caller's issue shape. */
+    readonly refuse: (path: string, message: string) => never;
+}
+/**
+ * §7 steps 1–8: authenticate what the Report extension names.
+ *
+ * Step 9 (claim-id pairing) and step 10 (projection equality) live in `verify.ts` and
+ * `assertClaimConsistency` respectively, because both compare against documents this function is
+ * deliberately not handed — keeping this function a statement about the RECORD and its evidence.
+ */
+export declare function assertDisclosureSpecification(input: AssertDisclosureSpecificationInput): DisclosureSpecificationReport;