@colophon-claims/verify 0.1.0 → 0.2.0

package/README.md

@@ -3,7 +3,7 @@
 Verify a public Colophon claim bundle without the Colophon app or any execution runtime:
 
 ```sh
-npx @colophon-claims/verify@0.1 ./bundle
+npx @colophon-claims/verify@0.2 ./bundle
 ```
 
 Use `--json` for machine-readable output. The reader runs the checks declared by the
@@ -11,11 +11,15 @@ bundle format, covering its manifest, evidence closure, calculations, report, an
 consistency. Exit status is `0` when every check passes, `1` for an invalid bundle, and
 `2` for usage or operational failures.
 
-This 0.1 reader supports public bundle formats v2, v4, v5, and v6. It intentionally
+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.
-New claims stamp `npx @colophon-claims/verify@0.1.0` and the compatible
-`@0.1` line.
+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.
+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
 nothing. It checks the bundle's integrity, evidence closure, calculations, report, and claim

package/dist/admission/contracts.d.ts

@@ -8,6 +8,10 @@ export declare const HUMAN_REVIEW_REPLACEMENT_LEDGER_PROTOCOL: "https://spec.jin
 export declare const HUMAN_REVIEW_OPERATOR_ASSERTION_PROTOCOL: "https://spec.jinn.network/binary-judgment/operator-truth-assertion/v1";
 export declare const BINARY_JUDGMENT_ADMISSION_MANIFEST_PROTOCOL: "https://spec.jinn.network/binary-judgment/admission-manifest/v1";
 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_SAMPLE_COMMITMENT_PROTOCOL: "https://spec.jinn.network/binary-judgment/screening-sample-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";
 export declare const HUMAN_REVIEW_RESPONSE_MEDIA_TYPE: "application/vnd.jinn.binary-judgment.human-review-response.v1+json";
@@ -16,6 +20,7 @@ export declare const HUMAN_REVIEW_ROSTER_MEDIA_TYPE: "application/vnd.jinn.binar
 export declare const HUMAN_REVIEW_REVEAL_RECEIPT_MEDIA_TYPE: "application/vnd.jinn.binary-judgment.reveal-receipt.v1+json";
 export declare const HUMAN_REVIEW_OPERATOR_ASSERTION_MEDIA_TYPE: "application/vnd.jinn.binary-judgment.operator-truth-assertion.v1+json";
 export declare const SCREENING_TABLE_MEDIA_TYPE: "application/vnd.jinn.binary-judgment.screening-table.v1+json";
+export declare const SCREENING_TABLE_V2_MEDIA_TYPE: "application/vnd.jinn.binary-judgment.screening-table.v2+json";
 export declare const SCREENING_REVEAL_RECEIPT_MEDIA_TYPE: "application/vnd.jinn.binary-judgment.screening-reveal-receipt.v1+json";
 export declare const HUMAN_REVIEW_OMITTED_FIELDS: readonly ["instrumentIdentity", "candidateClass", "stratum", "otherReview", "postRunOutcomes"];
 export declare const HumanReviewPacketSchema: z.ZodObject<{
@@ -186,6 +191,243 @@ export declare const ScreeningTableSchema: z.ZodObject<{
     sealedAt: z.ZodString;
 }, z.core.$strict>;
 export type ScreeningTable = z.infer<typeof ScreeningTableSchema>;
+export declare const PROMPTED_SCREENING_PROFILE: "prompted-codex-screening/v1";
+export declare const PROMPTED_SCREENING_LIMITATIONS: readonly ["prompt-compliance-not-machine-verified", "provider-execution-not-machine-verified", "transcript-provenance-not-machine-verified", "mutable-model-alias-weights-not-machine-verified"];
+/** Closed, machine-checkable orchestration metadata. Prompt and transcript bytes stay opaque. */
+export declare const PromptedScreeningProcedureV1Schema: z.ZodObject<{
+    protocol: z.ZodLiteral<"https://spec.jinn.network/binary-judgment/prompted-screening-procedure/v1">;
+    procedureId: z.ZodLiteral<"prompted-codex-screening/v1">;
+    coordinatorPromptSha256: z.ZodString;
+    coordinator: z.ZodObject<{
+        alias: z.ZodLiteral<"Sol">;
+        model: z.ZodLiteral<"gpt-5.6-sol">;
+        reasoningEffort: z.ZodLiteral<"high">;
+        mayOrchestrate: z.ZodLiteral<true>;
+    }, z.core.$strict>;
+    judgmentAgents: z.ZodTuple<[z.ZodObject<{
+        alias: z.ZodLiteral<"Luna">;
+        model: z.ZodLiteral<"gpt-5.6-luna">;
+        reasoningEffort: z.ZodLiteral<"medium" | "high">;
+        maxBatchSize: z.ZodLiteral<32>;
+    }, z.core.$strict>, z.ZodObject<{
+        alias: z.ZodLiteral<"Terra">;
+        model: z.ZodLiteral<"gpt-5.6-terra">;
+        reasoningEffort: z.ZodLiteral<"medium" | "high">;
+        maxBatchSize: z.ZodLiteral<16>;
+    }, z.core.$strict>, z.ZodObject<{
+        alias: z.ZodLiteral<"Sol">;
+        model: z.ZodLiteral<"gpt-5.6-sol">;
+        reasoningEffort: z.ZodLiteral<"medium" | "high">;
+        maxBatchSize: z.ZodLiteral<8>;
+    }, z.core.$strict>], null>;
+    toolPolicy: z.ZodObject<{
+        coordinator: z.ZodLiteral<"orchestration-only">;
+        judgmentAgents: z.ZodObject<{
+            web: z.ZodLiteral<false>;
+            shell: z.ZodLiteral<false>;
+            repository: z.ZodLiteral<false>;
+            search: z.ZodLiteral<false>;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    output: z.ZodObject<{
+        alphabet: z.ZodTuple<[z.ZodLiteral<"CORRECT">, z.ZodLiteral<"WRONG">, z.ZodLiteral<"UNSURE">], null>;
+        invalidOutputDecision: z.ZodLiteral<"UNSURE">;
+    }, z.core.$strict>;
+    retry: z.ZodObject<{
+        maxRetries: z.ZodLiteral<1>;
+        onlyWhen: z.ZodLiteral<"infrastructure-failure-with-no-model-output">;
+        prompt: z.ZodLiteral<"identical">;
+    }, z.core.$strict>;
+    transcriptSha256: z.ZodString;
+    sealedAt: z.ZodString;
+}, z.core.$strict>;
+export type PromptedScreeningProcedureV1 = z.infer<typeof PromptedScreeningProcedureV1Schema>;
+export declare const SCREENING_POOL_CANDIDATE_CLASSES: readonly ["correct", "specific-wrong", "vague-topical-wrong"];
+export declare const SCREENING_POOL_STRATA: readonly ["category-1", "category-2", "category-3", "category-4"];
+export declare const ScreeningPoolItemSchema: 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">;
+export type ScreeningPoolItem = z.infer<typeof ScreeningPoolItemSchema>;
+/** The complete, ordered 240-main plus 424-reserve candidate universe. */
+export declare const ScreeningPoolV1Schema: 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>;
+export type ScreeningPoolV1 = z.infer<typeof ScreeningPoolV1Schema>;
+export declare const ScreeningSampleCommitmentV1Schema: 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>;
+export type ScreeningSampleCommitmentV1 = z.infer<typeof ScreeningSampleCommitmentV1Schema>;
+export declare const PromptedScreeningRowV2Schema: z.ZodObject<{
+    itemSha256: z.ZodString;
+    intendedLabel: z.ZodEnum<{
+        CORRECT: "CORRECT";
+        WRONG: "WRONG";
+    }>;
+    screeningVerdict: z.ZodEnum<{
+        CORRECT: "CORRECT";
+        WRONG: "WRONG";
+        UNSURE: "UNSURE";
+    }>;
+    terraReviewVerdict: z.ZodOptional<z.ZodEnum<{
+        CORRECT: "CORRECT";
+        WRONG: "WRONG";
+        UNSURE: "UNSURE";
+    }>>;
+    solReviewVerdict: z.ZodOptional<z.ZodEnum<{
+        CORRECT: "CORRECT";
+        WRONG: "WRONG";
+        UNSURE: "UNSURE";
+    }>>;
+    ritsuDecision: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        checked: z.ZodLiteral<false>;
+    }, z.core.$strict>, z.ZodObject<{
+        checked: z.ZodLiteral<true>;
+        verdict: z.ZodEnum<{
+            confirm: "confirm";
+            exclude: "exclude";
+        }>;
+        decidedAt: z.ZodString;
+    }, z.core.$strict>], "checked">;
+}, z.core.$strict>;
+export type PromptedScreeningRowV2 = z.infer<typeof PromptedScreeningRowV2Schema>;
+/** Signed authority decision table for the prompted Codex procedure. */
+export declare const ScreeningTableV2Schema: z.ZodObject<{
+    protocol: z.ZodLiteral<"https://spec.jinn.network/binary-judgment/screening-table/v2">;
+    draftId: z.ZodString;
+    procedureSha256: z.ZodString;
+    coordinatorPromptSha256: z.ZodString;
+    poolSha256: z.ZodString;
+    sampleCommitmentSha256: z.ZodString;
+    samplingScriptSha256: z.ZodString;
+    transcriptSha256: z.ZodString;
+    operator: z.ZodLiteral<"Ritsu">;
+    rows: z.ZodArray<z.ZodObject<{
+        itemSha256: z.ZodString;
+        intendedLabel: z.ZodEnum<{
+            CORRECT: "CORRECT";
+            WRONG: "WRONG";
+        }>;
+        screeningVerdict: z.ZodEnum<{
+            CORRECT: "CORRECT";
+            WRONG: "WRONG";
+            UNSURE: "UNSURE";
+        }>;
+        terraReviewVerdict: z.ZodOptional<z.ZodEnum<{
+            CORRECT: "CORRECT";
+            WRONG: "WRONG";
+            UNSURE: "UNSURE";
+        }>>;
+        solReviewVerdict: z.ZodOptional<z.ZodEnum<{
+            CORRECT: "CORRECT";
+            WRONG: "WRONG";
+            UNSURE: "UNSURE";
+        }>>;
+        ritsuDecision: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            checked: z.ZodLiteral<false>;
+        }, z.core.$strict>, z.ZodObject<{
+            checked: z.ZodLiteral<true>;
+            verdict: z.ZodEnum<{
+                confirm: "confirm";
+                exclude: "exclude";
+            }>;
+            decidedAt: z.ZodString;
+        }, z.core.$strict>], "checked">;
+    }, z.core.$strict>>;
+    sealedAt: z.ZodString;
+}, z.core.$strict>;
+export type ScreeningTableV2 = z.infer<typeof ScreeningTableV2Schema>;
 export declare const HumanReviewReplacementLedgerEntrySchema: z.ZodObject<{
     excludedItemSha256: z.ZodString;
     replacementItemSha256: z.ZodString;

package/dist/admission/contracts.js

@@ -11,6 +11,10 @@ export const HUMAN_REVIEW_OPERATOR_ASSERTION_PROTOCOL = "https://spec.jinn.netwo
 export const BINARY_JUDGMENT_ADMISSION_MANIFEST_PROTOCOL = "https://spec.jinn.network/binary-judgment/admission-manifest/v1";
 // screened-operator-sampled admission branch (spec §6.1, §6.3, §6.6; packet P6).
 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_SAMPLE_COMMITMENT_PROTOCOL = "https://spec.jinn.network/binary-judgment/screening-sample-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";
 export const HUMAN_REVIEW_RESPONSE_MEDIA_TYPE = "application/vnd.jinn.binary-judgment.human-review-response.v1+json";
@@ -20,6 +24,7 @@ export const HUMAN_REVIEW_REVEAL_RECEIPT_MEDIA_TYPE = "application/vnd.jinn.bina
 export const HUMAN_REVIEW_OPERATOR_ASSERTION_MEDIA_TYPE = "application/vnd.jinn.binary-judgment.operator-truth-assertion.v1+json";
 // screened-operator-sampled admission branch (spec §6.3, §6.6; packet P6).
 export const SCREENING_TABLE_MEDIA_TYPE = "application/vnd.jinn.binary-judgment.screening-table.v1+json";
+export const SCREENING_TABLE_V2_MEDIA_TYPE = "application/vnd.jinn.binary-judgment.screening-table.v2+json";
 export const SCREENING_REVEAL_RECEIPT_MEDIA_TYPE = "application/vnd.jinn.binary-judgment.screening-reveal-receipt.v1+json";
 const DigestSchema = z.string().regex(/^sha256:[0-9a-f]{64}$/u);
 const TimestampSchema = z.string().datetime({ offset: true });
@@ -201,6 +206,170 @@ export const ScreeningTableSchema = z.strictObject({
         }
     }
 });
+export const PROMPTED_SCREENING_PROFILE = "prompted-codex-screening/v1";
+export const PROMPTED_SCREENING_LIMITATIONS = [
+    "prompt-compliance-not-machine-verified",
+    "provider-execution-not-machine-verified",
+    "transcript-provenance-not-machine-verified",
+    "mutable-model-alias-weights-not-machine-verified",
+];
+const PromptedAgentSchema = (alias, model, reasoningEffort, maxBatchSize) => z.strictObject({
+    alias: z.literal(alias),
+    model: z.literal(model),
+    reasoningEffort: z.literal(reasoningEffort),
+    maxBatchSize: z.literal(maxBatchSize),
+});
+/** Closed, machine-checkable orchestration metadata. Prompt and transcript bytes stay opaque. */
+export const PromptedScreeningProcedureV1Schema = z.strictObject({
+    protocol: z.literal(PROMPTED_SCREENING_PROCEDURE_PROTOCOL),
+    procedureId: z.literal(PROMPTED_SCREENING_PROFILE),
+    coordinatorPromptSha256: DigestSchema,
+    coordinator: z.strictObject({
+        alias: z.literal("Sol"),
+        model: z.literal("gpt-5.6-sol"),
+        reasoningEffort: z.literal("high"),
+        mayOrchestrate: z.literal(true),
+    }),
+    judgmentAgents: z.tuple([
+        PromptedAgentSchema("Luna", "gpt-5.6-luna", "medium", 32),
+        PromptedAgentSchema("Terra", "gpt-5.6-terra", "high", 16),
+        PromptedAgentSchema("Sol", "gpt-5.6-sol", "high", 8),
+    ]),
+    toolPolicy: z.strictObject({
+        coordinator: z.literal("orchestration-only"),
+        judgmentAgents: z.strictObject({
+            web: z.literal(false),
+            shell: z.literal(false),
+            repository: z.literal(false),
+            search: z.literal(false),
+        }),
+    }),
+    output: z.strictObject({
+        alphabet: z.tuple([z.literal("CORRECT"), z.literal("WRONG"), z.literal("UNSURE")]),
+        invalidOutputDecision: z.literal("UNSURE"),
+    }),
+    retry: z.strictObject({
+        maxRetries: z.literal(1),
+        onlyWhen: z.literal("infrastructure-failure-with-no-model-output"),
+        prompt: z.literal("identical"),
+    }),
+    transcriptSha256: DigestSchema,
+    sealedAt: TimestampSchema,
+});
+export const SCREENING_POOL_CANDIDATE_CLASSES = ["correct", "specific-wrong", "vague-topical-wrong"];
+export const SCREENING_POOL_STRATA = ["category-1", "category-2", "category-3", "category-4"];
+const ScreeningPoolCommonItemSchema = z.strictObject({
+    itemSha256: DigestSchema,
+    intendedLabel: BinaryJudgmentTruthLabelSchema,
+    candidateClass: z.enum(SCREENING_POOL_CANDIDATE_CLASSES),
+    stratum: z.enum(SCREENING_POOL_STRATA),
+    poolPosition: z.number().int().positive(),
+    slotId: z.string().regex(/^slot-[0-9]{3}$/u),
+});
+export const ScreeningPoolItemSchema = z.discriminatedUnion("poolKind", [
+    ScreeningPoolCommonItemSchema.extend({ poolKind: z.literal("main") }),
+    ScreeningPoolCommonItemSchema.extend({ poolKind: z.literal("reserve"), reserveOrder: z.number().int().positive() }),
+]);
+/** The complete, ordered 240-main plus 424-reserve candidate universe. */
+export const ScreeningPoolV1Schema = z.strictObject({
+    protocol: z.literal(SCREENING_POOL_PROTOCOL),
+    draftId: IdentitySchema,
+    identityCommitmentSha256: DigestSchema,
+    items: z.array(ScreeningPoolItemSchema).length(664),
+    sealedAt: TimestampSchema,
+}).superRefine((pool, ctx) => {
+    const slots = new Map();
+    const identities = 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.itemSha256))
+            ctx.addIssue({ code: "custom", path: ["items", index, "itemSha256"], message: "itemSha256 must be unique" });
+        identities.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" });
+        slots.set(item.slotId, [...(slots.get(item.slotId) ?? []), item]);
+    }
+    const mains = pool.items.filter((item) => item.poolKind === "main");
+    if (mains.length !== 240 || slots.size !== 240)
+        ctx.addIssue({ code: "custom", path: ["items"], message: "pool must contain exactly 240 main slots" });
+    const expectedSlotIds = Array.from({ length: 240 }, (_, index) => `slot-${(index + 1).toString().padStart(3, "0")}`);
+    const actualSlotIds = [...slots.keys()].sort(compareCodeUnitStrings);
+    if (actualSlotIds.length !== expectedSlotIds.length || actualSlotIds.some((value, index) => value !== expectedSlotIds[index]))
+        ctx.addIssue({ code: "custom", path: ["items"], message: "slot lineage must be exactly slot-001 through slot-240" });
+    for (const [slotId, items] of slots) {
+        const main = items.filter((item) => item.poolKind === "main");
+        if (main.length !== 1) {
+            ctx.addIssue({ code: "custom", path: ["items"], message: `${slotId} must contain exactly one main item` });
+            continue;
+        }
+        const reserves = items.filter((item) => item.poolKind === "reserve").sort((a, b) => a.reserveOrder - b.reserveOrder);
+        for (const [index, reserve] of reserves.entries()) {
+            if (reserve.reserveOrder !== index + 1)
+                ctx.addIssue({ code: "custom", path: ["items"], message: `${slotId} reserveOrder must be contiguous` });
+            if (reserve.poolPosition <= main[0].poolPosition)
+                ctx.addIssue({ code: "custom", path: ["items"], message: `${slotId} reserves must follow their main item in pool order` });
+            if (reserve.candidateClass !== main[0].candidateClass || reserve.stratum !== main[0].stratum || reserve.intendedLabel !== main[0].intendedLabel)
+                ctx.addIssue({ code: "custom", path: ["items"], message: `${slotId} reserves must preserve class, stratum, and intended label` });
+        }
+    }
+    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` });
+        }
+});
+export const ScreeningSampleCommitmentV1Schema = z.strictObject({
+    protocol: z.literal(SCREENING_SAMPLE_COMMITMENT_PROTOCOL),
+    draftId: IdentitySchema,
+    poolSha256: DigestSchema,
+    poolIdentityCommitmentSha256: DigestSchema,
+    samplingProcedure: z.literal("screening-sample/1"),
+    sampleSeed: z.string().min(1),
+    sampleSize: z.literal(72),
+    sampleItemSha256s: z.array(DigestSchema).length(72).superRefine((values, ctx) => {
+        for (let index = 1; index < values.length; index += 1) {
+            if (compareCodeUnitStrings(values[index - 1], values[index]) >= 0)
+                ctx.addIssue({ code: "custom", message: "sample identities must be sorted and unique" });
+        }
+    }),
+    committedAt: TimestampSchema,
+});
+const ScreeningDecisionSchema = z.enum(["CORRECT", "WRONG", "UNSURE"]);
+const RitsuScreeningDecisionSchema = z.discriminatedUnion("checked", [
+    z.strictObject({ checked: z.literal(false) }),
+    z.strictObject({ checked: z.literal(true), verdict: z.enum(["confirm", "exclude"]), decidedAt: TimestampSchema }),
+]);
+export const PromptedScreeningRowV2Schema = z.strictObject({
+    itemSha256: DigestSchema,
+    intendedLabel: BinaryJudgmentTruthLabelSchema,
+    screeningVerdict: ScreeningDecisionSchema,
+    terraReviewVerdict: ScreeningDecisionSchema.optional(),
+    solReviewVerdict: ScreeningDecisionSchema.optional(),
+    ritsuDecision: RitsuScreeningDecisionSchema,
+});
+/** Signed authority decision table for the prompted Codex procedure. */
+export const ScreeningTableV2Schema = z.strictObject({
+    protocol: z.literal(SCREENING_TABLE_V2_PROTOCOL),
+    draftId: IdentitySchema,
+    procedureSha256: DigestSchema,
+    coordinatorPromptSha256: DigestSchema,
+    poolSha256: DigestSchema,
+    sampleCommitmentSha256: DigestSchema,
+    samplingScriptSha256: DigestSchema,
+    transcriptSha256: DigestSchema,
+    operator: z.literal("Ritsu"),
+    rows: z.array(PromptedScreeningRowV2Schema).length(664),
+    sealedAt: TimestampSchema,
+}).superRefine((table, ctx) => {
+    for (let index = 1; index < table.rows.length; index += 1) {
+        if (compareCodeUnitStrings(table.rows[index - 1].itemSha256, table.rows[index].itemSha256) >= 0) {
+            ctx.addIssue({ code: "custom", path: ["rows"], message: "rows must be sorted by itemSha256 and unique" });
+            return;
+        }
+    }
+});
 // The two-human-review reasons (unchanged) and the screened-branch reasons this packet adds
 // (spec §6.4; packet P6). This is one of four widened copies of the closed reason vocabulary
 // (the other three: verify/src/schema.ts's exclusions[].reason, verify/src/admission/

package/dist/admission/verification.d.ts

@@ -1,6 +1,6 @@
-import { type BinaryJudgmentAdmissionManifest, type HumanReviewReplacementLedger } from "./contracts.js";
+import { PROMPTED_SCREENING_PROFILE, type BinaryJudgmentAdmissionManifest, type HumanReviewReplacementLedger } from "./contracts.js";
 export type AdmissionSha256 = `sha256:${string}`;
-export declare const BINARY_JUDGMENT_ADMISSION_RECORD_ROLES: readonly ["admission-manifest", "replacement-ledger", "source-item", "label-resolution", "analysis-context", "human-review-evaluation-spec", "human-review-form", "human-review-packet", "human-review-response", "human-review-verdict", "reviewer-roster", "review-visibility-receipt", "review-reveal-receipt", "operator-assertion", "screening-table", "screening-reveal-receipt", "screening-instrument", "screening-sampling-script", "screening-raw-outputs"];
+export declare const BINARY_JUDGMENT_ADMISSION_RECORD_ROLES: readonly ["admission-manifest", "replacement-ledger", "source-item", "label-resolution", "analysis-context", "human-review-evaluation-spec", "human-review-form", "human-review-packet", "human-review-response", "human-review-verdict", "reviewer-roster", "review-visibility-receipt", "review-reveal-receipt", "operator-assertion", "screening-table", "screening-reveal-receipt", "screening-instrument", "screening-sampling-script", "screening-raw-outputs", "screening-prompt", "screening-procedure", "screening-pool", "screening-sample-commitment", "screening-transcript"];
 export type BinaryJudgmentAdmissionRecordRole = (typeof BINARY_JUDGMENT_ADMISSION_RECORD_ROLES)[number];
 export type AdmissionAuthorityRole = "roster-attestor" | "truth-reveal-attestor" | "operator-truth-attestor";
 export interface BinaryJudgmentAdmissionClosurePorts {
@@ -57,12 +57,25 @@ export interface VerifiedBinaryJudgmentAdmissionClosure {
         readonly sha256: AdmissionSha256;
         readonly roles: readonly BinaryJudgmentAdmissionRecordRole[];
     }[];
-    /** Present iff `manifest.truthAdmission === "screened-operator-sampled"` (spec §6.5 check (3)). */
+    /** Present for the legacy screening-table/v1 method (spec §6.5 check (3)). */
     readonly screening?: {
         readonly sampleAgreementRate: number;
         readonly instrumentSha256: AdmissionSha256;
     };
+    /** Present for screening-table/v2; kept separate so the legacy v1 result shape stays source-compatible. */
+    readonly promptedScreening?: {
+        readonly sampleAgreementRate: number;
+        readonly procedureSha256: AdmissionSha256;
+        readonly profile: typeof PROMPTED_SCREENING_PROFILE;
+        readonly capabilityBoundary: PromptedScreeningCapabilityBoundary;
+    };
 }
+export declare const PROMPTED_SCREENING_CAPABILITY_BOUNDARY: {
+    readonly status: "not-machine-verified";
+    readonly machineVerified: readonly ["sealed-pool", "sealed-sample", "signed-table", "operator-decisions", "artifact-integrity"];
+    readonly notMachineVerified: readonly ["prompt-compliance-not-machine-verified", "provider-execution-not-machine-verified", "transcript-provenance-not-machine-verified", "mutable-model-alias-weights-not-machine-verified"];
+};
+export type PromptedScreeningCapabilityBoundary = typeof PROMPTED_SCREENING_CAPABILITY_BOUNDARY;
 export declare class BinaryJudgmentAdmissionClosureError extends Error {
     readonly path: string;
     constructor(path: string, detail: string, options?: ErrorOptions);

package/dist/admission/verification.js

@@ -3,9 +3,9 @@ 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, ScreeningPoolV1Schema, ScreeningSampleCommitmentV1Schema, PROMPTED_SCREENING_LIMITATIONS, PROMPTED_SCREENING_PROFILE, } from "./contracts.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 +21,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 +254,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 +325,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 +378,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 +397,86 @@ 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(ScreeningPoolV1Schema, resolve(state, screeningTable.poolSha256, "screeningTable.poolSha256", "screening-pool"), "screeningPool");
+            const commitment = exactCanonical(ScreeningSampleCommitmentV1Schema, resolve(state, screeningTable.sampleCommitmentSha256, "screeningTable.sampleCommitmentSha256", "screening-sample-commitment"), "screeningSampleCommitment");
+            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
+                || commitment.draftId !== input.expectedDraftId
+                || commitment.poolSha256 !== screeningTable.poolSha256
+                || commitment.poolIdentityCommitmentSha256 !== pool.identityCommitmentSha256
+                || Date.parse(procedure.sealedAt) > Date.parse(screeningTable.sealedAt)
+                || Date.parse(pool.sealedAt) > Date.parse(commitment.committedAt)
+                || Date.parse(commitment.committedAt) > Date.parse(screeningTable.sealedAt))
+                fail("screeningTable", "prompted procedure, prompt, transcript, pool, commitment, draft, or timestamps do not join");
+            const poolIdentities = pool.items.map((item) => item.itemSha256);
+            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 sortedPoolIdentities = [...poolIdentities].sort(compareCodeUnitStrings);
+            if (!sameStrings(rowIdentities, sortedPoolIdentities))
+                fail("screeningTable.rows", "v2 table must cover all 664 pool identities 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(commitment.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 = commitment.sampleSeed;
+            sampleSize = commitment.sampleSize;
+            sampleIdentities = poolIdentities;
+            promptedScreeningProcedureSha256 = screeningTable.procedureSha256;
+            promptedScreeningPool = pool;
+            promptedCommittedSample = commitment.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 +484,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,11 +495,13 @@ 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");
         // (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 || screeningSample.has(row.itemSha256)) && !screeningRowChecked(row)) {
                 fail("screeningTable.rows", `row ${row.itemSha256} is flagged or sampled but was never hand-checked`);
             }
         }
@@ -432,7 +509,7 @@ export function verifyBinaryJudgmentAdmissionClosure(input, ports) {
         // row in `screeningSample` is hand-checked by check (2) above, so `handVerdict` is defined.
         const sampleMatches = [...screeningSample].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;
     }
@@ -528,6 +605,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 +617,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 +645,37 @@ 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) {
+        const slotIds = [...new Set(promptedScreeningPool.items.map((item) => item.slotId))].sort(compareCodeUnitStrings);
+        const expectedAccepted = new Set();
+        for (const slotId of slotIds) {
+            const slotItems = promptedScreeningPool.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) => screeningRowAdmitted(screeningRowsByItem.get(item.itemSha256)));
+            if (winner === undefined)
+                fail("screeningPool.items", `${slotId} has no admissible main or reserve candidate`);
+            expectedAccepted.add(winner.itemSha256);
+            if (winner.itemSha256 !== main.itemSha256)
+                promptedExpectedReplacements.set(main.itemSha256, winner.itemSha256);
+        }
+        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");
@@ -593,6 +703,17 @@ 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);
+            if (excludedPoolItem?.poolKind !== "main"
+                || replacementPoolItem?.poolKind !== "reserve"
+                || excludedPoolItem.slotId !== replacementPoolItem.slotId
+                || entry.excludedPoolPosition !== excludedPoolItem.poolPosition
+                || entry.replacementPoolPosition !== replacementPoolItem.poolPosition
+                || promptedExpectedReplacements.get(entry.excludedItemSha256) !== entry.replacementItemSha256)
+                fail(path, "ledger does not name the deterministic first-admissible reserve for the exact sealed slot 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
@@ -652,6 +773,12 @@ export function verifyBinaryJudgmentAdmissionClosure(input, ports) {
             replacementItemSha256: prefixed(entry.replacementItemSha256),
         });
     }
+    if (promptedScreeningPool !== undefined) {
+        const ledgerReplacements = new Map(ledger.entries.map((entry) => [entry.excludedItemSha256, entry.replacementItemSha256]));
+        if (ledgerReplacements.size !== promptedExpectedReplacements.size || [...promptedExpectedReplacements].some(([excludedItem, replacementItem]) => ledgerReplacements.get(excludedItem) !== replacementItem)) {
+            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 +786,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 +832,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/profile/binary-qualification.js

@@ -1,4 +1,5 @@
 import { validateBinaryInstrumentParameters } from "@jinn-network/benchmarking-aggregate";
+import { PROMPTED_SCREENING_LIMITATIONS, PROMPTED_SCREENING_PROFILE, } from "../admission/contracts.js";
 export const BINARY_INSTRUMENT_REPORT_LIMITATIONS = {
     mutableModelAlias: "The gpt-5.6-luna identifier is a mutable provider alias; this evidence does not prove invariant model weights across calls.",
     reviewerKeyPerson: "Distinct reviewer signing keys prove key control, not that the controllers are distinct people.",
@@ -48,5 +49,10 @@ export function binaryInstrumentReportLimitations(parameters) {
         ...(parameters["truthAdmission"] === "screened-operator-sampled"
             ? [BINARY_INSTRUMENT_REPORT_LIMITATIONS.screenedNotIndependentlyLabeled]
             : []),
+        // Appended only for an authenticated screening-table/v2 closure. Legacy parameter sets omit
+        // the profile and therefore retain their exact limitation arrays and sealed Report bytes.
+        ...(parameters["promptedScreeningProfile"] === PROMPTED_SCREENING_PROFILE
+            ? PROMPTED_SCREENING_LIMITATIONS
+            : []),
     ];
 }

package/dist/profile/claim.d.ts

@@ -44,6 +44,9 @@ export declare const BINARY_QUALIFICATION_CLAIM_PACKAGE_SCHEMA_ID = "benchmark-p
 export declare const ANCHORED_CLAIM_PACKAGE_SCHEMA_ID = "benchmark-product.claim-package/4";
 export declare const BINARY_QUALIFICATION_VERIFICATION_COMMAND: "npx @colophon-claims/verify@0.1.0 <bundle-dir>";
 export declare 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 declare const PROMPTED_BINARY_QUALIFICATION_VERIFICATION_COMMAND: "npx @colophon-claims/verify@0.2.0 <bundle-dir>";
+export declare const PROMPTED_BINARY_QUALIFICATION_COMPATIBLE_VERIFICATION_COMMAND: "npx @colophon-claims/verify@0.2 <bundle-dir>";
 /** The fixed sentence every claim package's assurance block carries (BP-21, spec §6/§7.1): what
  * distinct evaluator identities on this venue actually prove. Never softened per-claim. */
 export declare const ASSURANCE_DISCLOSURE: string;

package/dist/profile/claim.js

@@ -34,6 +34,7 @@ import { validateBinaryInstrumentQualificationProjection } from "@jinn-network/b
 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 { 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";
 export const BINARY_QUALIFICATION_CLAIM_PACKAGE_SCHEMA_ID = "benchmark-product.claim-package/2";
@@ -46,6 +47,9 @@ export const BINARY_QUALIFICATION_CLAIM_PACKAGE_SCHEMA_ID = "benchmark-product.c
 export const ANCHORED_CLAIM_PACKAGE_SCHEMA_ID = "benchmark-product.claim-package/4";
 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_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
  * reached across the module boundary for one regex. */
@@ -361,9 +365,15 @@ 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.verification.command !== BINARY_QUALIFICATION_VERIFICATION_COMMAND
-        || claim.verification.compatibleCommand !== BINARY_QUALIFICATION_COMPATIBLE_VERIFICATION_COMMAND) {
-        ctx.addIssue({ code: "custom", message: "binary claim package must pin verifier 0.1.0/@0.1", path: ["verification"] });
+    const prompted = claim.method.parameters["promptedScreeningProfile"] === PROMPTED_SCREENING_PROFILE;
+    const command = prompted
+        ? PROMPTED_BINARY_QUALIFICATION_VERIFICATION_COMMAND
+        : BINARY_QUALIFICATION_VERIFICATION_COMMAND;
+    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"] });
     }
     if (claim.verification.checks.length !== READER_VERIFICATION_CHECKS.length
         || claim.verification.checks.some((check, index) => check !== READER_VERIFICATION_CHECKS[index])) {
@@ -635,6 +645,10 @@ export function buildClaimPackage(input) {
             + " — a claim stating primitives the sealed Run does not carry would be dishonest");
     }
     const projection = methodProjection(reportRecord);
+    // Prompted screening is an authenticated Run-level admission fact. Every report/claim emitted
+    // from that Run uses the v2 reader, including its companion method claims; the binary claim's
+    // own schema separately binds the same exact profile in its method parameters.
+    const promptedScreening = input.runRecord.analysisPlan?.some((entry) => entry.parameters["promptedScreeningProfile"] === PROMPTED_SCREENING_PROFILE) === true;
     const disclosuresPerSubject = (reportRecord.disclosures?.perSubject ?? []);
     const taskCount = new Set(input.matrixRecord.cells.map((cell) => cell.taskDigest)).size;
     // anchor-evidence §7.4: the anchored closure is entered by the CALLER, by supplying the section
@@ -695,14 +709,18 @@ export function buildClaimPackage(input) {
         verification: {
             command: anchored
                 ? PUBLIC_BUNDLE_V6_VERIFICATION_COMMAND
-                : projection.qualification === undefined
-                    ? PUBLIC_BUNDLE_VERIFICATION_COMMAND
-                    : BINARY_QUALIFICATION_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
-                : projection.qualification === undefined
-                    ? PUBLIC_BUNDLE_COMPATIBLE_VERIFICATION_COMMAND
-                    : BINARY_QUALIFICATION_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],
             // §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.

package/dist/profile/pinning-evidence.d.ts

@@ -16,8 +16,8 @@ export declare const RunPinningEvidenceSchema: z.ZodObject<{
     }, z.core.$strict>>;
     observations: z.ZodOptional<z.ZodArray<z.ZodObject<{
         axis: z.ZodEnum<{
-            harness: "harness";
             model: "model";
+            harness: "harness";
             loadout: "loadout";
             isolation: "isolation";
         }>;

package/dist/schema.d.ts

@@ -6,9 +6,9 @@ export declare const BUNDLE_ASSEMBLY_FORMAT: "benchmark-product-assembly/2";
 export declare const BUNDLE_V4_TRUST_FORMAT: "benchmark-product-public-trust/4";
 export declare const BUNDLE_V4_EVIDENCE_FORMAT: "benchmark-product-evidence-catalog/4";
 export declare const BUNDLE_QUALIFICATION_FORMAT: "benchmark-product-binary-qualification/1";
-export declare const BUNDLE_V4_EVIDENCE_ROLES: readonly ["task", "runtime-selection", "evaluation-spec", "admission-receipt", "solve-submission", "run-pinning-evidence", "evaluation-submission", "solve-delivery", "solve-output", "evaluation-task", "evaluation-delivery", "verdict", "item-bank", "source-manifest", "admission-index", "admission-manifest", "replacement-ledger", "source-item", "judge-instrument", "analysis-context", "label-resolution", "human-review-evaluation-spec", "human-review-form", "human-review-packet", "human-review-response", "human-review-verdict", "reviewer-roster", "review-visibility-receipt", "review-reveal-receipt", "operator-assertion", "snapshot-probe", "screening-table", "screening-reveal-receipt", "screening-instrument", "screening-sampling-script", "screening-raw-outputs"];
+export declare const BUNDLE_V4_EVIDENCE_ROLES: readonly ["task", "runtime-selection", "evaluation-spec", "admission-receipt", "solve-submission", "run-pinning-evidence", "evaluation-submission", "solve-delivery", "solve-output", "evaluation-task", "evaluation-delivery", "verdict", "item-bank", "source-manifest", "admission-index", "admission-manifest", "replacement-ledger", "source-item", "judge-instrument", "analysis-context", "label-resolution", "human-review-evaluation-spec", "human-review-form", "human-review-packet", "human-review-response", "human-review-verdict", "reviewer-roster", "review-visibility-receipt", "review-reveal-receipt", "operator-assertion", "snapshot-probe", "screening-table", "screening-reveal-receipt", "screening-instrument", "screening-sampling-script", "screening-raw-outputs", "screening-prompt", "screening-procedure", "screening-pool", "screening-sample-commitment", "screening-transcript"];
 export type BundleV4EvidenceRole = (typeof BUNDLE_V4_EVIDENCE_ROLES)[number];
-export declare const BUNDLE_V4_ADMISSION_EVIDENCE_ROLES: readonly ["admission-manifest", "replacement-ledger", "source-item", "label-resolution", "analysis-context", "human-review-evaluation-spec", "human-review-form", "human-review-packet", "human-review-response", "human-review-verdict", "reviewer-roster", "review-visibility-receipt", "review-reveal-receipt", "operator-assertion", "screening-table", "screening-reveal-receipt", "screening-instrument", "screening-sampling-script", "screening-raw-outputs"];
+export declare const BUNDLE_V4_ADMISSION_EVIDENCE_ROLES: readonly ["admission-manifest", "replacement-ledger", "source-item", "label-resolution", "analysis-context", "human-review-evaluation-spec", "human-review-form", "human-review-packet", "human-review-response", "human-review-verdict", "reviewer-roster", "review-visibility-receipt", "review-reveal-receipt", "operator-assertion", "screening-table", "screening-reveal-receipt", "screening-instrument", "screening-sampling-script", "screening-raw-outputs", "screening-prompt", "screening-procedure", "screening-pool", "screening-sample-commitment", "screening-transcript"];
 export declare const BundleTrustSchema: z.ZodObject<{
     format: z.ZodLiteral<"benchmark-product-public-trust/2">;
     selfRun: z.ZodObject<{
@@ -76,6 +76,7 @@ export declare const BundleEvidenceCatalogSchema: z.ZodObject<{
     records: z.ZodArray<z.ZodObject<{
         sha256: z.ZodString;
         roles: z.ZodArray<z.ZodEnum<{
+            verdict: "verdict";
             task: "task";
             "runtime-selection": "runtime-selection";
             "evaluation-spec": "evaluation-spec";
@@ -87,7 +88,6 @@ export declare const BundleEvidenceCatalogSchema: z.ZodObject<{
             "solve-output": "solve-output";
             "evaluation-task": "evaluation-task";
             "evaluation-delivery": "evaluation-delivery";
-            verdict: "verdict";
             "judge-instrument": "judge-instrument";
             "analysis-context": "analysis-context";
             "label-resolution": "label-resolution";
@@ -100,6 +100,7 @@ export declare const BundleV4EvidenceCatalogSchema: z.ZodObject<{
     records: z.ZodArray<z.ZodObject<{
         sha256: z.ZodString;
         roles: z.ZodArray<z.ZodEnum<{
+            verdict: "verdict";
             task: "task";
             "runtime-selection": "runtime-selection";
             "evaluation-spec": "evaluation-spec";
@@ -111,7 +112,6 @@ export declare const BundleV4EvidenceCatalogSchema: z.ZodObject<{
             "solve-output": "solve-output";
             "evaluation-task": "evaluation-task";
             "evaluation-delivery": "evaluation-delivery";
-            verdict: "verdict";
             "item-bank": "item-bank";
             "source-manifest": "source-manifest";
             "admission-index": "admission-index";
@@ -136,6 +136,11 @@ export declare const BundleV4EvidenceCatalogSchema: z.ZodObject<{
             "screening-instrument": "screening-instrument";
             "screening-sampling-script": "screening-sampling-script";
             "screening-raw-outputs": "screening-raw-outputs";
+            "screening-prompt": "screening-prompt";
+            "screening-procedure": "screening-procedure";
+            "screening-pool": "screening-pool";
+            "screening-sample-commitment": "screening-sample-commitment";
+            "screening-transcript": "screening-transcript";
         }>>;
     }, z.core.$strict>>;
 }, z.core.$strict>;
@@ -197,6 +202,11 @@ export declare const BundleQualificationSchema: z.ZodObject<{
             "screening-instrument": "screening-instrument";
             "screening-sampling-script": "screening-sampling-script";
             "screening-raw-outputs": "screening-raw-outputs";
+            "screening-prompt": "screening-prompt";
+            "screening-procedure": "screening-procedure";
+            "screening-pool": "screening-pool";
+            "screening-sample-commitment": "screening-sample-commitment";
+            "screening-transcript": "screening-transcript";
         }>>;
     }, z.core.$strict>>;
     reachableSha256s: z.ZodArray<z.ZodString>;

package/dist/schema.js

@@ -52,6 +52,11 @@ export const BUNDLE_V4_EVIDENCE_ROLES = [
     "screening-instrument",
     "screening-sampling-script",
     "screening-raw-outputs",
+    "screening-prompt",
+    "screening-procedure",
+    "screening-pool",
+    "screening-sample-commitment",
+    "screening-transcript",
 ];
 export const BUNDLE_V4_ADMISSION_EVIDENCE_ROLES = [
     "admission-manifest", "replacement-ledger", "source-item", "label-resolution",
@@ -68,6 +73,11 @@ export const BUNDLE_V4_ADMISSION_EVIDENCE_ROLES = [
     "screening-instrument",
     "screening-sampling-script",
     "screening-raw-outputs",
+    "screening-prompt",
+    "screening-procedure",
+    "screening-pool",
+    "screening-sample-commitment",
+    "screening-transcript",
 ];
 const PublicKeySchema = z.object({
     keyId: z.string().min(1),
@@ -317,12 +327,11 @@ export const BundleQualificationSchema = z.strictObject({
         "human-review-packet", "human-review-response", "human-review-verdict", "reviewer-roster",
         "review-visibility-receipt", "review-reveal-receipt",
     ];
-    const screeningEvidenceRoles = [
-        "screening-table",
-        "screening-reveal-receipt",
-        "screening-instrument",
-        "screening-sampling-script",
-        "screening-raw-outputs",
+    const commonScreeningEvidenceRoles = ["screening-table", "screening-reveal-receipt", "screening-sampling-script"];
+    const legacyScreeningEvidenceRoles = ["screening-instrument", "screening-raw-outputs"];
+    const promptedScreeningEvidenceRoles = [
+        "screening-prompt", "screening-procedure", "screening-pool",
+        "screening-sample-commitment", "screening-transcript",
     ];
     if (qualification.truthAdmission === "two-human-unanimous") {
         if (humanEvidenceRoles.some((role) => (roleCounts.get(role) ?? 0) === 0)
@@ -340,10 +349,15 @@ export const BundleQualificationSchema = z.strictObject({
         // silently inheriting the screened one's evidence rules.
     }
     else if (qualification.truthAdmission === "screened-operator-sampled") {
-        if (screeningEvidenceRoles.some((role) => (roleCounts.get(role) ?? 0) !== 1)
+        const legacyRoleSet = legacyScreeningEvidenceRoles.every((role) => roleCounts.get(role) === 1)
+            && promptedScreeningEvidenceRoles.every((role) => roleCounts.get(role) === 0);
+        const promptedRoleSet = promptedScreeningEvidenceRoles.every((role) => roleCounts.get(role) === 1)
+            && legacyScreeningEvidenceRoles.every((role) => roleCounts.get(role) === 0);
+        if (commonScreeningEvidenceRoles.some((role) => (roleCounts.get(role) ?? 0) !== 1)
+            || (!legacyRoleSet && !promptedRoleSet)
             || humanEvidenceRoles.some((role) => (roleCounts.get(role) ?? 0) !== 0)
             || (roleCounts.get("operator-assertion") ?? 0) !== 0) {
-            ctx.addIssue({ code: "custom", path: ["admissionRecords"], message: "screened admission must carry exactly one of every screening record and no human-review evidence or operator assertion" });
+            ctx.addIssue({ code: "custom", path: ["admissionRecords"], message: "screened admission must carry exactly one complete legacy-v1 or prompted-v2 screening record set and no human-review evidence or operator assertion" });
         }
         const screeningInstrument = qualification.admissionRecords.find((entry) => (entry.roles.includes("screening-instrument")));
         if (screeningInstrument !== undefined

package/dist/version.d.ts

@@ -1,2 +1,2 @@
 /** Public verifier release line. Kept in one module for output and bundle instructions. */
-export declare const VERIFIER_VERSION: "0.1.0";
+export declare const VERIFIER_VERSION: "0.2.0";

package/dist/version.js

@@ -1,2 +1,2 @@
 /** Public verifier release line. Kept in one module for output and bundle instructions. */
-export const VERIFIER_VERSION = "0.1.0";
+export const VERIFIER_VERSION = "0.2.0";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@colophon-claims/verify",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Standalone public-bundle verifier for Colophon claims.",
   "type": "module",
   "engines": {
@@ -47,28 +47,28 @@
     "@fontsource-variable/newsreader": "5.3.0",
     "@fontsource-variable/public-sans": "5.3.0",
     "@fontsource/ibm-plex-mono": "5.3.0",
-    "@jinn-network/benchmarking-aggregate": "0.1.0-canary.sha.1ed36166faf16ea4b96b021ceff0397f83a0a80c",
-    "@jinn-network/benchmarking-evidence": "0.1.0-canary.sha.1ed36166faf16ea4b96b021ceff0397f83a0a80c",
-    "@jinn-network/benchmarking-interop": "0.1.0-canary.sha.1ed36166faf16ea4b96b021ceff0397f83a0a80c",
-    "@jinn-network/benchmarking-local": "0.1.0-canary.sha.1ed36166faf16ea4b96b021ceff0397f83a0a80c",
-    "@jinn-network/benchmarking-protocol": "0.1.0-canary.sha.1ed36166faf16ea4b96b021ceff0397f83a0a80c",
-    "@jinn-network/benchmarking-records": "0.1.0-canary.sha.1ed36166faf16ea4b96b021ceff0397f83a0a80c",
-    "@jinn-network/benchmarking-run": "0.1.0-canary.sha.1ed36166faf16ea4b96b021ceff0397f83a0a80c",
-    "@jinn-network/task-admission": "0.1.0-canary.sha.1ed36166faf16ea4b96b021ceff0397f83a0a80c",
-    "@jinn-network/task-execution-profiles": "0.1.0-canary.sha.1ed36166faf16ea4b96b021ceff0397f83a0a80c",
-    "@jinn-network/task-execution-protocol": "0.1.0-canary.sha.1ed36166faf16ea4b96b021ceff0397f83a0a80c",
-    "@jinn-network/trust-core": "0.1.0-canary.sha.1ed36166faf16ea4b96b021ceff0397f83a0a80c",
+    "@jinn-network/benchmarking-aggregate": "0.1.0-canary.sha.e00b2fc47fc5635b007eb349fb1e41aa81bb3c50",
+    "@jinn-network/benchmarking-evidence": "0.1.0-canary.sha.e00b2fc47fc5635b007eb349fb1e41aa81bb3c50",
+    "@jinn-network/benchmarking-interop": "0.1.0-canary.sha.e00b2fc47fc5635b007eb349fb1e41aa81bb3c50",
+    "@jinn-network/benchmarking-local": "0.1.0-canary.sha.e00b2fc47fc5635b007eb349fb1e41aa81bb3c50",
+    "@jinn-network/benchmarking-protocol": "0.1.0-canary.sha.e00b2fc47fc5635b007eb349fb1e41aa81bb3c50",
+    "@jinn-network/benchmarking-records": "0.1.0-canary.sha.e00b2fc47fc5635b007eb349fb1e41aa81bb3c50",
+    "@jinn-network/benchmarking-run": "0.1.0-canary.sha.e00b2fc47fc5635b007eb349fb1e41aa81bb3c50",
+    "@jinn-network/task-admission": "0.1.0-canary.sha.e00b2fc47fc5635b007eb349fb1e41aa81bb3c50",
+    "@jinn-network/task-execution-profiles": "0.1.0-canary.sha.e00b2fc47fc5635b007eb349fb1e41aa81bb3c50",
+    "@jinn-network/task-execution-protocol": "0.1.0-canary.sha.e00b2fc47fc5635b007eb349fb1e41aa81bb3c50",
+    "@jinn-network/trust-core": "0.1.0-canary.sha.e00b2fc47fc5635b007eb349fb1e41aa81bb3c50",
     "zod": "4.4.3"
   },
   "resolutions": {
     "@noble/hashes": "2.2.0"
   },
   "devDependencies": {
-    "@jinn-network/trust-testing": "0.1.0-canary.sha.1ed36166faf16ea4b96b021ceff0397f83a0a80c",
+    "@jinn-network/trust-testing": "0.1.0-canary.sha.e00b2fc47fc5635b007eb349fb1e41aa81bb3c50",
     "@types/node": "^22.0.0",
     "ajv": "8.17.1",
     "typescript": "^5.9.3",
     "vitest": "^4.1.8"
   },
-  "gitHead": "2f249073718111afd810127ff7bbbc19b206dc93"
+  "gitHead": "892a10067cc653d4971b22d77aea716b617ef2d6"
 }