@colophon-claims/verify 0.1.0 → 0.2.1

package/README.md

@@ -3,19 +3,33 @@
 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
 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.1 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.
+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 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
 nothing. It checks the bundle's integrity, evidence closure, calculations, report, and claim

package/dist/admission/contracts.d.ts

@@ -8,6 +8,13 @@ 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_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";
 export declare const HUMAN_REVIEW_RESPONSE_MEDIA_TYPE: "application/vnd.jinn.binary-judgment.human-review-response.v1+json";
@@ -16,6 +23,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 +194,479 @@ 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 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;
+    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>;
+/**
+ * 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<{
+        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;
@@ -201,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>;
@@ -224,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>;