@colophon-claims/verify 0.1.0 → 0.2.1

package/dist/admission/verification.js

@@ -3,9 +3,11 @@ import { z } from "zod";
 import { VERDICT_DSSE_PAYLOAD_TYPE, canonicalJsonBytes, compareCodeUnitStrings, parseBinaryJudgmentAnalysisContext, parseBinaryJudgmentInstrument, parseBinaryJudgmentLabelResolution, parseBinaryJudgmentPayload, recordDigest, sealBinaryJudgmentInstrument, } from "@jinn-network/task-execution-profiles";
 import { parseExactDsseEnvelope } from "@jinn-network/trust-core";
 import { BINARY_JUDGMENT_HUMAN_REVIEW_EVALUATION_SPEC_SEALED, HUMAN_REVIEW_FORM_SEALED, } from "./application.js";
-import { BinaryJudgmentAdmissionManifestSchema, HUMAN_REVIEW_OPERATOR_ASSERTION_MEDIA_TYPE, HUMAN_REVIEW_PACKET_MEDIA_TYPE, HUMAN_REVIEW_RESPONSE_MEDIA_TYPE, HUMAN_REVIEW_REVEAL_RECEIPT_MEDIA_TYPE, HUMAN_REVIEW_ROSTER_MEDIA_TYPE, HUMAN_REVIEW_VISIBILITY_RECEIPT_MEDIA_TYPE, SCREENING_REVEAL_RECEIPT_MEDIA_TYPE, SCREENING_TABLE_MEDIA_TYPE, HumanReviewOperatorAssertionSchema, HumanReviewPacketSchema, HumanReviewReplacementLedgerSchema, HumanReviewResponseSchema, HumanReviewRevealReceiptSchema, HumanReviewRosterSchema, HumanReviewVisibilityReceiptSchema, ScreeningRevealReceiptSchema, ScreeningTableSchema, } from "./contracts.js";
+import { BinaryJudgmentAdmissionManifestSchema, HUMAN_REVIEW_OPERATOR_ASSERTION_MEDIA_TYPE, HUMAN_REVIEW_PACKET_MEDIA_TYPE, HUMAN_REVIEW_RESPONSE_MEDIA_TYPE, HUMAN_REVIEW_REVEAL_RECEIPT_MEDIA_TYPE, HUMAN_REVIEW_ROSTER_MEDIA_TYPE, HUMAN_REVIEW_VISIBILITY_RECEIPT_MEDIA_TYPE, SCREENING_REVEAL_RECEIPT_MEDIA_TYPE, SCREENING_TABLE_MEDIA_TYPE, SCREENING_TABLE_V2_MEDIA_TYPE, HumanReviewOperatorAssertionSchema, HumanReviewPacketSchema, HumanReviewReplacementLedgerSchema, HumanReviewResponseSchema, HumanReviewRevealReceiptSchema, HumanReviewRosterSchema, HumanReviewVisibilityReceiptSchema, ScreeningRevealReceiptSchema, ScreeningTableSchema, ScreeningTableV2Schema, PromptedScreeningProcedureV1Schema, ScreeningPoolSchema, SCREENING_POOL_V2_PROTOCOL, PROMPTED_SCREENING_LIMITATIONS, PROMPTED_SCREENING_PROFILE, } from "./contracts.js";
+import { selectPromptedScreeningPool, PromptedScreeningSelectionError } from "./prompted-selection.js";
+import { parseScreeningSampleCommitmentBytes, promptedScreeningCommitmentView, } from "./prompted-commitment.js";
 import { readOrderedAdmissionVerdictMeasurements, readAdmissionVerdictEnvelope } from "./result-evaluation.js";
-import { computeScreeningSample, ScreeningSampleError } from "./screening-sample.js";
+import { computeScreeningPoolDigest, computeScreeningSample, ScreeningSampleError } from "./screening-sample.js";
 // Verbatim duplicate of `schema.ts`'s `BUNDLE_V4_ADMISSION_EVIDENCE_ROLES`, hand-kept in sync
 // (spec §6.8a Group C).
 export const BINARY_JUDGMENT_ADMISSION_RECORD_ROLES = [
@@ -21,7 +23,17 @@ export const BINARY_JUDGMENT_ADMISSION_RECORD_ROLES = [
     "screening-instrument",
     "screening-sampling-script",
     "screening-raw-outputs",
+    "screening-prompt",
+    "screening-procedure",
+    "screening-pool",
+    "screening-sample-commitment",
+    "screening-transcript",
 ];
+export const PROMPTED_SCREENING_CAPABILITY_BOUNDARY = {
+    status: "not-machine-verified",
+    machineVerified: ["sealed-pool", "sealed-sample", "signed-table", "operator-decisions", "artifact-integrity"],
+    notMachineVerified: PROMPTED_SCREENING_LIMITATIONS,
+};
 export class BinaryJudgmentAdmissionClosureError extends Error {
     path;
     constructor(path, detail, options) {
@@ -244,14 +256,15 @@ function authorityPayload(state, options) {
     catch (cause) {
         fail(path, "authority evidence is not an exact compact DSSE envelope", cause);
     }
-    if (envelope.payloadType !== mediaType || envelope.signatures.length !== 1)
+    const allowedMediaTypes = typeof mediaType === "string" ? [mediaType] : mediaType;
+    if (!allowedMediaTypes.includes(envelope.payloadType) || envelope.signatures.length !== 1)
         fail(path, "authority evidence has the wrong payload type or signature count");
     const signature = envelope.signatures[0];
     const signatureKeyId = signature.keyid;
     if (typeof signatureKeyId !== "string" || !state.ports.verifyAuthoritySignature({ envelopeBytes, keyId: signatureKeyId, role })) {
         fail(path, `authority signature is invalid for role ${role}`);
     }
-    return { value: exactCanonical(schema, envelope.payloadBytes, `${path}.payload`), keyId: signatureKeyId };
+    return { value: exactCanonical(schema, envelope.payloadBytes, `${path}.payload`), keyId: signatureKeyId, mediaType: envelope.payloadType };
 }
 function verifyHumanEvidence(state, refs, expectedItemSha256, expectedDraftId, admittedAt, path) {
     const reviews = refs.reviewVerdictSha256s.map((digest, index) => verifyReview(state, digest, expectedItemSha256, `${path}.reviews.${index}`));
@@ -314,27 +327,29 @@ function expectedExclusionReason(reviews) {
         return "review-disagreement";
     return undefined;
 }
-/**
- * The screened branch's sibling of `expectedExclusionReason` above, derived from §6.4's admission
- * rule instead of two signed reviews (spec §6.4, §6.5 check (4)). The seventh copy of the
- * replacement-ledger reason vocabulary this file carries (contracts.ts's own comment names the
- * other six and defers this one to S3, "recomputation logic").
- *
- * A row this file already knows is admitted returns `undefined` (no exclusion). Among excluded
- * rows: a FLAGGED row (`screeningVerdict !== intendedLabel`) is always hand-checked in a passing
- * closure (check (2) requires it), so its reason names the screen's own finding regardless of
- * that hand check having run -- `screening-indeterminate` when the screen itself was
- * indeterminate, `screening-disagreement` for a definite-label disagreement. `screening-hand-
- * excluded` is reserved for the one case a flagged-first read would miss: R-3's tie-break, a row
- * the screen AGREED with that the hand check overrode to exclude.
- */
+function screeningRowAgreed(row) {
+    return row.screeningVerdict !== "UNSURE"
+        && row.screeningVerdict !== "indeterminate"
+        && row.screeningVerdict === row.intendedLabel;
+}
+function screeningRowChecked(row) {
+    return "ritsuDecision" in row ? row.ritsuDecision.checked : row.handChecked;
+}
+function screeningRowHandVerdict(row) {
+    if ("ritsuDecision" in row)
+        return row.ritsuDecision.checked ? row.ritsuDecision.verdict : undefined;
+    return row.handVerdict;
+}
+function screeningRowAdmitted(row) {
+    return screeningRowChecked(row) ? screeningRowHandVerdict(row) === "confirm" : screeningRowAgreed(row);
+}
 function expectedScreeningExclusionReason(row) {
-    const agreed = row.screeningVerdict === row.intendedLabel;
-    const admitted = row.handChecked ? row.handVerdict === "confirm" : agreed;
+    const agreed = screeningRowAgreed(row);
+    const admitted = screeningRowAdmitted(row);
     if (admitted)
         return undefined;
     if (!agreed)
-        return row.screeningVerdict === "indeterminate" ? "screening-indeterminate" : "screening-disagreement";
+        return row.screeningVerdict === "indeterminate" || row.screeningVerdict === "UNSURE" ? "screening-indeterminate" : "screening-disagreement";
     return "screening-hand-excluded";
 }
 /** The reviewer Result Evaluation verifier shared by admission construction and closure replay. */
@@ -365,6 +380,10 @@ export function verifyBinaryJudgmentAdmissionClosure(input, ports) {
     let screeningSample = new Set();
     let screeningSampleAgreementRate;
     let screeningInstrumentSha256;
+    let promptedScreeningProcedureSha256;
+    let promptedScreeningPool;
+    let promptedCommittedSample;
+    let screeningTableAuthorityKeyId;
     if (manifest.truthAdmission === "screened-operator-sampled") {
         if (manifest.screeningTableSha256 === undefined) {
             fail("admissionManifest.screeningTableSha256", "screened admission manifest carries no screening table reference");
@@ -380,28 +399,100 @@ export function verifyBinaryJudgmentAdmissionClosure(input, ports) {
         // branch's sole legal authority set is `["truth-reveal-attestor"]` alone (§6.8a Group C), so
         // that is the one key that signs both the bank-scoped table and the bank-scoped reveal
         // receipt: "signed once per bank" as D1 describes.
-        screeningTable = authorityPayload(state, {
+        const tableEvidence = authorityPayload(state, {
             digest: manifest.screeningTableSha256,
-            mediaType: SCREENING_TABLE_MEDIA_TYPE,
+            mediaType: [SCREENING_TABLE_MEDIA_TYPE, SCREENING_TABLE_V2_MEDIA_TYPE],
             role: "truth-reveal-attestor",
             evidenceRole: "screening-table",
-            schema: ScreeningTableSchema,
+            schema: z.union([ScreeningTableSchema, ScreeningTableV2Schema]),
             path: "admissionManifest.screeningTableSha256",
-        }).value;
+        });
+        screeningTable = tableEvidence.value;
+        screeningTableAuthorityKeyId = tableEvidence.keyId;
         if (screeningTable.draftId !== input.expectedDraftId || screeningTable.sealedAt !== manifest.admittedAt) {
             fail("screeningTable", "table draft/time does not bind the manifest");
         }
-        const screeningInstrument = parseProfileRecord(state, screeningTable.screeningInstrumentSha256, "screeningTable.screeningInstrumentSha256", parseBinaryJudgmentInstrument, "screening-instrument");
-        const resealedScreeningInstrument = sealBinaryJudgmentInstrument(screeningInstrument.value);
-        if (resealedScreeningInstrument.digest !== screeningTable.screeningInstrumentSha256
-            || !bytesEqual(resealedScreeningInstrument.bytes, screeningInstrument.bytes)) {
-            fail("screeningTable.screeningInstrumentSha256", "instrument does not reseal to its table commitment");
+        let sampleSeed;
+        let sampleSize;
+        let sampleIdentities;
+        if (screeningTable.protocol === "https://spec.jinn.network/binary-judgment/screening-table/v1") {
+            if (tableEvidence.mediaType !== SCREENING_TABLE_MEDIA_TYPE)
+                fail("screeningTable", "v1 table protocol must use the v1 media type");
+            const screeningInstrument = parseProfileRecord(state, screeningTable.screeningInstrumentSha256, "screeningTable.screeningInstrumentSha256", parseBinaryJudgmentInstrument, "screening-instrument");
+            const resealedScreeningInstrument = sealBinaryJudgmentInstrument(screeningInstrument.value);
+            if (resealedScreeningInstrument.digest !== screeningTable.screeningInstrumentSha256 || !bytesEqual(resealedScreeningInstrument.bytes, screeningInstrument.bytes)) {
+                fail("screeningTable.screeningInstrumentSha256", "instrument does not reseal to its table commitment");
+            }
+            screeningInstrumentSha256 = screeningTable.screeningInstrumentSha256;
+            resolve(state, screeningTable.samplingScriptSha256, "screeningTable.samplingScriptSha256", "screening-sampling-script");
+            resolve(state, screeningTable.rawOutputsSha256, "screeningTable.rawOutputsSha256", "screening-raw-outputs");
+            sampleSeed = screeningTable.sampleSeed;
+            sampleSize = screeningTable.sampleSize;
+            sampleIdentities = screeningTable.rows.map((row) => row.itemSha256);
+        }
+        else {
+            if (tableEvidence.mediaType !== SCREENING_TABLE_V2_MEDIA_TYPE)
+                fail("screeningTable", "v2 table protocol must use the v2 media type");
+            const procedure = exactCanonical(PromptedScreeningProcedureV1Schema, resolve(state, screeningTable.procedureSha256, "screeningTable.procedureSha256", "screening-procedure"), "screeningProcedure");
+            const pool = exactCanonical(ScreeningPoolSchema, resolve(state, screeningTable.poolSha256, "screeningTable.poolSha256", "screening-pool"), "screeningPool");
+            let commitment;
+            try {
+                commitment = parseScreeningSampleCommitmentBytes(resolve(state, screeningTable.sampleCommitmentSha256, "screeningTable.sampleCommitmentSha256", "screening-sample-commitment"));
+            }
+            catch (cause) {
+                fail("screeningSampleCommitment", cause instanceof Error ? cause.message : "screening sample commitment is invalid", cause);
+            }
+            const commitmentView = promptedScreeningCommitmentView(commitment);
+            resolve(state, screeningTable.coordinatorPromptSha256, "screeningTable.coordinatorPromptSha256", "screening-prompt");
+            resolve(state, screeningTable.samplingScriptSha256, "screeningTable.samplingScriptSha256", "screening-sampling-script");
+            resolve(state, screeningTable.transcriptSha256, "screeningTable.transcriptSha256", "screening-transcript");
+            if (procedure.coordinatorPromptSha256 !== screeningTable.coordinatorPromptSha256
+                || procedure.transcriptSha256 !== screeningTable.transcriptSha256
+                || pool.draftId !== input.expectedDraftId
+                || (commitmentView.draftId !== undefined && commitmentView.draftId !== input.expectedDraftId)
+                || (commitmentView.poolSha256 !== undefined && commitmentView.poolSha256 !== screeningTable.poolSha256)
+                || commitmentView.poolIdentityCommitmentSha256 !== pool.identityCommitmentSha256
+                || (commitmentView.samplingScriptSha256 !== undefined && commitmentView.samplingScriptSha256 !== screeningTable.samplingScriptSha256)
+                || Date.parse(procedure.sealedAt) > Date.parse(screeningTable.sealedAt)
+                || Date.parse(pool.sealedAt) > Date.parse(screeningTable.sealedAt)
+                || (commitmentView.poolSha256 !== undefined && Date.parse(pool.sealedAt) > Date.parse(commitmentView.committedAt))
+                || Date.parse(commitmentView.committedAt) > Date.parse(screeningTable.sealedAt))
+                fail("screeningTable", "prompted procedure, prompt, transcript, pool, commitment, draft, or timestamps do not join");
+            const poolIdentities = pool.protocol === SCREENING_POOL_V2_PROTOCOL
+                ? pool.items.map((item) => item.screeningIdentitySha256)
+                : pool.items.map((item) => item.itemSha256);
+            if (commitmentView.registeredIdentitySha256s !== undefined
+                && !sameStrings([...poolIdentities].sort(compareCodeUnitStrings), commitmentView.registeredIdentitySha256s))
+                fail("screeningSampleCommitment.candidateItemDigests", "registered identities do not exactly cover the later pool bridge");
+            if (computeScreeningPoolDigest(poolIdentities) !== pool.identityCommitmentSha256)
+                fail("screeningPool.identityCommitmentSha256", "identity commitment does not match the sorted unique pool identities");
+            const itemIds = new Set();
+            for (const [index, poolItem] of pool.items.entries()) {
+                const item = parseProfileRecord(state, poolItem.itemSha256, `screeningPool.items.${index}.itemSha256`, (bytes) => parseBinaryJudgmentPayload(bytes), "source-item").value;
+                if (itemIds.has(item.itemId))
+                    fail("screeningPool.items", `duplicate source itemId ${item.itemId}`);
+                itemIds.add(item.itemId);
+            }
+            const rowIdentities = screeningTable.rows.map((row) => row.itemSha256);
+            const sortedPoolItemSha256s = pool.items.map((item) => item.itemSha256).sort(compareCodeUnitStrings);
+            if (!sameStrings(rowIdentities, sortedPoolItemSha256s))
+                fail("screeningTable.rows", "v2 table must cover all 664 pool item digests in sorted order");
+            const poolByItem = new Map(pool.items.map((item) => [item.itemSha256, item]));
+            for (const row of screeningTable.rows) {
+                const poolItem = poolByItem.get(row.itemSha256);
+                if (row.intendedLabel !== poolItem.intendedLabel)
+                    fail("screeningTable.rows", `row ${row.itemSha256} intended label differs from the sealed pool`);
+                if (row.ritsuDecision.checked && (Date.parse(row.ritsuDecision.decidedAt) < Date.parse(commitmentView.committedAt)
+                    || Date.parse(row.ritsuDecision.decidedAt) > Date.parse(screeningTable.sealedAt)))
+                    fail("screeningTable.rows", `row ${row.itemSha256} has a Ritsu decision outside the committed-sample-to-table interval`);
+            }
+            sampleSeed = commitmentView.sampleSeed;
+            sampleSize = commitmentView.sampleSize;
+            sampleIdentities = poolIdentities;
+            promptedScreeningProcedureSha256 = screeningTable.procedureSha256;
+            promptedScreeningPool = pool;
+            promptedCommittedSample = commitmentView.sampleItemSha256s;
         }
-        screeningInstrumentSha256 = screeningTable.screeningInstrumentSha256;
-        // These two sidecars are intentionally opaque. Resolving them is sufficient to prove exact
-        // digest-bound reachability; screening-sample/1 remains the independent sampling authority.
-        resolve(state, screeningTable.samplingScriptSha256, "screeningTable.samplingScriptSha256", "screening-sampling-script");
-        resolve(state, screeningTable.rawOutputsSha256, "screeningTable.rawOutputsSha256", "screening-raw-outputs");
         screeningRowsByItem = new Map(screeningTable.rows.map((row) => [row.itemSha256, row]));
         // (1) Sample membership: recomputed by screening-sample/1, never by executing the sealed
         // script (R-4). The recomputation is authoritative for checks (2) and (3) below -- there is
@@ -409,9 +500,9 @@ export function verifyBinaryJudgmentAdmissionClosure(input, ports) {
         let sampleResult;
         try {
             sampleResult = computeScreeningSample({
-                itemSha256s: screeningTable.rows.map((row) => row.itemSha256),
-                sampleSeed: screeningTable.sampleSeed,
-                sampleSize: screeningTable.sampleSize,
+                itemSha256s: sampleIdentities,
+                sampleSeed,
+                sampleSize,
             });
         }
         catch (cause) {
@@ -420,21 +511,28 @@ export function verifyBinaryJudgmentAdmissionClosure(input, ports) {
                 : "sample recomputation (screening-sample/1) failed", cause);
         }
         screeningSample = new Set(sampleResult.sample);
+        if (promptedCommittedSample !== undefined && !sameStrings([...sampleResult.sample].sort(compareCodeUnitStrings), promptedCommittedSample))
+            fail("screeningSampleCommitment.sampleItemSha256s", "public sample membership differs from screening-sample/1 recomputation");
+        const sampledItemSha256s = promptedScreeningPool?.protocol === SCREENING_POOL_V2_PROTOCOL
+            ? new Set(promptedScreeningPool.items
+                .filter((item) => screeningSample.has(item.screeningIdentitySha256))
+                .map((item) => item.itemSha256))
+            : screeningSample;
         // (2) Required hand checks: flagged := rows where NOT agreed. Every row in flagged ∪ sample
         // must carry handChecked === true.
         for (const row of screeningTable.rows) {
-            const flagged = row.screeningVerdict !== row.intendedLabel;
-            if ((flagged || screeningSample.has(row.itemSha256)) && !row.handChecked) {
+            const flagged = !screeningRowAgreed(row);
+            if ((flagged || sampledItemSha256s.has(row.itemSha256)) && !screeningRowChecked(row)) {
                 fail("screeningTable.rows", `row ${row.itemSha256} is flagged or sampled but was never hand-checked`);
             }
         }
         // (3) Sample agreement rate -- the one definition (spec §6.5(3)), symmetric on purpose. Every
         // row in `screeningSample` is hand-checked by check (2) above, so `handVerdict` is defined.
-        const sampleMatches = [...screeningSample].filter((sampledItemSha256) => {
+        const sampleMatches = [...sampledItemSha256s].filter((sampledItemSha256) => {
             const row = screeningRowsByItem.get(sampledItemSha256);
-            return (row.screeningVerdict === row.intendedLabel) === (row.handVerdict === "confirm");
+            return screeningRowAgreed(row) === (screeningRowHandVerdict(row) === "confirm");
         }).length;
-        screeningSampleAgreementRate = sampleMatches / screeningSample.size;
+        screeningSampleAgreementRate = sampleMatches / sampledItemSha256s.size;
     }
     const resolutions = manifest.labelResolutionSha256s.map((digest, index) => ({
         digest,
@@ -528,6 +626,7 @@ export function verifyBinaryJudgmentAdmissionClosure(input, ports) {
                 const reveal = revealEvidence.value;
                 if (reveal.attestorRole !== "truth-reveal-attestor"
                     || reveal.attestorKeyId !== revealEvidence.keyId
+                    || revealEvidence.keyId !== screeningTableAuthorityKeyId
                     || reveal.draftId !== input.expectedDraftId
                     || reveal.screeningTableSha256 !== resolution.screeningTableSha256
                     || reveal.judgeExecutionState !== "not-started"
@@ -539,12 +638,13 @@ export function verifyBinaryJudgmentAdmissionClosure(input, ports) {
                 const row = screeningRowsByItem.get(resolution.itemSha256);
                 if (row === undefined)
                     fail(path, "accepted screened item has no covering screening-table row");
-                const agreed = row.screeningVerdict === row.intendedLabel;
-                const admitted = row.handChecked ? row.handVerdict === "confirm" : agreed;
-                if (!admitted)
-                    fail(path, "admitted screened item's table row is not itself admitted per §6.4's admission rule");
+                if (!screeningRowAdmitted(row))
+                    fail(path, "admitted screened item's table row is not itself admitted per the sealed admission rule");
                 if (row.intendedLabel !== resolution.truthLabel)
                     fail(path, "resolution truth label differs from the screening table's intended label");
+                const poolItem = promptedScreeningPool?.items.find((item) => item.itemSha256 === resolution.itemSha256);
+                if (poolItem !== undefined && (poolItem.candidateClass !== resolution.candidateClass || poolItem.stratum !== resolution.stratum))
+                    fail(path, "resolution class or stratum differs from the prompted screening pool");
                 break;
             }
             default: {
@@ -566,6 +666,36 @@ export function verifyBinaryJudgmentAdmissionClosure(input, ports) {
     if (contextByResolution.size !== resolutions.length || contexts.some((entry) => !manifest.labelResolutionSha256s.includes(entry.value.labelResolutionSha256))) {
         fail("admissionManifest.analysisContextSha256s", "analysis-context coverage has an orphan or omission");
     }
+    const promptedExpectedReplacements = new Map();
+    if (promptedScreeningPool !== undefined) {
+        let selection;
+        try {
+            selection = selectPromptedScreeningPool(promptedScreeningPool, screeningRowsByItem);
+        }
+        catch (cause) {
+            fail("screeningPool.items", cause instanceof PromptedScreeningSelectionError ? cause.message : "prompted reserve selection failed", cause);
+        }
+        const expectedAccepted = new Set(selection.winners.map((item) => item.itemSha256));
+        for (const replacement of selection.replacements) {
+            promptedExpectedReplacements.set(replacement.excludedMain.itemSha256, {
+                replacementItemSha256: replacement.replacement.itemSha256,
+                receivingSlotId: replacement.receivingSlotId,
+            });
+        }
+        const actualAccepted = [...acceptedItems].sort(compareCodeUnitStrings);
+        if (!sameStrings(actualAccepted, [...expectedAccepted].sort(compareCodeUnitStrings)))
+            fail("admissionManifest.labelResolutionSha256s", "accepted items are not the first admissible candidate in every sealed slot");
+        if (accepted.length !== 240)
+            fail("admissionManifest.labelResolutionSha256s", "prompted screening must admit exactly 240 items");
+        for (const candidateClass of ["correct", "specific-wrong", "vague-topical-wrong"]) {
+            if (accepted.filter((item) => item.candidateClass === candidateClass).length !== 80)
+                fail("admissionManifest.labelResolutionSha256s", `final bank must contain exactly 80 ${candidateClass} items`);
+            for (const stratum of ["category-1", "category-2", "category-3", "category-4"]) {
+                if (accepted.filter((item) => item.candidateClass === candidateClass && item.stratum === stratum).length !== 20)
+                    fail("admissionManifest.labelResolutionSha256s", `final bank must contain exactly 20 ${candidateClass}/${stratum} items`);
+            }
+        }
+    }
     const excludedDigests = ledger.entries.map((entry) => entry.excludedItemSha256).sort(compareCodeUnitStrings);
     if (!sameStrings(excludedDigests, manifest.excludedItemSha256s))
         fail("replacementLedger.entries", "ledger exclusion coverage differs from manifest");
@@ -577,7 +707,14 @@ export function verifyBinaryJudgmentAdmissionClosure(input, ports) {
     let previousPosition = 0;
     for (const [index, entry] of ledger.entries.entries()) {
         const path = `replacementLedger.entries.${index}`;
-        if (entry.excludedPoolPosition <= previousPosition)
+        const sharedPool = promptedScreeningPool?.protocol === SCREENING_POOL_V2_PROTOCOL;
+        if (sharedPool) {
+            const previousSlotId = index === 0 ? undefined : ledger.entries[index - 1].receivingSlotId;
+            if (entry.receivingSlotId === undefined || (previousSlotId !== undefined && compareCodeUnitStrings(previousSlotId, entry.receivingSlotId) >= 0)) {
+                fail(path, "shared-reserve ledger entries are not in deterministic receiving-slot order");
+            }
+        }
+        else if (entry.excludedPoolPosition <= previousPosition)
             fail(path, "ledger entries are not in deterministic pool order");
         previousPosition = entry.excludedPoolPosition;
         if (excludedItems.has(entry.excludedItemSha256) || acceptedItems.has(entry.excludedItemSha256))
@@ -593,6 +730,35 @@ export function verifyBinaryJudgmentAdmissionClosure(input, ports) {
             || replacement.candidateClass !== entry.candidateClass
             || replacement.stratum !== entry.stratum)
             fail(path, "replacement is not a later admitted reserve in the same class and stratum");
+        if (promptedScreeningPool !== undefined) {
+            const excludedPoolItem = promptedScreeningPool.items.find((item) => item.itemSha256 === entry.excludedItemSha256);
+            const replacementPoolItem = promptedScreeningPool.items.find((item) => item.itemSha256 === entry.replacementItemSha256);
+            const expected = promptedExpectedReplacements.get(entry.excludedItemSha256);
+            let sealedPoolItemsMatch = false;
+            let actualReceivingSlotId;
+            if (promptedScreeningPool.protocol === SCREENING_POOL_V2_PROTOCOL) {
+                if (excludedPoolItem?.poolKind === "main" && replacementPoolItem?.poolKind === "reserve") {
+                    actualReceivingSlotId = entry.receivingSlotId;
+                    sealedPoolItemsMatch = excludedPoolItem.candidateClass === replacementPoolItem.candidateClass
+                        && excludedPoolItem.stratum === replacementPoolItem.stratum
+                        && entry.receivingSlotId === excludedPoolItem.slotId;
+                }
+            }
+            else if (excludedPoolItem?.poolKind === "main"
+                && replacementPoolItem?.poolKind === "reserve"
+                && "slotId" in excludedPoolItem
+                && "slotId" in replacementPoolItem) {
+                actualReceivingSlotId = excludedPoolItem.slotId;
+                sealedPoolItemsMatch = excludedPoolItem.slotId === replacementPoolItem.slotId
+                    && entry.receivingSlotId === undefined;
+            }
+            if (!sealedPoolItemsMatch
+                || entry.excludedPoolPosition !== excludedPoolItem?.poolPosition
+                || entry.replacementPoolPosition !== replacementPoolItem?.poolPosition
+                || expected?.replacementItemSha256 !== entry.replacementItemSha256
+                || expected.receivingSlotId !== actualReceivingSlotId)
+                fail(path, "ledger does not name the deterministic first-admissible reserve and its receiving slot at the exact sealed positions");
+        }
         // Branches on admission mode (spec §6.4, §6.5 check (4); ratified resolution to G-1): a
         // screened exclusion is verified against the screening table's own per-row admission rule
         // rather than against two signed reviews. §6.9 deliberately DROPS the four per-item two-human
@@ -650,8 +816,15 @@ export function verifyBinaryJudgmentAdmissionClosure(input, ports) {
             stratum: entry.stratum,
             reason: entry.reason,
             replacementItemSha256: prefixed(entry.replacementItemSha256),
+            ...(entry.receivingSlotId === undefined ? {} : { receivingSlotId: entry.receivingSlotId }),
         });
     }
+    if (promptedScreeningPool !== undefined) {
+        const ledgerReplacements = new Map(ledger.entries.map((entry) => [entry.excludedItemSha256, entry.replacementItemSha256]));
+        if (ledgerReplacements.size !== promptedExpectedReplacements.size || [...promptedExpectedReplacements].some(([excludedItem, expected]) => ledgerReplacements.get(excludedItem) !== expected.replacementItemSha256)) {
+            fail("replacementLedger.entries", "ledger does not exactly cover every prompted main-slot replacement");
+        }
+    }
     // (0) Coverage, the other half (spec §6.5 check (0)): the table's rows must cover the frozen
     // bank's candidate pool EXACTLY. The pool itself is not a separate input to this function --
     // it is reconstructed as accepted ∪ excluded, the closure's own admission decision, which by
@@ -659,7 +832,7 @@ export function verifyBinaryJudgmentAdmissionClosure(input, ports) {
     // with a same-class same-stratum replacement, and every replacement is itself an admitted pool
     // member). `sampleSize <= rows.length` (check (0)'s other clause) is enforced transitively:
     // `computeScreeningSample` above refuses a `sampleSize` exceeding the pool size on its own.
-    if (manifest.truthAdmission === "screened-operator-sampled") {
+    if (manifest.truthAdmission === "screened-operator-sampled" && promptedScreeningPool === undefined) {
         if (screeningTable === undefined) {
             // Unreachable today: the screened arm resolves the table before any row is admitted and fails
             // closed when it is absent. Written as a refusal anyway, because the `&& screeningTable !==
@@ -705,5 +878,13 @@ export function verifyBinaryJudgmentAdmissionClosure(input, ports) {
                 instrumentSha256: screeningInstrumentSha256,
             },
         }),
+        ...(screeningSampleAgreementRate === undefined || promptedScreeningProcedureSha256 === undefined ? {} : {
+            promptedScreening: {
+                sampleAgreementRate: screeningSampleAgreementRate,
+                procedureSha256: promptedScreeningProcedureSha256,
+                profile: PROMPTED_SCREENING_PROFILE,
+                capabilityBoundary: PROMPTED_SCREENING_CAPABILITY_BOUNDARY,
+            },
+        }),
     };
 }

package/dist/assets.d.ts

@@ -10,7 +10,12 @@ export interface PublicAssetInput {
     /** Canonically sorted identities for every authenticated `records/<sha>.bin` closure member. */
     readonly recordSha256s: readonly string[];
     readonly dissentCellKeys: readonly string[];
-    /** Verifier-derived, authenticated human projection. Absent only for legacy bundle assets. */
+    /**
+     * Verifier-derived, authenticated human projection. Absent only for the
+     * qualification-projecting profile (`benchmark-product-public-bundle/4`, `/7`, and `/8`), which
+     * carries `binaryQualification` instead. There is no third, comparison-free profile: a
+     * bundle rendered with neither field is refused at verification (issue #2984).
+     */
     readonly comparison?: PublicComparisonView;
     /** Producer-verified binary admission/instrument facts. Required for claim-package/2 only. */
     readonly binaryQualification?: {
@@ -26,6 +31,21 @@ export interface PublicAssetInput {
         }[];
     };
 }
+/**
+ * The six-variable disclosure table (issue #2839, ruling Q4: the bundle's own `index.html` and
+ * `README.md` are S2's; the site template is packet R1's).
+ *
+ * Rendered from `claim.disclosure` — a verified fact the claim already carries — so this hangs off
+ * the REPORT/claim facts rather than off a format test, and every bundle without a declaration
+ * renders byte-identically to what it rendered before this section existed.
+ *
+ * `measured-here` and `disclosed-by-publisher` are kept visually distinct and are never merged into
+ * one list: the whole point of the record is that a reader can tell at a glance which variables this
+ * venue proved and which it only carries. Nothing here counts, scores, or ranks the statuses (design
+ * §8), and there is no explanatory caption — the status token and the statement are the content.
+ */
+export declare function disclosureSpecificationHtml(input: PublicAssetInput): string;
+export declare function disclosureSpecificationMarkdown(input: PublicAssetInput): string;
 export declare function binaryAdmissionHtml(input: PublicAssetInput): string;
 export declare function binaryAdmissionMarkdown(input: PublicAssetInput): string;
 /** Fixed, deterministic public-bundle/2 presentation bytes. The builder only projects already

package/dist/assets.js

@@ -1,4 +1,4 @@
-import { BENCHMARKING_METHOD_IDS } from "@jinn-network/benchmarking-records";
+import { BENCHMARKING_METHOD_IDS, DISCLOSURE_VARIABLE_KEYS } from "@jinn-network/benchmarking-records";
 import { validateBinaryInstrumentQualificationProjection } from "@jinn-network/benchmarking-aggregate";
 import { canonicalJsonBytes } from "@jinn-network/trust-core";
 import { readFileSync } from "node:fs";
@@ -450,6 +450,57 @@ function publicationGradeWording(truthAdmission) {
         }
     }
 }
+/**
+ * The six-variable disclosure table (issue #2839, ruling Q4: the bundle's own `index.html` and
+ * `README.md` are S2's; the site template is packet R1's).
+ *
+ * Rendered from `claim.disclosure` — a verified fact the claim already carries — so this hangs off
+ * the REPORT/claim facts rather than off a format test, and every bundle without a declaration
+ * renders byte-identically to what it rendered before this section existed.
+ *
+ * `measured-here` and `disclosed-by-publisher` are kept visually distinct and are never merged into
+ * one list: the whole point of the record is that a reader can tell at a glance which variables this
+ * venue proved and which it only carries. Nothing here counts, scores, or ranks the statuses (design
+ * §8), and there is no explanatory caption — the status token and the statement are the content.
+ */
+export function disclosureSpecificationHtml(input) {
+    const disclosure = input.claim.disclosure;
+    if (disclosure === undefined)
+        return "";
+    const rows = DISCLOSURE_VARIABLE_KEYS.map((key) => {
+        const entry = disclosure.variables[key];
+        const detail = entry.status === "undisclosed"
+            ? `<p class="disclosure-reason">${escapeMarkup(entry.reason)}</p>`
+            : `<p class="disclosure-statement">${escapeMarkup(entry.statement)}</p>`;
+        const sources = entry.status === "disclosed-by-publisher" && entry.sources !== undefined
+            ? `<ul class="disclosure-sources">${entry.sources.map((source) => `<li>${escapeMarkup(source.uri)}</li>`).join("")}</ul>`
+            : "";
+        const evidence = entry.status === "measured-here"
+            ? `<ul class="disclosure-evidence">${entry.evidence.map((citation) => `<li><span class="role">${escapeMarkup(citation.role)}</span> <span class="digest">${escapeMarkup(citation.digest.sha256)}</span></li>`).join("")}</ul>`
+            : "";
+        return `<div class="disclosure-variable disclosure-${escapeMarkup(entry.status)}"><dt>${escapeMarkup(key)}</dt><dd><span class="disclosure-status">${escapeMarkup(entry.status)}</span>${detail}${sources}${evidence}</dd></div>`;
+    }).join("");
+    return `<section id="disclosure-specification" aria-labelledby="disclosure-specification-heading"><h2 id="disclosure-specification-heading">Six-variable disclosure</h2><dl class="facts disclosure">${rows}</dl><p class="digest">${escapeMarkup(disclosure.specification)} · record ${escapeMarkup(disclosure.recordSha256)} · subject ${escapeMarkup(disclosure.subjectSha256)}</p></section>`;
+}
+export function disclosureSpecificationMarkdown(input) {
+    const disclosure = input.claim.disclosure;
+    if (disclosure === undefined)
+        return "";
+    const rows = DISCLOSURE_VARIABLE_KEYS.map((key) => {
+        const entry = disclosure.variables[key];
+        const detail = entry.status === "undisclosed"
+            ? `\n  - ${escapeMarkdown(entry.reason)}`
+            : `\n  - ${escapeMarkdown(entry.statement)}`;
+        const sources = entry.status === "disclosed-by-publisher" && entry.sources !== undefined
+            ? entry.sources.map((source) => `\n  - source: ${escapeMarkdown(source.uri)}`).join("")
+            : "";
+        const evidence = entry.status === "measured-here"
+            ? entry.evidence.map((citation) => `\n  - ${escapeMarkdown(citation.role)}: ${escapeMarkdown(citation.digest.sha256)}`).join("")
+            : "";
+        return `- ${escapeMarkdown(key)}: ${escapeMarkdown(entry.status)}${detail}${sources}${evidence}`;
+    }).join("\n");
+    return `## Six-variable disclosure\n\n${rows}\n\n- ${escapeMarkdown(disclosure.specification)}\n- record: ${escapeMarkdown(disclosure.recordSha256)}\n- subject: ${escapeMarkdown(disclosure.subjectSha256)}\n\n`;
+}
 export function binaryAdmissionHtml(input) {
     const admission = input.binaryQualification;
     if (admission === undefined)
@@ -493,6 +544,12 @@ function neutralClaimHtml(facts) {
     }
     return '<p class="neutral">Verified binary-instrument qualification. Facts are presented per instrument without comparative conclusions.</p>';
 }
+// Task-selection provenance (issue #2980) is sealed into the Run and verified under
+// `claim-consistency`, but deliberately renders NOTHING here, and no asset below projects it.
+// The classic and anchored allocations pin `@colophon-claims/verify@0.1.0`, whose
+// `verifyPublicBundleSnapshot` byte-compares every presentation asset against its own rebuild, so
+// a bundle that rendered the sentence would carry an instruction to run a verifier that refuses
+// it. Restoring the render is issue #3416, once the reader line that derives it is re-pinned.
 function buildIndex(input, reportFacts, claimFacts) {
     const outcome = input.matrix.completeness.runOutcome;
     const status = reportFacts.kind === "binary" ? qualificationOutcomeLabel(outcome) : outcomeLabel(outcome);
@@ -543,7 +600,7 @@ ${neutralClaimHtml(reportFacts)}
 </header>
 <main>
 <section class="adverse" aria-labelledby="adverse-heading"><h2 id="adverse-heading">Prominent adverse facts</h2>${list(adverse, "No adverse facts stated.")}</section>${input.comparison === undefined ? "" : `\n${comparisonSectionHtml(input.comparison)}`}
-<section aria-labelledby="scope-heading"><h2 id="scope-heading">Benchmark and configuration scope</h2><dl class="facts"><div><dt>Benchmark digest</dt><dd class="digest">${input.claim.scope.benchmarkSha256}</dd></div><div><dt>Tasks</dt><dd>${input.claim.scope.taskCount}</dd></div><div><dt>Replicates</dt><dd>${input.claim.scope.replicates}</dd></div><div><dt>Venue</dt><dd>${escapeMarkup(input.claim.scope.venue)}</dd></div></dl><h3>Arms and pinned configuration</h3><ul>${arms}</ul></section>${reportFacts.kind === "binary" ? binaryAdmissionHtml(input) : ""}
+<section aria-labelledby="scope-heading"><h2 id="scope-heading">Benchmark and configuration scope</h2><dl class="facts"><div><dt>Benchmark digest</dt><dd class="digest">${input.claim.scope.benchmarkSha256}</dd></div><div><dt>Tasks</dt><dd>${input.claim.scope.taskCount}</dd></div><div><dt>Replicates</dt><dd>${input.claim.scope.replicates}</dd></div><div><dt>Venue</dt><dd>${escapeMarkup(input.claim.scope.venue)}</dd></div></dl><h3>Arms and pinned configuration</h3><ul>${arms}</ul></section>${reportFacts.kind === "binary" ? binaryAdmissionHtml(input) : ""}${disclosureSpecificationHtml(input)}
 <section aria-labelledby="matrix-heading"><h2 id="matrix-heading">Sealed Matrix accounting</h2><p class="source-label">Source: authenticated <a href="matrix.json">matrix.json</a>; values below are copied without reconciliation.</p><pre>${escapeMarkup(canonicalText({ completeness: input.matrix.completeness, attrition: input.matrix.attrition }))}</pre><h3>Completeness and attrition</h3><dl class="facts"><div><dt>Matrix run outcome</dt><dd>${escapeMarkup(outcome)}</dd></div><div><dt>Matrix expected</dt><dd>${input.matrix.completeness.expected}</dd></div><div><dt>Matrix judged</dt><dd>${input.matrix.completeness.judged}</dd></div><div><dt>Matrix floor</dt><dd>${escapeMarkup(input.matrix.completeness.floor)}</dd></div></dl><div class="table-scroll" tabindex="0" role="region" aria-label="Per-arm Matrix attrition"><table><caption>Exact per-arm attrition stored in the Matrix</caption><thead><tr><th scope="col">Arm</th><th scope="col">Expected</th><th scope="col">Judged</th><th scope="col">Unjudged</th><th scope="col">Unscorable</th><th scope="col">Expired</th><th scope="col">Invalidated</th><th scope="col">Excluded</th><th scope="col">Replacements</th></tr></thead><tbody>${attritionRows(input)}</tbody></table></div><h3>Matrix asymmetry flags</h3>${list(input.matrix.attrition.asymmetryFlags, "None recorded in the Matrix.")}</section>
 <section aria-labelledby="report-heading"><h2 id="report-heading">Sealed Report facts</h2><p class="source-label">Source: authenticated <a href="report.json">report.json</a>; values below are copied without reconciliation.</p><h3>${factsHeading(reportFacts, "report")}</h3>${armResultsHtml(reportFacts, "Exact wilson@1 values from the sealed Report")}<h3>Method and assurance facts stored in the Report</h3><dl class="facts"><div><dt>Report method</dt><dd>${escapeMarkup(input.report.method.id)} @ ${escapeMarkup(input.report.method.version)}</dd></div><div><dt>Report preregistered</dt><dd>${input.report.preregistered === true ? "Yes" : "No"}</dd></div></dl><h3>Report parameters</h3><pre>${escapeMarkup(canonicalText(input.report.method.parameters))}</pre><h3>Report conflicts</h3><pre>${escapeMarkup(canonicalText(reportFacts.conflicted))}</pre><h3>Report disclosures</h3><pre>${escapeMarkup(canonicalText(input.report.disclosures))}</pre></section>
 <section aria-labelledby="claim-heading"><h2 id="claim-heading">Stored Claim facts</h2><p class="source-label">Source: authenticated <a href="claim-package.json">claim-package.json</a>; values below are copied without reconciliation.</p><h3>${factsHeading(claimFacts, "claim")}</h3>${armResultsHtml(claimFacts, "Exact arm values stored in the Claim package")}<h3>Claim method and preregistration</h3><dl class="facts"><div><dt>Claim method</dt><dd>${escapeMarkup(input.claim.method.id)} @ ${escapeMarkup(input.claim.method.version)}</dd></div><div><dt>Claim preregistered</dt><dd>${input.claim.method.preregistered ? "Yes" : "No"}</dd></div><div><dt>Assurance preset</dt><dd>${escapeMarkup(input.claim.assurance.preset)}</dd></div></dl><h3>Claim parameters</h3><pre>${escapeMarkup(canonicalText(input.claim.method.parameters))}</pre><h3>Claim completeness</h3><pre>${escapeMarkup(canonicalText(input.claim.completeness))}</pre><h3>Claim attrition</h3><pre>${escapeMarkup(canonicalText(input.claim.attrition))}</pre><h3>Claim conflicts</h3><pre>${escapeMarkup(canonicalText(input.claim.conflicted))}</pre><h3>Claim disclosures</h3><h4>Unverifiable axes, integrity tiers, and per-subject disclosures</h4><pre>${escapeMarkup(canonicalText(input.claim.disclosures))}</pre><h3>Resolved assurance primitives</h3><pre>${escapeMarkup(canonicalText(input.claim.assurance.resolved))}</pre><p>${escapeMarkup(input.claim.assurance.disclosure)}</p><h3>Rehearsal disclosure</h3>${rehearsalHtml}</section>
@@ -749,7 +806,7 @@ ${adverse.map((value) => `- ${escapeMarkdown(value)}`).join("\n")}
 
 ## Configurations
 
-${arms}${reportFacts.kind === "binary" ? `\n\n${binaryAdmissionMarkdown(input).trimEnd()}` : ""}
+${arms}${reportFacts.kind === "binary" ? `\n\n${binaryAdmissionMarkdown(input).trimEnd()}` : ""}${input.claim.disclosure === undefined ? "" : `\n\n${disclosureSpecificationMarkdown(input).trimEnd()}`}
 
 ## Sealed Matrix accounting