@colophon-claims/verify 0.2.0 → 0.2.1

package/README.md

@@ -8,17 +8,27 @@ npx @colophon-claims/verify@0.2 ./bundle
 
 Use `--json` for machine-readable output. The reader runs the checks declared by the
 bundle format, covering its manifest, evidence closure, calculations, report, and claim
-consistency. Exit status is `0` when every check passes, `1` for an invalid bundle, and
-`2` for usage or operational failures.
-
-This 0.2 reader supports public bundle formats v2, v4, v5, and v6. It intentionally
-rejects the unrelated accounting bundle v3. Formats v2 and v4 run six checks; the
-evidence-native v5 and anchored v6 formats run seven.
+consistency. Exit status is `0` when the bundle is valid for the format and profile it
+declares, `1` for an invalid bundle, and `2` for usage or operational failures. A check a
+profile defers is reported as deferred, never as passed, and never as a failure.
+
+This 0.2 reader supports public bundle formats v2, v4, v5, v6, v7, and v8. It
+intentionally rejects the unrelated accounting bundle v3. Formats v2 and v4 run six
+checks; the evidence-native v5 and the two anchored formats, v6 and v7, run seven; the
+disclosed v8 runs eight. The v7 format is the anchored binary-qualification closure —
+v4's members plus v6's anchors — and v8 is v7 plus a sealed six-variable
+disclosure-specification record and the `disclosure-specification` check. Both exist
+only from this 0.2.1 release, so their bundles pin `@0.2.1` rather than the `@0.1` line
+every earlier closure stamps.
+The evidence-native v5 has two declared profiles, full-evidence and metadata-first;
+this reader supports both. A metadata-first bundle carries the artifact digests without
+the artifact bodies, so `artifact-integrity` reports `not fetched` rather than passing,
+and the verdict line counts it out of the passed total. Every other check is complete.
 Existing claim bundles retain their recorded verifier pins. Use this 0.2 reader
 for prompted-screening v2 support and the compatible `@0.2` line for this
 release.
-For this one-time prompted-screening v2 release, `@jinn-network/*` is pinned to
-the exact `0.1.0-canary.sha.e00b2fc47fc5635b007eb349fb1e41aa81bb3c50` receipt.
+For this release, `@jinn-network/*` is pinned to the exact
+`0.1.0-canary.sha.0533a224cf99f06d7facf0c23455f2781a5b9e62` receipt.
 It is not a floating `@canary` dependency and is not a stable stack release.
 
 Verification opens no network connection, reads no account or API credential, and uploads

package/dist/admission/contracts.d.ts

@@ -10,7 +10,10 @@ export declare const BINARY_JUDGMENT_ADMISSION_MANIFEST_PROTOCOL: "https://spec.
 export declare const SCREENING_TABLE_PROTOCOL: "https://spec.jinn.network/binary-judgment/screening-table/v1";
 export declare const PROMPTED_SCREENING_PROCEDURE_PROTOCOL: "https://spec.jinn.network/binary-judgment/prompted-screening-procedure/v1";
 export declare const SCREENING_POOL_PROTOCOL: "https://spec.jinn.network/binary-judgment/screening-pool/v1";
+export declare const SCREENING_POOL_V2_PROTOCOL: "https://spec.jinn.network/binary-judgment/screening-pool/v2";
+export declare const SCREENING_POOL_V2_RESERVE_SELECTION_PROTOCOL: "shared-slice-first-admissible/1";
 export declare const SCREENING_SAMPLE_COMMITMENT_PROTOCOL: "https://spec.jinn.network/binary-judgment/screening-sample-commitment/v1";
+export declare const REGISTERED_SCREENING_SAMPLE_COMMITMENT_V1_SCHEMA: "https://colophon-claims.github.io/locomo-judge-report/sampling-commitment/v1";
 export declare const SCREENING_TABLE_V2_PROTOCOL: "https://spec.jinn.network/binary-judgment/screening-table/v2";
 export declare const SCREENING_REVEAL_RECEIPT_PROTOCOL: "https://spec.jinn.network/binary-judgment/screening-reveal-receipt/v1";
 export declare const HUMAN_REVIEW_PACKET_MEDIA_TYPE: "application/vnd.jinn.binary-judgment.human-review-packet.v1+json";
@@ -337,6 +340,206 @@ export declare const ScreeningPoolV1Schema: z.ZodObject<{
     sealedAt: z.ZodString;
 }, z.core.$strict>;
 export type ScreeningPoolV1 = z.infer<typeof ScreeningPoolV1Schema>;
+export declare const ScreeningPoolV2ItemSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    screeningIdentitySha256: z.ZodString;
+    itemSha256: z.ZodString;
+    intendedLabel: z.ZodEnum<{
+        CORRECT: "CORRECT";
+        WRONG: "WRONG";
+    }>;
+    candidateClass: z.ZodEnum<{
+        correct: "correct";
+        "specific-wrong": "specific-wrong";
+        "vague-topical-wrong": "vague-topical-wrong";
+    }>;
+    stratum: z.ZodEnum<{
+        "category-1": "category-1";
+        "category-2": "category-2";
+        "category-3": "category-3";
+        "category-4": "category-4";
+    }>;
+    poolPosition: z.ZodNumber;
+    sourceQuestionLineageId: z.ZodString;
+    poolKind: z.ZodLiteral<"main">;
+    slotId: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    screeningIdentitySha256: z.ZodString;
+    itemSha256: z.ZodString;
+    intendedLabel: z.ZodEnum<{
+        CORRECT: "CORRECT";
+        WRONG: "WRONG";
+    }>;
+    candidateClass: z.ZodEnum<{
+        correct: "correct";
+        "specific-wrong": "specific-wrong";
+        "vague-topical-wrong": "vague-topical-wrong";
+    }>;
+    stratum: z.ZodEnum<{
+        "category-1": "category-1";
+        "category-2": "category-2";
+        "category-3": "category-3";
+        "category-4": "category-4";
+    }>;
+    poolPosition: z.ZodNumber;
+    sourceQuestionLineageId: z.ZodString;
+    poolKind: z.ZodLiteral<"reserve">;
+    reserveOrder: z.ZodNumber;
+}, z.core.$strict>], "poolKind">;
+export type ScreeningPoolV2Item = z.infer<typeof ScreeningPoolV2ItemSchema>;
+/** A 240-main pool whose reserves are ordered shared slices within each class/stratum cell. */
+export declare const ScreeningPoolV2Schema: z.ZodObject<{
+    protocol: z.ZodLiteral<"https://spec.jinn.network/binary-judgment/screening-pool/v2">;
+    reserveSelectionProtocol: z.ZodLiteral<"shared-slice-first-admissible/1">;
+    draftId: z.ZodString;
+    identityCommitmentSha256: z.ZodString;
+    items: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        screeningIdentitySha256: z.ZodString;
+        itemSha256: z.ZodString;
+        intendedLabel: z.ZodEnum<{
+            CORRECT: "CORRECT";
+            WRONG: "WRONG";
+        }>;
+        candidateClass: z.ZodEnum<{
+            correct: "correct";
+            "specific-wrong": "specific-wrong";
+            "vague-topical-wrong": "vague-topical-wrong";
+        }>;
+        stratum: z.ZodEnum<{
+            "category-1": "category-1";
+            "category-2": "category-2";
+            "category-3": "category-3";
+            "category-4": "category-4";
+        }>;
+        poolPosition: z.ZodNumber;
+        sourceQuestionLineageId: z.ZodString;
+        poolKind: z.ZodLiteral<"main">;
+        slotId: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        screeningIdentitySha256: z.ZodString;
+        itemSha256: z.ZodString;
+        intendedLabel: z.ZodEnum<{
+            CORRECT: "CORRECT";
+            WRONG: "WRONG";
+        }>;
+        candidateClass: z.ZodEnum<{
+            correct: "correct";
+            "specific-wrong": "specific-wrong";
+            "vague-topical-wrong": "vague-topical-wrong";
+        }>;
+        stratum: z.ZodEnum<{
+            "category-1": "category-1";
+            "category-2": "category-2";
+            "category-3": "category-3";
+            "category-4": "category-4";
+        }>;
+        poolPosition: z.ZodNumber;
+        sourceQuestionLineageId: z.ZodString;
+        poolKind: z.ZodLiteral<"reserve">;
+        reserveOrder: z.ZodNumber;
+    }, z.core.$strict>], "poolKind">>;
+    sealedAt: z.ZodString;
+}, z.core.$strict>;
+export type ScreeningPoolV2 = z.infer<typeof ScreeningPoolV2Schema>;
+export declare const ScreeningPoolSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    protocol: z.ZodLiteral<"https://spec.jinn.network/binary-judgment/screening-pool/v1">;
+    draftId: z.ZodString;
+    identityCommitmentSha256: z.ZodString;
+    items: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        itemSha256: z.ZodString;
+        intendedLabel: z.ZodEnum<{
+            CORRECT: "CORRECT";
+            WRONG: "WRONG";
+        }>;
+        candidateClass: z.ZodEnum<{
+            correct: "correct";
+            "specific-wrong": "specific-wrong";
+            "vague-topical-wrong": "vague-topical-wrong";
+        }>;
+        stratum: z.ZodEnum<{
+            "category-1": "category-1";
+            "category-2": "category-2";
+            "category-3": "category-3";
+            "category-4": "category-4";
+        }>;
+        poolPosition: z.ZodNumber;
+        slotId: z.ZodString;
+        poolKind: z.ZodLiteral<"main">;
+    }, z.core.$strict>, z.ZodObject<{
+        itemSha256: z.ZodString;
+        intendedLabel: z.ZodEnum<{
+            CORRECT: "CORRECT";
+            WRONG: "WRONG";
+        }>;
+        candidateClass: z.ZodEnum<{
+            correct: "correct";
+            "specific-wrong": "specific-wrong";
+            "vague-topical-wrong": "vague-topical-wrong";
+        }>;
+        stratum: z.ZodEnum<{
+            "category-1": "category-1";
+            "category-2": "category-2";
+            "category-3": "category-3";
+            "category-4": "category-4";
+        }>;
+        poolPosition: z.ZodNumber;
+        slotId: z.ZodString;
+        poolKind: z.ZodLiteral<"reserve">;
+        reserveOrder: z.ZodNumber;
+    }, z.core.$strict>], "poolKind">>;
+    sealedAt: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    protocol: z.ZodLiteral<"https://spec.jinn.network/binary-judgment/screening-pool/v2">;
+    reserveSelectionProtocol: z.ZodLiteral<"shared-slice-first-admissible/1">;
+    draftId: z.ZodString;
+    identityCommitmentSha256: z.ZodString;
+    items: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        screeningIdentitySha256: z.ZodString;
+        itemSha256: z.ZodString;
+        intendedLabel: z.ZodEnum<{
+            CORRECT: "CORRECT";
+            WRONG: "WRONG";
+        }>;
+        candidateClass: z.ZodEnum<{
+            correct: "correct";
+            "specific-wrong": "specific-wrong";
+            "vague-topical-wrong": "vague-topical-wrong";
+        }>;
+        stratum: z.ZodEnum<{
+            "category-1": "category-1";
+            "category-2": "category-2";
+            "category-3": "category-3";
+            "category-4": "category-4";
+        }>;
+        poolPosition: z.ZodNumber;
+        sourceQuestionLineageId: z.ZodString;
+        poolKind: z.ZodLiteral<"main">;
+        slotId: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        screeningIdentitySha256: z.ZodString;
+        itemSha256: z.ZodString;
+        intendedLabel: z.ZodEnum<{
+            CORRECT: "CORRECT";
+            WRONG: "WRONG";
+        }>;
+        candidateClass: z.ZodEnum<{
+            correct: "correct";
+            "specific-wrong": "specific-wrong";
+            "vague-topical-wrong": "vague-topical-wrong";
+        }>;
+        stratum: z.ZodEnum<{
+            "category-1": "category-1";
+            "category-2": "category-2";
+            "category-3": "category-3";
+            "category-4": "category-4";
+        }>;
+        poolPosition: z.ZodNumber;
+        sourceQuestionLineageId: z.ZodString;
+        poolKind: z.ZodLiteral<"reserve">;
+        reserveOrder: z.ZodNumber;
+    }, z.core.$strict>], "poolKind">>;
+    sealedAt: z.ZodString;
+}, z.core.$strict>], "protocol">;
+export type ScreeningPool = z.infer<typeof ScreeningPoolSchema>;
 export declare const ScreeningSampleCommitmentV1Schema: z.ZodObject<{
     protocol: z.ZodLiteral<"https://spec.jinn.network/binary-judgment/screening-sample-commitment/v1">;
     draftId: z.ZodString;
@@ -349,6 +552,42 @@ export declare const ScreeningSampleCommitmentV1Schema: z.ZodObject<{
     committedAt: z.ZodString;
 }, z.core.$strict>;
 export type ScreeningSampleCommitmentV1 = z.infer<typeof ScreeningSampleCommitmentV1Schema>;
+/**
+ * Exact public identity-only commitments made by an external registration repository. Unlike the
+ * internal v1 envelope, this record deliberately does not claim that the later label-bearing pool
+ * bridge existed at registration time. Its sorted identities, product-defined pool digest, seed,
+ * sample size, script digest, and timestamp are sufficient to replay the committed sample.
+ */
+export declare const RegisteredScreeningSampleCommitmentV1Schema: z.ZodObject<{
+    schema: z.ZodLiteral<"https://colophon-claims.github.io/locomo-judge-report/sampling-commitment/v1">;
+    candidateItemDigests: z.ZodArray<z.ZodString>;
+    committedAt: z.ZodString;
+    poolDigest: z.ZodString;
+    sampleSeed: z.ZodString;
+    sampleSize: z.ZodLiteral<72>;
+    samplingScriptSha256: z.ZodString;
+}, z.core.$strict>;
+export type RegisteredScreeningSampleCommitmentV1 = z.infer<typeof RegisteredScreeningSampleCommitmentV1Schema>;
+export declare const ScreeningSampleCommitmentSchema: z.ZodUnion<readonly [z.ZodObject<{
+    protocol: z.ZodLiteral<"https://spec.jinn.network/binary-judgment/screening-sample-commitment/v1">;
+    draftId: z.ZodString;
+    poolSha256: z.ZodString;
+    poolIdentityCommitmentSha256: z.ZodString;
+    samplingProcedure: z.ZodLiteral<"screening-sample/1">;
+    sampleSeed: z.ZodString;
+    sampleSize: z.ZodLiteral<72>;
+    sampleItemSha256s: z.ZodArray<z.ZodString>;
+    committedAt: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    schema: z.ZodLiteral<"https://colophon-claims.github.io/locomo-judge-report/sampling-commitment/v1">;
+    candidateItemDigests: z.ZodArray<z.ZodString>;
+    committedAt: z.ZodString;
+    poolDigest: z.ZodString;
+    sampleSeed: z.ZodString;
+    sampleSize: z.ZodLiteral<72>;
+    samplingScriptSha256: z.ZodString;
+}, z.core.$strict>]>;
+export type ScreeningSampleCommitment = z.infer<typeof ScreeningSampleCommitmentSchema>;
 export declare const PromptedScreeningRowV2Schema: z.ZodObject<{
     itemSha256: z.ZodString;
     intendedLabel: z.ZodEnum<{
@@ -443,6 +682,7 @@ export declare const HumanReviewReplacementLedgerEntrySchema: z.ZodObject<{
         "screening-indeterminate": "screening-indeterminate";
         "screening-hand-excluded": "screening-hand-excluded";
     }>;
+    receivingSlotId: z.ZodOptional<z.ZodString>;
     reviewVerdictSha256s: z.ZodOptional<z.ZodTuple<[z.ZodString, z.ZodString], null>>;
     visibilityReceiptSha256s: z.ZodOptional<z.ZodTuple<[z.ZodString, z.ZodString], null>>;
     reviewerRosterSha256: z.ZodOptional<z.ZodString>;
@@ -466,6 +706,7 @@ export declare const HumanReviewReplacementLedgerSchema: z.ZodObject<{
             "screening-indeterminate": "screening-indeterminate";
             "screening-hand-excluded": "screening-hand-excluded";
         }>;
+        receivingSlotId: z.ZodOptional<z.ZodString>;
         reviewVerdictSha256s: z.ZodOptional<z.ZodTuple<[z.ZodString, z.ZodString], null>>;
         visibilityReceiptSha256s: z.ZodOptional<z.ZodTuple<[z.ZodString, z.ZodString], null>>;
         reviewerRosterSha256: z.ZodOptional<z.ZodString>;

package/dist/admission/contracts.js

@@ -13,7 +13,10 @@ export const BINARY_JUDGMENT_ADMISSION_MANIFEST_PROTOCOL = "https://spec.jinn.ne
 export const SCREENING_TABLE_PROTOCOL = "https://spec.jinn.network/binary-judgment/screening-table/v1";
 export const PROMPTED_SCREENING_PROCEDURE_PROTOCOL = "https://spec.jinn.network/binary-judgment/prompted-screening-procedure/v1";
 export const SCREENING_POOL_PROTOCOL = "https://spec.jinn.network/binary-judgment/screening-pool/v1";
+export const SCREENING_POOL_V2_PROTOCOL = "https://spec.jinn.network/binary-judgment/screening-pool/v2";
+export const SCREENING_POOL_V2_RESERVE_SELECTION_PROTOCOL = "shared-slice-first-admissible/1";
 export const SCREENING_SAMPLE_COMMITMENT_PROTOCOL = "https://spec.jinn.network/binary-judgment/screening-sample-commitment/v1";
+export const REGISTERED_SCREENING_SAMPLE_COMMITMENT_V1_SCHEMA = "https://colophon-claims.github.io/locomo-judge-report/sampling-commitment/v1";
 export const SCREENING_TABLE_V2_PROTOCOL = "https://spec.jinn.network/binary-judgment/screening-table/v2";
 export const SCREENING_REVEAL_RECEIPT_PROTOCOL = "https://spec.jinn.network/binary-judgment/screening-reveal-receipt/v1";
 export const HUMAN_REVIEW_PACKET_MEDIA_TYPE = "application/vnd.jinn.binary-judgment.human-review-packet.v1+json";
@@ -320,6 +323,90 @@ export const ScreeningPoolV1Schema = z.strictObject({
                 ctx.addIssue({ code: "custom", path: ["items"], message: `main pool must contain 20 ${candidateClass}/${stratum} items` });
         }
 });
+const ScreeningPoolV2CommonItemSchema = z.strictObject({
+    /** Privacy-preserving identity committed before screening outcomes were observed. */
+    screeningIdentitySha256: DigestSchema,
+    /** Digest of the exact later Colophon F0 item bytes. */
+    itemSha256: DigestSchema,
+    intendedLabel: BinaryJudgmentTruthLabelSchema,
+    candidateClass: z.enum(SCREENING_POOL_CANDIDATE_CLASSES),
+    stratum: z.enum(SCREENING_POOL_STRATA),
+    poolPosition: z.number().int().positive(),
+    sourceQuestionLineageId: IdentitySchema,
+});
+export const ScreeningPoolV2ItemSchema = z.discriminatedUnion("poolKind", [
+    ScreeningPoolV2CommonItemSchema.extend({
+        poolKind: z.literal("main"),
+        slotId: z.string().regex(/^slot-[0-9]{3}$/u),
+    }),
+    ScreeningPoolV2CommonItemSchema.extend({
+        poolKind: z.literal("reserve"),
+        reserveOrder: z.number().int().positive(),
+    }),
+]);
+/** A 240-main pool whose reserves are ordered shared slices within each class/stratum cell. */
+export const ScreeningPoolV2Schema = z.strictObject({
+    protocol: z.literal(SCREENING_POOL_V2_PROTOCOL),
+    reserveSelectionProtocol: z.literal(SCREENING_POOL_V2_RESERVE_SELECTION_PROTOCOL),
+    draftId: IdentitySchema,
+    identityCommitmentSha256: DigestSchema,
+    items: z.array(ScreeningPoolV2ItemSchema).length(664),
+    sealedAt: TimestampSchema,
+}).superRefine((pool, ctx) => {
+    const identities = new Set();
+    const itemDigests = new Set();
+    const mains = pool.items.filter((item) => item.poolKind === "main");
+    const mainSlots = new Set();
+    const mainLineages = new Set();
+    for (const [index, item] of pool.items.entries()) {
+        if (item.poolPosition !== index + 1)
+            ctx.addIssue({ code: "custom", path: ["items", index, "poolPosition"], message: "poolPosition must be contiguous and match array order" });
+        if (identities.has(item.screeningIdentitySha256))
+            ctx.addIssue({ code: "custom", path: ["items", index, "screeningIdentitySha256"], message: "screeningIdentitySha256 must be unique" });
+        identities.add(item.screeningIdentitySha256);
+        if (itemDigests.has(item.itemSha256))
+            ctx.addIssue({ code: "custom", path: ["items", index, "itemSha256"], message: "itemSha256 must be unique" });
+        itemDigests.add(item.itemSha256);
+        const expectedLabel = item.candidateClass === "correct" ? "CORRECT" : "WRONG";
+        if (item.intendedLabel !== expectedLabel)
+            ctx.addIssue({ code: "custom", path: ["items", index, "intendedLabel"], message: "intendedLabel does not derive from candidateClass" });
+        if (item.poolKind === "main") {
+            if (mainSlots.has(item.slotId))
+                ctx.addIssue({ code: "custom", path: ["items", index, "slotId"], message: "main slotId must be unique" });
+            mainSlots.add(item.slotId);
+            if (mainLineages.has(item.sourceQuestionLineageId))
+                ctx.addIssue({ code: "custom", path: ["items", index, "sourceQuestionLineageId"], message: "main sourceQuestionLineageId must be unique" });
+            mainLineages.add(item.sourceQuestionLineageId);
+        }
+    }
+    if (mains.length !== 240)
+        ctx.addIssue({ code: "custom", path: ["items"], message: "pool must contain exactly 240 main items" });
+    const lastMainPosition = Math.max(...mains.map((item) => item.poolPosition));
+    for (const [index, item] of pool.items.entries()) {
+        if (item.poolKind === "reserve" && item.poolPosition <= lastMainPosition)
+            ctx.addIssue({ code: "custom", path: ["items", index, "poolPosition"], message: "all shared reserves must follow all main items in pool order" });
+    }
+    const expectedSlotIds = Array.from({ length: 240 }, (_, index) => `slot-${(index + 1).toString().padStart(3, "0")}`);
+    const actualSlotIds = [...mainSlots].sort(compareCodeUnitStrings);
+    if (actualSlotIds.length !== expectedSlotIds.length || actualSlotIds.some((value, index) => value !== expectedSlotIds[index]))
+        ctx.addIssue({ code: "custom", path: ["items"], message: "main slots must be exactly slot-001 through slot-240" });
+    for (const candidateClass of SCREENING_POOL_CANDIDATE_CLASSES)
+        for (const stratum of SCREENING_POOL_STRATA) {
+            if (mains.filter((item) => item.candidateClass === candidateClass && item.stratum === stratum).length !== 20)
+                ctx.addIssue({ code: "custom", path: ["items"], message: `main pool must contain 20 ${candidateClass}/${stratum} items` });
+            const reserves = pool.items
+                .filter((item) => item.poolKind === "reserve" && item.candidateClass === candidateClass && item.stratum === stratum)
+                .sort((left, right) => left.reserveOrder - right.reserveOrder);
+            for (const [index, reserve] of reserves.entries()) {
+                if (reserve.reserveOrder !== index + 1)
+                    ctx.addIssue({ code: "custom", path: ["items"], message: `${candidateClass}/${stratum} reserveOrder must be contiguous and unique` });
+            }
+        }
+});
+export const ScreeningPoolSchema = z.discriminatedUnion("protocol", [
+    ScreeningPoolV1Schema,
+    ScreeningPoolV2Schema,
+]);
 export const ScreeningSampleCommitmentV1Schema = z.strictObject({
     protocol: z.literal(SCREENING_SAMPLE_COMMITMENT_PROTOCOL),
     draftId: IdentitySchema,
@@ -336,6 +423,32 @@ export const ScreeningSampleCommitmentV1Schema = z.strictObject({
     }),
     committedAt: TimestampSchema,
 });
+/**
+ * Exact public identity-only commitments made by an external registration repository. Unlike the
+ * internal v1 envelope, this record deliberately does not claim that the later label-bearing pool
+ * bridge existed at registration time. Its sorted identities, product-defined pool digest, seed,
+ * sample size, script digest, and timestamp are sufficient to replay the committed sample.
+ */
+export const RegisteredScreeningSampleCommitmentV1Schema = z.strictObject({
+    schema: z.literal(REGISTERED_SCREENING_SAMPLE_COMMITMENT_V1_SCHEMA),
+    candidateItemDigests: z.array(DigestSchema).length(664),
+    committedAt: TimestampSchema,
+    poolDigest: DigestSchema,
+    sampleSeed: z.string().min(1),
+    sampleSize: z.literal(72),
+    samplingScriptSha256: DigestSchema,
+}).superRefine((commitment, ctx) => {
+    for (let index = 1; index < commitment.candidateItemDigests.length; index += 1) {
+        if (compareCodeUnitStrings(commitment.candidateItemDigests[index - 1], commitment.candidateItemDigests[index]) >= 0) {
+            ctx.addIssue({ code: "custom", path: ["candidateItemDigests"], message: "registered identities must be sorted and unique" });
+            return;
+        }
+    }
+});
+export const ScreeningSampleCommitmentSchema = z.union([
+    ScreeningSampleCommitmentV1Schema,
+    RegisteredScreeningSampleCommitmentV1Schema,
+]);
 const ScreeningDecisionSchema = z.enum(["CORRECT", "WRONG", "UNSURE"]);
 const RitsuScreeningDecisionSchema = z.discriminatedUnion("checked", [
     z.strictObject({ checked: z.literal(false) }),
@@ -396,6 +509,9 @@ export const HumanReviewReplacementLedgerEntrySchema = z.strictObject({
     excludedPoolPosition: z.number().int().positive(),
     replacementPoolPosition: z.number().int().positive(),
     reason: z.enum([...HUMAN_REVIEW_LEDGER_REASONS, ...SCREENING_LEDGER_REASONS]),
+    // Required by closure replay for shared-slice pool/v2 replacements. It names the main slot that
+    // receives the reserve; the reserve itself carries no static slot ownership.
+    receivingSlotId: z.string().regex(/^slot-[0-9]{3}$/u).optional(),
     // Per-item two-human apparatus (spec §6.9 deliberately drops it for the screened branch):
     // present if and only if `reason` is one of the three two-human reasons above.
     reviewVerdictSha256s: SortedUniqueDigestPairSchema.optional(),

package/dist/admission/index.d.ts

@@ -1,5 +1,7 @@
 export * from "./application.js";
 export * from "./contracts.js";
 export * from "./intake.js";
+export * from "./prompted-selection.js";
+export * from "./prompted-commitment.js";
 export * from "./screening-sample.js";
 export * from "./verification.js";

package/dist/admission/index.js

@@ -1,5 +1,7 @@
 export * from "./application.js";
 export * from "./contracts.js";
 export * from "./intake.js";
+export * from "./prompted-selection.js";
+export * from "./prompted-commitment.js";
 export * from "./screening-sample.js";
 export * from "./verification.js";

package/dist/admission/prompted-commitment.d.ts

@@ -0,0 +1,19 @@
+import { type ScreeningSampleCommitment } from "./contracts.js";
+export interface PromptedScreeningCommitmentView {
+    readonly committedAt: string;
+    readonly poolIdentityCommitmentSha256: string;
+    readonly sampleSeed: string;
+    readonly sampleSize: 72;
+    readonly registeredIdentitySha256s?: readonly string[];
+    readonly samplingScriptSha256?: string;
+    readonly sampleItemSha256s?: readonly string[];
+    readonly draftId?: string;
+    readonly poolSha256?: string;
+}
+/**
+ * Parse the two exact wire encodings. Internal Colophon envelopes use bare canonical JSON;
+ * external registration files use the canonical one-record JSONL form with exactly one final LF.
+ */
+export declare function parseScreeningSampleCommitmentBytes(bytes: Uint8Array): ScreeningSampleCommitment;
+/** Normalize the original internal envelope and exact external registration shape for replay. */
+export declare function promptedScreeningCommitmentView(commitment: ScreeningSampleCommitment): PromptedScreeningCommitmentView;

package/dist/admission/prompted-commitment.js

@@ -0,0 +1,52 @@
+// SPDX-License-Identifier: Apache-2.0
+import { canonicalJsonBytes } from "@jinn-network/task-execution-profiles";
+import { ScreeningSampleCommitmentSchema, } from "./contracts.js";
+function sameBytes(left, right) {
+    return left.byteLength === right.byteLength && left.every((byte, index) => byte === right[index]);
+}
+/**
+ * Parse the two exact wire encodings. Internal Colophon envelopes use bare canonical JSON;
+ * external registration files use the canonical one-record JSONL form with exactly one final LF.
+ */
+export function parseScreeningSampleCommitmentBytes(bytes) {
+    let input;
+    try {
+        input = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes));
+    }
+    catch {
+        throw new TypeError("screening sample commitment is not UTF-8 JSON");
+    }
+    const parsed = ScreeningSampleCommitmentSchema.safeParse(input);
+    if (!parsed.success)
+        throw new TypeError(`screening sample commitment failed its closed schema: ${parsed.error.message}`);
+    const canonical = canonicalJsonBytes(parsed.data);
+    const expected = "candidateItemDigests" in parsed.data
+        ? new Uint8Array([...canonical, 0x0a])
+        : canonical;
+    if (!sameBytes(bytes, expected)) {
+        throw new TypeError("screening sample commitment is not in its exact canonical wire encoding");
+    }
+    return parsed.data;
+}
+/** Normalize the original internal envelope and exact external registration shape for replay. */
+export function promptedScreeningCommitmentView(commitment) {
+    if (!("candidateItemDigests" in commitment)) {
+        return {
+            committedAt: commitment.committedAt,
+            poolIdentityCommitmentSha256: commitment.poolIdentityCommitmentSha256,
+            sampleSeed: commitment.sampleSeed,
+            sampleSize: commitment.sampleSize,
+            sampleItemSha256s: commitment.sampleItemSha256s,
+            draftId: commitment.draftId,
+            poolSha256: commitment.poolSha256,
+        };
+    }
+    return {
+        committedAt: commitment.committedAt,
+        poolIdentityCommitmentSha256: commitment.poolDigest,
+        sampleSeed: commitment.sampleSeed,
+        sampleSize: commitment.sampleSize,
+        registeredIdentitySha256s: commitment.candidateItemDigests,
+        samplingScriptSha256: commitment.samplingScriptSha256,
+    };
+}

package/dist/admission/prompted-selection.d.ts

@@ -0,0 +1,24 @@
+import { type PromptedScreeningRowV2, type ScreeningPool } from "./contracts.js";
+type PoolItem = ScreeningPool["items"][number];
+type MainItem = Extract<PoolItem, {
+    poolKind: "main";
+}>;
+type ReserveItem = Extract<PoolItem, {
+    poolKind: "reserve";
+}>;
+export interface PromptedScreeningReplacement {
+    readonly excludedMain: MainItem;
+    readonly replacement: ReserveItem;
+    readonly receivingSlotId: string;
+}
+export interface PromptedScreeningSelection {
+    readonly winners: readonly PoolItem[];
+    readonly replacements: readonly PromptedScreeningReplacement[];
+    readonly participatingItemSha256s: ReadonlySet<string>;
+}
+export declare class PromptedScreeningSelectionError extends Error {
+    constructor(message: string);
+}
+/** Deterministic prompted-screening winner selection shared by the producer and portable replay. */
+export declare function selectPromptedScreeningPool(pool: ScreeningPool, rows: ReadonlyMap<string, PromptedScreeningRowV2>): PromptedScreeningSelection;
+export {};

package/dist/admission/prompted-selection.js

@@ -0,0 +1,85 @@
+// SPDX-License-Identifier: Apache-2.0
+import { compareCodeUnitStrings } from "@jinn-network/task-execution-profiles";
+import { SCREENING_POOL_V2_PROTOCOL, } from "./contracts.js";
+export class PromptedScreeningSelectionError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "PromptedScreeningSelectionError";
+    }
+}
+function admitted(row) {
+    const agreed = row.screeningVerdict !== "UNSURE" && row.screeningVerdict === row.intendedLabel;
+    return row.ritsuDecision.checked ? row.ritsuDecision.verdict === "confirm" : agreed;
+}
+function v1Selection(pool, rows) {
+    const winners = [];
+    const replacements = [];
+    const participating = new Set();
+    const slotIds = [...new Set(pool.items.map((item) => item.slotId))].sort(compareCodeUnitStrings);
+    for (const slotId of slotIds) {
+        const slotItems = pool.items.filter((item) => item.slotId === slotId);
+        const main = slotItems.find((item) => item.poolKind === "main");
+        const reserves = slotItems
+            .filter((item) => item.poolKind === "reserve")
+            .sort((left, right) => left.reserveOrder - right.reserveOrder);
+        const winner = [main, ...reserves].find((item) => admitted(rows.get(item.itemSha256)));
+        if (winner === undefined)
+            throw new PromptedScreeningSelectionError(`${slotId} has no admissible main or reserve candidate`);
+        winners.push(winner);
+        participating.add(winner.itemSha256);
+        if (winner.poolKind === "reserve") {
+            participating.add(main.itemSha256);
+            replacements.push({ excludedMain: main, replacement: winner, receivingSlotId: slotId });
+        }
+    }
+    return { winners, replacements, participatingItemSha256s: participating };
+}
+function v2Selection(pool, rows) {
+    const mains = pool.items
+        .filter((item) => item.poolKind === "main")
+        .sort((left, right) => compareCodeUnitStrings(left.slotId, right.slotId));
+    const winners = [];
+    const replacements = [];
+    const participating = new Set();
+    const activeLineages = new Set();
+    for (const main of mains) {
+        if (!admitted(rows.get(main.itemSha256)))
+            continue;
+        if (activeLineages.has(main.sourceQuestionLineageId)) {
+            throw new PromptedScreeningSelectionError(`admitted mains duplicate source-question lineage ${main.sourceQuestionLineageId}`);
+        }
+        activeLineages.add(main.sourceQuestionLineageId);
+        winners.push(main);
+        participating.add(main.itemSha256);
+    }
+    for (const main of mains) {
+        if (admitted(rows.get(main.itemSha256)))
+            continue;
+        const reserves = pool.items
+            .filter((item) => item.poolKind === "reserve"
+            && item.candidateClass === main.candidateClass
+            && item.stratum === main.stratum)
+            .sort((left, right) => left.reserveOrder - right.reserveOrder);
+        const replacement = reserves.find((reserve) => admitted(rows.get(reserve.itemSha256))
+            && !activeLineages.has(reserve.sourceQuestionLineageId));
+        if (replacement === undefined) {
+            throw new PromptedScreeningSelectionError(`${main.slotId} has no admissible unused-lineage reserve in ${main.candidateClass}/${main.stratum}`);
+        }
+        activeLineages.add(replacement.sourceQuestionLineageId);
+        winners.push(replacement);
+        participating.add(main.itemSha256);
+        participating.add(replacement.itemSha256);
+        replacements.push({ excludedMain: main, replacement, receivingSlotId: main.slotId });
+    }
+    return {
+        winners: winners.sort((left, right) => left.poolPosition - right.poolPosition),
+        replacements,
+        participatingItemSha256s: participating,
+    };
+}
+/** Deterministic prompted-screening winner selection shared by the producer and portable replay. */
+export function selectPromptedScreeningPool(pool, rows) {
+    return pool.protocol === SCREENING_POOL_V2_PROTOCOL
+        ? v2Selection(pool, rows)
+        : v1Selection(pool, rows);
+}