@colophon-claims/verify 0.0.0 → 0.2.0

package/README.md

@@ -0,0 +1,39 @@
+# @colophon-claims/verify
+
+Verify a public Colophon claim bundle without the Colophon app or any execution runtime:
+
+```sh
+npx @colophon-claims/verify@0.2 ./bundle
+```
+
+Use `--json` for machine-readable output. The reader runs the checks declared by the
+bundle format, covering its manifest, evidence closure, calculations, report, and claim
+consistency. Exit status is `0` when every check passes, `1` for an invalid bundle, and
+`2` for usage or operational failures.
+
+This 0.2 reader supports public bundle formats v2, v4, v5, and v6. It intentionally
+rejects the unrelated accounting bundle v3. Formats v2 and v4 run six checks; the
+evidence-native v5 and anchored v6 formats run seven.
+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
+consistency. It does not prove that the producing machine was honest or that the compared
+identities are independent parties.
+
+Bundles are also verifiable without this package: `../EXTERNAL-VERIFICATION.md` specifies
+the external path (openssl plus a dependency-free script, shipped here as
+`scripts/external-verify.py`), the JSON Schemas under `schemas/`, and the conformance kit
+under `fixtures/public-bundle-conformance-v1/` for testing an independent verifier.
+
+## What this does not yet prove
+
+Protocol identifiers in the installed platform packages name `https://spec.jinn.network/…`.
+That origin is not hosted yet. This verifier checks the bundle against the exact
+`@jinn-network/*` bytes installed from npm. A third party who fetches those identifiers
+from the live origin will not retrieve them.

package/dist/admission/application.d.ts

@@ -0,0 +1,18 @@
+import { type BinaryJudgmentPayload, type EvaluationSpec } from "@jinn-network/task-execution-profiles";
+export declare const HUMAN_REVIEW_FORM: {
+    readonly protocol: "https://spec.jinn.network/binary-judgment/human-review-form/v1";
+    readonly question: "Is the candidate answer correct relative to the question and reference answer?";
+    readonly labels: readonly ["CORRECT", "WRONG", "indeterminate"];
+    readonly completeReviewRequired: true;
+    readonly rationale: "optional";
+};
+export declare const HUMAN_REVIEW_FORM_SEALED: {
+    bytes: Uint8Array;
+    digest: `sha256:${string}`;
+};
+export declare function binaryJudgmentItemBytes(item: BinaryJudgmentPayload): Uint8Array;
+export declare function buildBinaryJudgmentHumanReviewEvaluationSpec(): EvaluationSpec;
+export declare const BINARY_JUDGMENT_HUMAN_REVIEW_EVALUATION_SPEC_SEALED: {
+    bytes: Uint8Array;
+    digest: `sha256:${string}`;
+};

package/dist/admission/application.js

@@ -0,0 +1,53 @@
+// SPDX-License-Identifier: Apache-2.0
+import { EVALUATION_SPEC_FORMAT_URI, EVAL_SEMANTICS_VERSION, canonicalJsonBytes, sealDocument, sealEvaluationSpec, } from "@jinn-network/task-execution-profiles";
+export const HUMAN_REVIEW_FORM = {
+    protocol: "https://spec.jinn.network/binary-judgment/human-review-form/v1",
+    question: "Is the candidate answer correct relative to the question and reference answer?",
+    labels: ["CORRECT", "WRONG", "indeterminate"],
+    completeReviewRequired: true,
+    rationale: "optional",
+};
+export const HUMAN_REVIEW_FORM_SEALED = sealDocument(HUMAN_REVIEW_FORM);
+export function binaryJudgmentItemBytes(item) {
+    return canonicalJsonBytes(item);
+}
+export function buildBinaryJudgmentHumanReviewEvaluationSpec() {
+    return {
+        protocol: EVALUATION_SPEC_FORMAT_URI,
+        semanticsVersion: EVAL_SEMANTICS_VERSION,
+        family: "human-review",
+        grader: {
+            name: "external-human-review",
+            uri: HUMAN_REVIEW_FORM.protocol,
+            digest: { sha256: HUMAN_REVIEW_FORM_SEALED.digest.slice("sha256:".length) },
+            mediaType: "application/vnd.jinn.binary-judgment.human-review-form.v1+json",
+            accessClass: "public",
+        },
+        familyBlock: {
+            reviewForm: {
+                name: "human-review-form.json",
+                uri: HUMAN_REVIEW_FORM.protocol,
+                digest: { sha256: HUMAN_REVIEW_FORM_SEALED.digest.slice("sha256:".length) },
+                mediaType: "application/vnd.jinn.binary-judgment.human-review-form.v1+json",
+            },
+            reviewerQualifications: { roleDeclaredInRoster: true },
+            attestationShape: {
+                labels: ["CORRECT", "WRONG", "indeterminate"],
+                completeReviewRequired: true,
+            },
+        },
+        measurements: [
+            { name: "truthLabel", type: "string", direction: "none", required: true },
+            { name: "reviewComplete", type: "boolean", direction: "none", required: true },
+            { name: "reviewPacketSha256", type: "string", direction: "none", required: true },
+            { name: "visibilityReceiptSha256", type: "string", direction: "none", required: true },
+            { name: "responseSha256", type: "string", direction: "none", required: true },
+        ],
+        verdictRule: { threshold: { measurement: "truthLabel", op: "eq", value: "CORRECT" } },
+        unscorable: [{ name: "indeterminate", disposition: "recorded-inconclusive" }],
+        evidenceConventions: {
+            requiredRefs: ["human-review-packet", "visibility-receipt", "human-review-response"],
+        },
+    };
+}
+export const BINARY_JUDGMENT_HUMAN_REVIEW_EVALUATION_SPEC_SEALED = sealEvaluationSpec(buildBinaryJudgmentHumanReviewEvaluationSpec());

package/dist/admission/contracts.d.ts

@@ -0,0 +1,506 @@
+import { z } from "zod";
+export declare const HUMAN_REVIEW_PACKET_PROTOCOL: "https://spec.jinn.network/binary-judgment/human-review-packet/v1";
+export declare const HUMAN_REVIEW_RESPONSE_PROTOCOL: "https://spec.jinn.network/binary-judgment/human-review-response/v1";
+export declare const HUMAN_REVIEW_VISIBILITY_RECEIPT_PROTOCOL: "https://spec.jinn.network/binary-judgment/visibility-receipt/v1";
+export declare const HUMAN_REVIEW_ROSTER_PROTOCOL: "https://spec.jinn.network/binary-judgment/reviewer-roster/v1";
+export declare const HUMAN_REVIEW_REVEAL_RECEIPT_PROTOCOL: "https://spec.jinn.network/binary-judgment/reveal-receipt/v1";
+export declare const HUMAN_REVIEW_REPLACEMENT_LEDGER_PROTOCOL: "https://spec.jinn.network/binary-judgment/replacement-ledger/v1";
+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";
+export declare const HUMAN_REVIEW_VISIBILITY_RECEIPT_MEDIA_TYPE: "application/vnd.jinn.binary-judgment.visibility-receipt.v1+json";
+export declare const HUMAN_REVIEW_ROSTER_MEDIA_TYPE: "application/vnd.jinn.binary-judgment.reviewer-roster.v1+json";
+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<{
+    protocol: z.ZodLiteral<"https://spec.jinn.network/binary-judgment/human-review-packet/v1">;
+    itemSha256: z.ZodString;
+    item: z.ZodObject<{
+        itemId: z.ZodString;
+        question: z.ZodString;
+        referenceAnswer: z.ZodString;
+        candidateAnswer: z.ZodString;
+        evidence: z.ZodOptional<z.ZodString>;
+        provenance: z.ZodObject<{
+            sourceCommitment: z.ZodString;
+            timestamp: z.ZodString;
+        }, z.core.$strict>;
+        sources: z.ZodArray<z.ZodObject<{
+            digest: z.ZodObject<{
+                sha256: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    evaluationSpecSha256: z.ZodString;
+    reviewerId: z.ZodString;
+    form: z.ZodObject<{
+        question: z.ZodLiteral<"Is the candidate answer correct relative to the question and reference answer?">;
+        labels: z.ZodTuple<[z.ZodLiteral<"CORRECT">, z.ZodLiteral<"WRONG">, z.ZodLiteral<"indeterminate">], null>;
+        completeReviewRequired: z.ZodLiteral<true>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type HumanReviewPacket = z.infer<typeof HumanReviewPacketSchema>;
+export declare const HumanReviewVisibilityReceiptSchema: z.ZodObject<{
+    protocol: z.ZodLiteral<"https://spec.jinn.network/binary-judgment/visibility-receipt/v1">;
+    packetSha256: z.ZodString;
+    itemSha256: z.ZodString;
+    reviewerId: z.ZodString;
+    omittedFields: z.ZodTuple<[z.ZodLiteral<"instrumentIdentity">, z.ZodLiteral<"candidateClass">, z.ZodLiteral<"stratum">, z.ZodLiteral<"otherReview">, z.ZodLiteral<"postRunOutcomes">], null>;
+    issuedAt: z.ZodString;
+}, z.core.$strict>;
+export type HumanReviewVisibilityReceipt = z.infer<typeof HumanReviewVisibilityReceiptSchema>;
+export declare const HumanReviewResponseSchema: z.ZodObject<{
+    protocol: z.ZodLiteral<"https://spec.jinn.network/binary-judgment/human-review-response/v1">;
+    packetSha256: z.ZodString;
+    visibilityReceiptSha256: z.ZodString;
+    itemSha256: z.ZodString;
+    evaluatorId: z.ZodString;
+    label: z.ZodUnion<readonly [z.ZodEnum<{
+        CORRECT: "CORRECT";
+        WRONG: "WRONG";
+    }>, z.ZodLiteral<"indeterminate">]>;
+    complete: z.ZodBoolean;
+    completedAt: z.ZodString;
+}, z.core.$strict>;
+export type HumanReviewResponse = z.infer<typeof HumanReviewResponseSchema>;
+export declare const ReviewerDeclarationSchema: z.ZodObject<{
+    evaluatorId: z.ZodString;
+    keyId: z.ZodString;
+    personId: z.ZodString;
+    role: z.ZodString;
+    conflicts: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+export declare const HumanReviewRosterSchema: z.ZodObject<{
+    protocol: z.ZodLiteral<"https://spec.jinn.network/binary-judgment/reviewer-roster/v1">;
+    itemSha256: z.ZodString;
+    reviewers: z.ZodTuple<[z.ZodObject<{
+        evaluatorId: z.ZodString;
+        keyId: z.ZodString;
+        personId: z.ZodString;
+        role: z.ZodString;
+        conflicts: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        evaluatorId: z.ZodString;
+        keyId: z.ZodString;
+        personId: z.ZodString;
+        role: z.ZodString;
+        conflicts: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>], null>;
+    attestedBy: z.ZodString;
+    attestorKeyId: z.ZodString;
+    attestorRole: z.ZodLiteral<"roster-attestor">;
+    attestedAt: z.ZodString;
+}, z.core.$strict>;
+export type HumanReviewRoster = z.infer<typeof HumanReviewRosterSchema>;
+export declare const HumanReviewRevealReceiptSchema: z.ZodObject<{
+    protocol: z.ZodLiteral<"https://spec.jinn.network/binary-judgment/reveal-receipt/v1">;
+    draftId: z.ZodString;
+    itemSha256: z.ZodString;
+    truthFrozenAt: z.ZodString;
+    judgeExecutionState: z.ZodLiteral<"not-started">;
+    attestedBy: z.ZodString;
+    attestorKeyId: z.ZodString;
+    attestorRole: z.ZodLiteral<"truth-reveal-attestor">;
+}, z.core.$strict>;
+export type HumanReviewRevealReceipt = z.infer<typeof HumanReviewRevealReceiptSchema>;
+/**
+ * `screening-reveal-receipt/v1` (spec §6.6): a bank-scoped sibling of `HumanReviewRevealReceiptSchema`
+ * above. Same ordering primitive, same attestor role, same `judgeExecutionState: "not-started"`
+ * gate — differing only in subject: the bank (`screeningTableSha256`), not an item (`itemSha256`).
+ * `AdmissionAuthorityRole` (`verify/src/admission/verification.ts`) is deliberately unchanged: this
+ * reuses `truth-reveal-attestor` rather than minting a new role.
+ */
+export declare const ScreeningRevealReceiptSchema: z.ZodObject<{
+    protocol: z.ZodLiteral<"https://spec.jinn.network/binary-judgment/screening-reveal-receipt/v1">;
+    draftId: z.ZodString;
+    screeningTableSha256: z.ZodString;
+    truthFrozenAt: z.ZodString;
+    judgeExecutionState: z.ZodLiteral<"not-started">;
+    attestedBy: z.ZodString;
+    attestorKeyId: z.ZodString;
+    attestorRole: z.ZodLiteral<"truth-reveal-attestor">;
+}, z.core.$strict>;
+export type ScreeningRevealReceipt = z.infer<typeof ScreeningRevealReceiptSchema>;
+/**
+ * One row of the `screening-table/v1` record (spec §6.3). `handVerdict` is present if and only if
+ * `handChecked === true`; both directions refuse. `handVerdict` deliberately does not reuse
+ * `BinaryJudgmentTruthLabelSchema` — the hand-check outcome space is confirm-or-exclude only, with
+ * no label corrections.
+ */
+export declare const ScreeningRowSchema: z.ZodObject<{
+    itemSha256: z.ZodString;
+    intendedLabel: z.ZodEnum<{
+        CORRECT: "CORRECT";
+        WRONG: "WRONG";
+    }>;
+    screeningVerdict: z.ZodUnion<readonly [z.ZodEnum<{
+        CORRECT: "CORRECT";
+        WRONG: "WRONG";
+    }>, z.ZodLiteral<"indeterminate">]>;
+    handChecked: z.ZodBoolean;
+    handVerdict: z.ZodOptional<z.ZodEnum<{
+        confirm: "confirm";
+        exclude: "exclude";
+    }>>;
+}, z.core.$strict>;
+export type ScreeningRow = z.infer<typeof ScreeningRowSchema>;
+/**
+ * `screening-table/v1` (spec §6.3): one signed record per bank. Every derived quantity (the
+ * flagged set, the sample, the exclusions, the agreement rate) is a *view* of this table, never a
+ * stored field that can disagree with it — those recomputations live in `screening-sample.ts` and
+ * its siblings, not here. `screeningModel` is deliberately absent: it is derivable from
+ * `screeningInstrumentSha256`, and a second copy is a second thing to drift. The table is signed
+ * once, over the whole record, on the existing DSSE signing path used by the other admission
+ * records (`sealRoleEvidence`), not the ledger's non-DSSE path.
+ */
+export declare const ScreeningTableSchema: z.ZodObject<{
+    protocol: z.ZodLiteral<"https://spec.jinn.network/binary-judgment/screening-table/v1">;
+    draftId: z.ZodString;
+    screeningInstrumentSha256: z.ZodString;
+    sampleSeed: z.ZodString;
+    sampleSize: z.ZodNumber;
+    samplingScriptSha256: z.ZodString;
+    rawOutputsSha256: z.ZodString;
+    rows: z.ZodArray<z.ZodObject<{
+        itemSha256: z.ZodString;
+        intendedLabel: z.ZodEnum<{
+            CORRECT: "CORRECT";
+            WRONG: "WRONG";
+        }>;
+        screeningVerdict: z.ZodUnion<readonly [z.ZodEnum<{
+            CORRECT: "CORRECT";
+            WRONG: "WRONG";
+        }>, z.ZodLiteral<"indeterminate">]>;
+        handChecked: z.ZodBoolean;
+        handVerdict: z.ZodOptional<z.ZodEnum<{
+            confirm: "confirm";
+            exclude: "exclude";
+        }>>;
+    }, z.core.$strict>>;
+    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;
+    candidateClass: z.ZodString;
+    stratum: z.ZodString;
+    excludedPoolPosition: z.ZodNumber;
+    replacementPoolPosition: z.ZodNumber;
+    reason: z.ZodEnum<{
+        "review-disagreement": "review-disagreement";
+        "review-indeterminate": "review-indeterminate";
+        "review-incomplete": "review-incomplete";
+        "screening-disagreement": "screening-disagreement";
+        "screening-indeterminate": "screening-indeterminate";
+        "screening-hand-excluded": "screening-hand-excluded";
+    }>;
+    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>;
+    revealReceiptSha256: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export declare const HumanReviewReplacementLedgerSchema: z.ZodObject<{
+    protocol: z.ZodLiteral<"https://spec.jinn.network/binary-judgment/replacement-ledger/v1">;
+    draftId: z.ZodString;
+    entries: z.ZodArray<z.ZodObject<{
+        excludedItemSha256: z.ZodString;
+        replacementItemSha256: z.ZodString;
+        candidateClass: z.ZodString;
+        stratum: z.ZodString;
+        excludedPoolPosition: z.ZodNumber;
+        replacementPoolPosition: z.ZodNumber;
+        reason: z.ZodEnum<{
+            "review-disagreement": "review-disagreement";
+            "review-indeterminate": "review-indeterminate";
+            "review-incomplete": "review-incomplete";
+            "screening-disagreement": "screening-disagreement";
+            "screening-indeterminate": "screening-indeterminate";
+            "screening-hand-excluded": "screening-hand-excluded";
+        }>;
+        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>;
+        revealReceiptSha256: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    sealedAt: z.ZodString;
+}, z.core.$strict>;
+export type HumanReviewReplacementLedger = z.infer<typeof HumanReviewReplacementLedgerSchema>;
+export declare const HumanReviewOperatorAssertionSchema: z.ZodObject<{
+    protocol: z.ZodLiteral<"https://spec.jinn.network/binary-judgment/operator-truth-assertion/v1">;
+    itemSha256: z.ZodString;
+    truthLabel: z.ZodEnum<{
+        CORRECT: "CORRECT";
+        WRONG: "WRONG";
+    }>;
+    assertedBy: z.ZodString;
+    assertedAt: z.ZodString;
+    attestorKeyId: z.ZodString;
+    attestorRole: z.ZodLiteral<"operator-truth-attestor">;
+    limitation: z.ZodLiteral<"operator-only-not-publication-grade">;
+}, z.core.$strict>;
+export type HumanReviewOperatorAssertion = z.infer<typeof HumanReviewOperatorAssertionSchema>;
+export declare const BinaryJudgmentAdmissionManifestSchema: z.ZodObject<{
+    protocol: z.ZodLiteral<"https://spec.jinn.network/binary-judgment/admission-manifest/v1">;
+    draftId: z.ZodString;
+    truthAdmission: z.ZodEnum<{
+        "two-human-unanimous": "two-human-unanimous";
+        "operator-only": "operator-only";
+        "screened-operator-sampled": "screened-operator-sampled";
+    }>;
+    labelResolutionSha256s: z.ZodArray<z.ZodString>;
+    analysisContextSha256s: z.ZodArray<z.ZodString>;
+    excludedItemSha256s: z.ZodArray<z.ZodString>;
+    replacementLedgerSha256: z.ZodString;
+    screeningTableSha256: z.ZodOptional<z.ZodString>;
+    admittedAt: z.ZodString;
+}, z.core.$strict>;
+export type BinaryJudgmentAdmissionManifest = z.infer<typeof BinaryJudgmentAdmissionManifestSchema>;