@colophon-claims/verify 0.1.0 → 0.2.1

package/dist/admission/contracts.js

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

package/dist/admission/index.d.ts

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

package/dist/admission/index.js

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

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

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

package/dist/admission/prompted-commitment.js

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

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

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

package/dist/admission/prompted-selection.js

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

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 {
@@ -40,6 +40,7 @@ export interface VerifiedBinaryJudgmentAdmissionExclusion {
     readonly stratum: string;
     readonly reason: "review-disagreement" | "review-indeterminate" | "review-incomplete" | "screening-disagreement" | "screening-indeterminate" | "screening-hand-excluded";
     readonly replacementItemSha256: AdmissionSha256;
+    readonly receivingSlotId?: string;
 }
 export interface VerifiedBinaryJudgmentAdmissionClosure {
     readonly manifestSha256: AdmissionSha256;
@@ -57,12 +58,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);