@colophon-claims/verify 0.0.0 → 0.2.0

package/dist/profile/artifacts.js

@@ -0,0 +1,139 @@
+import { evaluateVerdictRule } from "@jinn-network/task-execution-profiles";
+import { z } from "zod";
+import { isInspectMultiScorerSelection } from "./inspect-manifest.js";
+export const INSPECT_TASK_PROFILE_URI = "https://product.jinn.network/profiles/inspect-evaluation/1";
+export const INSPECT_EMBEDDED_EVALUATOR_ID = "urn:jinn:benchmark-product:inspect-runtime:same-execution-scorer";
+const InspectProviderEvidenceSchema = z.object({
+    surface: z.literal("openai-responses"),
+    resolvedModel: z.string().nullable(),
+    callCount: z.number().int().nonnegative(),
+    usage: z.record(z.string(), z.unknown()).nullable(),
+    terminalStatus: z.enum([
+        "completed",
+        "authentication-failure",
+        "rate-limited",
+        "timeout",
+        "broker-loss",
+        "provider-5xx",
+        "provider-failure",
+        "budget-rejected",
+        "method-conflict",
+        "capability-rejected",
+        "malformed-request",
+        "no-call",
+    ]),
+    eventDigest: z.string().regex(/^[a-f0-9]{64}$/).nullable(),
+    brokerProtocol: z.literal("jinn.network/model-broker/1"),
+    brokerSourceSha256: z.string().regex(/^[a-f0-9]{64}$/),
+}).strict();
+export const InspectCellSummaryV1Schema = z.object({
+    schema: z.literal("jinn.network/benchmark-product/inspect-cell-summary/1"),
+    terminal: z.enum(["scored", "unscorable"]),
+    inspectStatus: z.enum(["started", "success", "cancelled", "error"]),
+    expectedSamples: z.number().int().nonnegative().nullable(),
+    observedSamples: z.number().int().nonnegative(),
+    erroredSamples: z.number().int().nonnegative(),
+    missingScoreSamples: z.number().int().nonnegative(),
+    invalidated: z.boolean(),
+    scorer: z.string().min(1),
+    verdict: z.enum(["pass", "fail"]).nullable(),
+    measurement: z.boolean().nullable(),
+    evaluatedAt: z.string().datetime({ offset: true }),
+    nativeLogSha256: z.string().regex(/^[a-f0-9]{64}$/),
+    nativeLogBytes: z.number().int().nonnegative(),
+    provider: InspectProviderEvidenceSchema.optional(),
+});
+export const InspectCellSummaryV2Schema = z.object({
+    schema: z.literal("jinn.network/benchmark-product/inspect-cell-summary/2"),
+    terminal: z.enum(["scored", "unscorable"]),
+    inspectStatus: z.enum(["started", "success", "cancelled", "error"]),
+    expectedSamples: z.number().int().nonnegative().nullable(),
+    observedSamples: z.number().int().nonnegative(),
+    erroredSamples: z.number().int().nonnegative(),
+    invalidated: z.boolean(),
+    scorers: z.array(z.object({
+        name: z.string().min(1),
+        presentSamples: z.number().int().nonnegative(),
+        missingSamples: z.number().int().nonnegative(),
+        valueShapes: z.array(z.enum(["null", "boolean", "number", "string", "list", "object"])),
+    }).strict()).min(1),
+    measurements: z.array(z.object({
+        measurementName: z.string().min(1),
+        scorerName: z.string().min(1),
+        subScoreKey: z.string().min(1).optional(),
+        missingSamples: z.number().int().nonnegative(),
+        invalidValueSamples: z.number().int().nonnegative(),
+        value: z.boolean().nullable(),
+    }).strict()).min(1),
+    verdict: z.enum(["pass", "fail", "inconclusive"]).nullable(),
+    evaluatedAt: z.string().datetime({ offset: true }),
+    nativeLogSha256: z.string().regex(/^[a-f0-9]{64}$/),
+    nativeLogBytes: z.number().int().nonnegative(),
+    provider: InspectProviderEvidenceSchema.optional(),
+    sandbox: z.object({
+        provider: z.literal("jinn-oci"),
+        protocol: z.literal("jinn.network/inspect-sandbox-host/1"),
+        imageDigest: z.string().regex(/^sha256:[a-f0-9]{64}$/),
+        environmentCount: z.number().int().nonnegative(),
+        operationCount: z.number().int().nonnegative(),
+        eventDigest: z.string().regex(/^[a-f0-9]{64}$/),
+    }).strict().optional(),
+}).strict();
+export const InspectCellSummarySchema = z.union([InspectCellSummaryV1Schema, InspectCellSummaryV2Schema]);
+const SCORE_SHAPE_ORDER = ["null", "boolean", "number", "string", "list", "object"];
+function equalStrings(left, right) {
+    return left.length === right.length && left.every((value, index) => value === right[index]);
+}
+/** Validate the product projection and return the only verdict authorized by its sealed rule. */
+export function projectInspectCellVerdict(summary, manifest) {
+    if (!isInspectMultiScorerSelection(manifest)) {
+        throw new TypeError("Inspect summary v2 requires a multi-scorer selection manifest");
+    }
+    const scorerNames = summary.scorers.map((scorer) => scorer.name);
+    if (!equalStrings(scorerNames, manifest.scorers.map((scorer) => scorer.name))) {
+        throw new TypeError("Inspect scorer inventory differs from the sealed ordered scorer set");
+    }
+    for (const scorer of summary.scorers) {
+        if (scorer.presentSamples + scorer.missingSamples !== summary.observedSamples) {
+            throw new TypeError("Inspect scorer inventory does not account for every observed sample");
+        }
+        const canonicalShapes = SCORE_SHAPE_ORDER.filter((shape) => scorer.valueShapes.includes(shape));
+        if (!equalStrings(scorer.valueShapes, canonicalShapes)) {
+            throw new TypeError("Inspect scorer value shapes are duplicated or non-canonical");
+        }
+    }
+    if (summary.measurements.length !== manifest.scoring.projections.length) {
+        throw new TypeError("Inspect summary measurement count differs from the sealed projections");
+    }
+    const values = {};
+    summary.measurements.forEach((measurement, index) => {
+        const projection = manifest.scoring.projections[index];
+        if (measurement.measurementName !== projection.measurementName
+            || measurement.scorerName !== projection.scorerName
+            || measurement.subScoreKey !== projection.subScoreKey
+            || measurement.missingSamples + measurement.invalidValueSamples > summary.observedSamples) {
+            throw new TypeError("Inspect summary measurement differs from its sealed projection");
+        }
+        if (summary.terminal === "scored") {
+            if (measurement.value === null
+                || measurement.missingSamples !== 0
+                || measurement.invalidValueSamples !== 0) {
+                throw new TypeError("scored Inspect summary carries an incomplete projected measurement");
+            }
+            values[measurement.measurementName] = measurement.value;
+        }
+        else if (measurement.value !== null) {
+            throw new TypeError("unscorable Inspect summary carries a projected measurement value");
+        }
+    });
+    if (summary.terminal === "unscorable")
+        return null;
+    if (summary.inspectStatus !== "success"
+        || summary.invalidated
+        || summary.erroredSamples !== 0
+        || summary.expectedSamples === null
+        || summary.expectedSamples !== summary.observedSamples) {
+        throw new TypeError("scored Inspect summary contradicts its run/sample accounting");
+    }
+    return evaluateVerdictRule(manifest.scoring.verdictRule, values).verdict;
+}

package/dist/profile/assembly-ports.d.ts

@@ -0,0 +1,19 @@
+import { type KeyObject } from "node:crypto";
+import type { RunRecord } from "@jinn-network/benchmarking-records";
+import type { AssemblyPorts, InScopeCell } from "@jinn-network/benchmarking-run";
+import type { LocalAdmissionReceiptFact } from "./admission-receipts.js";
+export interface AssemblyPublicKeyRecord {
+    readonly keyId: string;
+    readonly publicKey: KeyObject;
+}
+export interface BuildAssemblyPortsFromFactsInput {
+    readonly runRecord: RunRecord;
+    readonly cells: readonly InScopeCell[];
+    readonly owner: string;
+    readonly runCancelled: boolean;
+    readonly receiptsByTaskDigest: ReadonlyMap<string, LocalAdmissionReceiptFact>;
+    readonly resolveBytes: (digest: string) => Uint8Array;
+    readonly evaluatorKeys: () => ReadonlyMap<string, AssemblyPublicKeyRecord>;
+}
+/** Reconstructs the Matrix verifier ports exclusively from authenticated bundle facts. */
+export declare function buildAssemblyPortsFromFacts(input: BuildAssemblyPortsFromFactsInput): AssemblyPorts;

package/dist/profile/assembly-ports.js

@@ -0,0 +1,42 @@
+import { verify as cryptoVerify } from "node:crypto";
+import { localAssemblyPorts } from "@jinn-network/benchmarking-local";
+import { dssePreAuthEncoding, parseDsseEnvelope } from "@jinn-network/trust-core";
+import { venueIsolationPostureForPolicy } from "./isolation.js";
+function resolveEvaluatorClaim(resolveBytes, evidenceRef, loadKeys) {
+    try {
+        const ref = evidenceRef;
+        if (typeof ref?.claim !== "string" || typeof ref.verdictDigest !== "string" || !ref.verdictDigest.startsWith("sha256:"))
+            return "unresolved";
+        const key = loadKeys().get(ref.claim);
+        if (key === undefined)
+            return "unresolved";
+        const envelope = parseDsseEnvelope(resolveBytes(ref.verdictDigest.slice("sha256:".length)));
+        const preAuth = Buffer.from(dssePreAuthEncoding(envelope.payloadType, envelope.payloadBytes));
+        return envelope.signatures.some((signature) => signature.keyid === key.keyId && cryptoVerify(null, preAuth, key.publicKey, Buffer.from(signature.sig, "base64"))) ? ref.claim : "unresolved";
+    }
+    catch {
+        return "unresolved";
+    }
+}
+/** Reconstructs the Matrix verifier ports exclusively from authenticated bundle facts. */
+export function buildAssemblyPortsFromFacts(input) {
+    const baseline = input.runRecord.policy.submissionBaseline;
+    const isolation = venueIsolationPostureForPolicy(baseline.isolationPolicy);
+    return localAssemblyPorts({
+        inputScope: { cellsForRun: () => [...input.cells], ...(input.runCancelled ? { runCancelled: true } : {}) },
+        pinning: {
+            submissionBaseline: baseline,
+            isolationInventory: isolation.inventory,
+            evidenceFor: (cellKey) => {
+                const cell = input.cells.find((candidate) => candidate.cellKey === cellKey);
+                if (cell === undefined || cell.dispatches === 0)
+                    return { dispatches: 0 };
+                const evidence = cell.evidenceRef;
+                return evidence === undefined ? { dispatches: cell.dispatches } : { ...evidence, dispatches: cell.dispatches };
+            },
+        },
+        admission: { receiptFor: (cell) => input.receiptsByTaskDigest.get(cell.taskDigest) },
+        cost: { costFor: () => undefined, latencyFor: () => undefined },
+        trust: { resolveAgent: async (ref) => ref?.role === "solver" ? input.owner : ref?.role === "evaluator" ? resolveEvaluatorClaim(input.resolveBytes, ref, input.evaluatorKeys) : "unresolved" },
+    });
+}

package/dist/profile/binary-judge-manifest.d.ts

@@ -0,0 +1,121 @@
+import { z } from "zod";
+export declare const INSPECT_BINARY_JUDGE_ADAPTER_ID: "inspect-binary-judge";
+export declare const INSPECT_BINARY_JUDGE_LAUNCHER_ID: "inspect-ai-judge";
+export declare const INSPECT_BINARY_JUDGE_LAUNCHER_VERSION: "1";
+export declare const INSPECT_BINARY_JUDGE_SELECTION_SCHEMA: "jinn.network/benchmark-product/inspect-binary-judge-selection/1";
+export declare const INSPECT_SELECTION_CORRELATION_ROLE: "https://product.jinn.network/artifact-roles/inspect/selection-manifest/v1";
+export declare const INSPECT_BINARY_JUDGE_INSPECT_VERSION: "0.3.255";
+export declare const INSPECT_BINARY_JUDGE_INSPECT_EVALS_VERSION: "0.16.0";
+export declare const INSPECT_BINARY_JUDGE_OPENAI_SDK_VERSION: "2.53.0";
+export declare const INSPECT_BINARY_JUDGE_PYTHON_VERSION: "3.11.9";
+export declare const INSPECT_BINARY_JUDGE_OCI_PLATFORM: "linux/amd64";
+export declare const InspectBinaryJudgeArmSchema: z.ZodObject<{
+    armId: z.ZodString;
+    instrumentSha256: z.ZodString;
+    model: z.ZodEnum<{
+        "gpt-5.6-luna": "gpt-5.6-luna";
+        "gpt-4o-mini-2024-07-18": "gpt-4o-mini-2024-07-18";
+    }>;
+    generation: z.ZodUnion<readonly [z.ZodObject<{
+        reasoningEffort: z.ZodEnum<{
+            none: "none";
+            low: "low";
+        }>;
+        maxOutputTokens: z.ZodLiteral<128>;
+        store: z.ZodLiteral<false>;
+        background: z.ZodLiteral<false>;
+        stream: z.ZodLiteral<false>;
+        serviceTier: z.ZodLiteral<"default">;
+        tools: z.ZodTuple<[], null>;
+        fallbackModels: z.ZodTuple<[], null>;
+        retries: z.ZodLiteral<0>;
+        persistedConversation: z.ZodLiteral<false>;
+        metadata: z.ZodNull;
+        promptCacheIdentifier: z.ZodNull;
+    }, z.core.$strict>, z.ZodObject<{
+        temperature: z.ZodLiteral<0>;
+        maxOutputTokens: z.ZodLiteral<512>;
+        store: z.ZodLiteral<false>;
+        background: z.ZodLiteral<false>;
+        stream: z.ZodLiteral<false>;
+        serviceTier: z.ZodLiteral<"default">;
+        tools: z.ZodTuple<[], null>;
+        fallbackModels: z.ZodTuple<[], null>;
+        retries: z.ZodLiteral<0>;
+        persistedConversation: z.ZodLiteral<false>;
+        metadata: z.ZodNull;
+        promptCacheIdentifier: z.ZodNull;
+    }, z.core.$strict>]>;
+}, z.core.$strict>;
+export type InspectBinaryJudgeArm = z.infer<typeof InspectBinaryJudgeArmSchema>;
+/** Portable public selection for the binary judge runtime. Host paths and credentials are absent. */
+export declare const InspectBinaryJudgeSelectionManifestSchema: z.ZodObject<{
+    schema: z.ZodLiteral<"jinn.network/benchmark-product/inspect-binary-judge-selection/1">;
+    runtime: z.ZodObject<{
+        imageDigest: z.ZodString;
+        platform: z.ZodLiteral<"linux/amd64">;
+        pythonVersion: z.ZodLiteral<"3.11.9">;
+        inspectVersion: z.ZodLiteral<"0.3.255">;
+        inspectEvalsVersion: z.ZodLiteral<"0.16.0">;
+        openaiSdkVersion: z.ZodLiteral<"2.53.0">;
+        runtimeHostSourceSha256: z.ZodString;
+        workerSourceSha256: z.ZodString;
+        brokerSourceSha256: z.ZodString;
+        modelProviderSourceSha256: z.ZodString;
+    }, z.core.$strict>;
+    execution: z.ZodObject<{
+        callsPerCell: z.ZodLiteral<1>;
+        epochs: z.ZodLiteral<1>;
+        inspectScorer: z.ZodLiteral<false>;
+        retries: z.ZodLiteral<0>;
+        fallbacks: z.ZodLiteral<0>;
+        tools: z.ZodTuple<[], null>;
+        storage: z.ZodLiteral<false>;
+    }, z.core.$strict>;
+    requirement: z.ZodObject<{
+        key: z.ZodLiteral<"network.jinn.binary-judgment.instrument">;
+        valueShape: z.ZodLiteral<"sha256:<64-lowercase-hex>">;
+        comparison: z.ZodLiteral<"exact">;
+        location: z.ZodLiteral<"submission-effective-requirements">;
+    }, z.core.$strict>;
+    arms: z.ZodArray<z.ZodObject<{
+        armId: z.ZodString;
+        instrumentSha256: z.ZodString;
+        model: z.ZodEnum<{
+            "gpt-5.6-luna": "gpt-5.6-luna";
+            "gpt-4o-mini-2024-07-18": "gpt-4o-mini-2024-07-18";
+        }>;
+        generation: z.ZodUnion<readonly [z.ZodObject<{
+            reasoningEffort: z.ZodEnum<{
+                none: "none";
+                low: "low";
+            }>;
+            maxOutputTokens: z.ZodLiteral<128>;
+            store: z.ZodLiteral<false>;
+            background: z.ZodLiteral<false>;
+            stream: z.ZodLiteral<false>;
+            serviceTier: z.ZodLiteral<"default">;
+            tools: z.ZodTuple<[], null>;
+            fallbackModels: z.ZodTuple<[], null>;
+            retries: z.ZodLiteral<0>;
+            persistedConversation: z.ZodLiteral<false>;
+            metadata: z.ZodNull;
+            promptCacheIdentifier: z.ZodNull;
+        }, z.core.$strict>, z.ZodObject<{
+            temperature: z.ZodLiteral<0>;
+            maxOutputTokens: z.ZodLiteral<512>;
+            store: z.ZodLiteral<false>;
+            background: z.ZodLiteral<false>;
+            stream: z.ZodLiteral<false>;
+            serviceTier: z.ZodLiteral<"default">;
+            tools: z.ZodTuple<[], null>;
+            fallbackModels: z.ZodTuple<[], null>;
+            retries: z.ZodLiteral<0>;
+            persistedConversation: z.ZodLiteral<false>;
+            metadata: z.ZodNull;
+            promptCacheIdentifier: z.ZodNull;
+        }, z.core.$strict>]>;
+    }, z.core.$strict>>;
+    snapshotProbeSha256: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type InspectBinaryJudgeSelectionManifest = z.infer<typeof InspectBinaryJudgeSelectionManifestSchema>;

package/dist/profile/binary-judge-manifest.js

@@ -0,0 +1,106 @@
+import { z } from "zod";
+import { ACCEPTED_JUDGE_MODEL_IDS, BINARY_JUDGMENT_INSTRUMENT_REQUIREMENT_KEY, BinaryJudgmentGenerationSchema, isDatedSnapshotJudgeModel, judgeGenerationProfile, JUDGE_MODEL_PROFILES, } from "@jinn-network/task-execution-profiles";
+import { compareCodeUnitStrings } from "@jinn-network/task-execution-protocol";
+export const INSPECT_BINARY_JUDGE_ADAPTER_ID = "inspect-binary-judge";
+export const INSPECT_BINARY_JUDGE_LAUNCHER_ID = "inspect-ai-judge";
+export const INSPECT_BINARY_JUDGE_LAUNCHER_VERSION = "1";
+export const INSPECT_BINARY_JUDGE_SELECTION_SCHEMA = "jinn.network/benchmark-product/inspect-binary-judge-selection/1";
+export const INSPECT_SELECTION_CORRELATION_ROLE = "https://product.jinn.network/artifact-roles/inspect/selection-manifest/v1";
+export const INSPECT_BINARY_JUDGE_INSPECT_VERSION = "0.3.255";
+export const INSPECT_BINARY_JUDGE_INSPECT_EVALS_VERSION = "0.16.0";
+export const INSPECT_BINARY_JUDGE_OPENAI_SDK_VERSION = "2.53.0";
+export const INSPECT_BINARY_JUDGE_PYTHON_VERSION = "3.11.9";
+export const INSPECT_BINARY_JUDGE_OCI_PLATFORM = "linux/amd64";
+const Sha256HexSchema = z.string().regex(/^[0-9a-f]{64}$/u);
+const Sha256DigestSchema = z.string().regex(/^sha256:[0-9a-f]{64}$/u);
+export const InspectBinaryJudgeArmSchema = z.strictObject({
+    armId: z.string().regex(/^[A-Za-z0-9_-]{1,64}$/u),
+    instrumentSha256: Sha256DigestSchema,
+    model: z.enum(ACCEPTED_JUDGE_MODEL_IDS),
+    generation: BinaryJudgmentGenerationSchema,
+}).superRefine((arm, ctx) => {
+    // The third parent-level refinement spec §1.3 requires. The generation union cannot carry its
+    // own discriminator, and here the sibling `model` key lives on this arm object, so the arm is
+    // the parent. Without this, the permissive union alone would admit a reasoning generation block
+    // on a dated snapshot (or vice versa); this is what closes it.
+    const modelProfile = JUDGE_MODEL_PROFILES[arm.model];
+    const generationProfile = judgeGenerationProfile(arm.generation);
+    if (generationProfile !== modelProfile) {
+        ctx.addIssue({
+            code: "custom",
+            path: ["generation"],
+            message: `generation must match the ${modelProfile} profile for model ${arm.model}`,
+        });
+    }
+});
+/** Portable public selection for the binary judge runtime. Host paths and credentials are absent. */
+export const InspectBinaryJudgeSelectionManifestSchema = z.strictObject({
+    schema: z.literal(INSPECT_BINARY_JUDGE_SELECTION_SCHEMA),
+    runtime: z.strictObject({
+        imageDigest: Sha256DigestSchema,
+        platform: z.literal(INSPECT_BINARY_JUDGE_OCI_PLATFORM),
+        pythonVersion: z.literal(INSPECT_BINARY_JUDGE_PYTHON_VERSION),
+        inspectVersion: z.literal(INSPECT_BINARY_JUDGE_INSPECT_VERSION),
+        inspectEvalsVersion: z.literal(INSPECT_BINARY_JUDGE_INSPECT_EVALS_VERSION),
+        openaiSdkVersion: z.literal(INSPECT_BINARY_JUDGE_OPENAI_SDK_VERSION),
+        runtimeHostSourceSha256: Sha256HexSchema,
+        workerSourceSha256: Sha256HexSchema,
+        brokerSourceSha256: Sha256HexSchema,
+        modelProviderSourceSha256: Sha256HexSchema,
+    }),
+    execution: z.strictObject({
+        callsPerCell: z.literal(1),
+        epochs: z.literal(1),
+        inspectScorer: z.literal(false),
+        retries: z.literal(0),
+        fallbacks: z.literal(0),
+        tools: z.tuple([]),
+        storage: z.literal(false),
+    }),
+    requirement: z.strictObject({
+        key: z.literal(BINARY_JUDGMENT_INSTRUMENT_REQUIREMENT_KEY),
+        valueShape: z.literal("sha256:<64-lowercase-hex>"),
+        comparison: z.literal("exact"),
+        location: z.literal("submission-effective-requirements"),
+    }),
+    arms: z.array(InspectBinaryJudgeArmSchema).min(2),
+    // Optional (spec §1.5 rule 2): required when any bound arm's model is a dated snapshot,
+    // forbidden otherwise. This selection manifest's digest already flows into
+    // `draft.spec.evaluationRuntime.selectionManifestSha256` and from there into the sealed Run at
+    // lock, so the probe is bound into the run's identity with no new plumbing — it is a lock input
+    // by construction. Because the field is optional and absent on every existing selection, every
+    // existing sealed selection stays byte-identical (§0.4).
+    snapshotProbeSha256: Sha256DigestSchema.optional(),
+}).superRefine((manifest, context) => {
+    const armIds = manifest.arms.map((arm) => arm.armId);
+    if (new Set(armIds).size !== armIds.length) {
+        context.addIssue({ code: "custom", path: ["arms"], message: "armId values must be unique" });
+    }
+    const sortedArmIds = [...armIds].sort(compareCodeUnitStrings);
+    if (armIds.some((armId, index) => armId !== sortedArmIds[index])) {
+        context.addIssue({ code: "custom", path: ["arms"], message: "arms must be code-unit sorted by armId" });
+    }
+    const instruments = manifest.arms.map((arm) => arm.instrumentSha256);
+    if (new Set(instruments).size !== instruments.length) {
+        context.addIssue({ code: "custom", path: ["arms"], message: "each judge arm must bind one distinct instrument digest" });
+    }
+    const generation = JSON.stringify(manifest.arms[0]?.generation);
+    if (manifest.arms.some((arm) => JSON.stringify(arm.generation) !== generation)) {
+        context.addIssue({ code: "custom", path: ["arms"], message: "all arms must share one identical generation block" });
+    }
+    const requiresProbe = manifest.arms.some((arm) => isDatedSnapshotJudgeModel(arm.model));
+    if (requiresProbe && manifest.snapshotProbeSha256 === undefined) {
+        context.addIssue({
+            code: "custom",
+            path: ["snapshotProbeSha256"],
+            message: "snapshotProbeSha256 is required when any bound arm's model is a dated snapshot",
+        });
+    }
+    if (!requiresProbe && manifest.snapshotProbeSha256 !== undefined) {
+        context.addIssue({
+            code: "custom",
+            path: ["snapshotProbeSha256"],
+            message: "snapshotProbeSha256 is forbidden unless a bound arm's model is a dated snapshot",
+        });
+    }
+});

package/dist/profile/binary-qualification.d.ts

@@ -0,0 +1,9 @@
+export declare const BINARY_INSTRUMENT_REPORT_LIMITATIONS: {
+    readonly mutableModelAlias: "The gpt-5.6-luna identifier is a mutable provider alias; this evidence does not prove invariant model weights across calls.";
+    readonly reviewerKeyPerson: "Distinct reviewer signing keys prove key control, not that the controllers are distinct people.";
+    readonly cognitiveBlinding: "Signed visibility and reveal receipts attest the review protocol; they do not technically prove cognitive blinding.";
+    readonly operatorOnly: "Truth uses operator-only admission and is not publication-grade two-human unanimous truth.";
+    readonly screenedNotIndependentlyLabeled: string;
+};
+/** Portable disclosure projection from the registered binary-instrument method parameters. */
+export declare function binaryInstrumentReportLimitations(parameters: Readonly<Record<string, unknown>>): readonly string[];

package/dist/profile/binary-qualification.js

@@ -0,0 +1,58 @@
+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.",
+    cognitiveBlinding: "Signed visibility and reveal receipts attest the review protocol; they do not technically prove cognitive blinding.",
+    operatorOnly: "Truth uses operator-only admission and is not publication-grade two-human unanimous truth.",
+    // Prose, not the spec's bare kebab identifier `screened-not-independently-labeled` (spec §6.8,
+    // ruling C-1): that identifier is the limitation's NAME, and every other entry in this map is a
+    // full sentence, rendered on the public page (`assets.ts`) and byte-compared at cold
+    // verification (`claim-consistency.ts`). Passes §6.1's overclaim test: no "unanimous", no
+    // "independent" as an affirmative claim -- "human reviewers" appears only as the disclosed
+    // absence, which is the point of a limitation string.
+    screenedNotIndependentlyLabeled: "Truth uses screened-operator-sampled admission: a pinned model screens every item and the "
+        + "operator hand-checks the flagged set plus a random sample; this proves screen-hand "
+        + "agreement on that sample, not independent two-human truth.",
+};
+/** Portable disclosure projection from the registered binary-instrument method parameters. */
+export function binaryInstrumentReportLimitations(parameters) {
+    const validation = validateBinaryInstrumentParameters(parameters);
+    if (!validation.ok) {
+        throw new TypeError(`invalid sealed binary-instrument parameters: ${validation.issues.join("; ")}`);
+    }
+    return [
+        // Absent, or any profile other than dated-snapshot-sampling, means "emit the alias
+        // limitation" — today's behavior byte for byte (spec §1.4 clause 2). This is not a default of
+        // convenience: the two frozen 144-cell golden fixtures seal parameters with no
+        // judgeModelProfile, so they must keep emitting this string in this position to stay green
+        // unmodified. Flipping the absent case to "emit nothing" would move those fixtures' bytes and
+        // destroy the compatibility proof this program depends on.
+        ...(parameters["judgeModelProfile"] === "dated-snapshot-sampling"
+            ? []
+            : [BINARY_INSTRUMENT_REPORT_LIMITATIONS.mutableModelAlias]),
+        // reviewerKeyPerson and cognitiveBlinding are claims about a two-reviewer protocol; an
+        // operator-only run has no reviewers and no visibility receipts at all, so emitting them there
+        // is a false limitation (spec §1.4 clause 4). truthAdmission is already a sealed parameter, so
+        // this needs no new key.
+        ...(parameters["truthAdmission"] === "two-human-unanimous"
+            ? [
+                BINARY_INSTRUMENT_REPORT_LIMITATIONS.reviewerKeyPerson,
+                BINARY_INSTRUMENT_REPORT_LIMITATIONS.cognitiveBlinding,
+            ]
+            : []),
+        ...(parameters["truthAdmission"] === "operator-only"
+            ? [BINARY_INSTRUMENT_REPORT_LIMITATIONS.operatorOnly]
+            : []),
+        // Appended AFTER the operator-only arm (ruling C-3): the return is a positional array and the
+        // two frozen 144-cell goldens depend on the existing entries keeping their indices.
+        ...(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/branding-assets.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Canonical Colophon mark imported from the approved design-system source bundle.
+ * Keep this byte-for-byte aligned with `design-system/reference/assets/mark.svg`.
+ */
+export declare const COLOPHON_MARK_SVG = "<svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 32 32\" width=\"32\" height=\"32\" role=\"img\" aria-label=\"Colophon mark\"><g fill=\"currentColor\"><rect x=\"12.5\" y=\"1.5\" width=\"7\" height=\"7\" transform=\"rotate(45 16 5)\"></rect><rect x=\"2.5\" y=\"19.5\" width=\"7\" height=\"7\" transform=\"rotate(45 6 23)\"></rect><rect x=\"22.5\" y=\"19.5\" width=\"7\" height=\"7\" transform=\"rotate(45 26 23)\"></rect></g></svg>";

package/dist/profile/branding-assets.js

@@ -0,0 +1,5 @@
+/**
+ * Canonical Colophon mark imported from the approved design-system source bundle.
+ * Keep this byte-for-byte aligned with `design-system/reference/assets/mark.svg`.
+ */
+export const COLOPHON_MARK_SVG = `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 32 32" width="32" height="32" role="img" aria-label="Colophon mark"><g fill="currentColor"><rect x="12.5" y="1.5" width="7" height="7" transform="rotate(45 16 5)"></rect><rect x="2.5" y="19.5" width="7" height="7" transform="rotate(45 6 23)"></rect><rect x="22.5" y="19.5" width="7" height="7" transform="rotate(45 26 23)"></rect></g></svg>`;

package/dist/profile/branding.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Branding isolation for the standalone benchmark product.
+ *
+ * See docs/superpowers/specs/2026-08-05-benchmark-product-design.md §9
+ * ("Branding isolation") for the design rationale this module implements.
+ */
+/**
+ * The product's identity and attribution — the single source consumed
+ * everywhere a product name or attribution appears (CLI banner, GUI chrome,
+ * report presentation, claim assets).
+ *
+ * `attribution` is factual, and appears only in about/verification contexts
+ * — never in the product name, primary navigation, category explanation, or
+ * hero copy.
+ */
+export interface ProductBranding {
+    readonly displayName: string;
+    readonly categoryDescriptor: string;
+    readonly tagline: string;
+    readonly promise: string;
+    readonly attribution: string;
+    readonly commandName: string;
+}
+export declare const PRODUCT_BRANDING: ProductBranding;

package/dist/profile/branding.js

@@ -0,0 +1,14 @@
+/**
+ * Branding isolation for the standalone benchmark product.
+ *
+ * See docs/superpowers/specs/2026-08-05-benchmark-product-design.md §9
+ * ("Branding isolation") for the design rationale this module implements.
+ */
+export const PRODUCT_BRANDING = {
+    displayName: "Colophon",
+    categoryDescriptor: "Benchmark publishing for agent configurations",
+    tagline: "Compare agents on the same work.",
+    promise: "Publish benchmark claims people can check.",
+    attribution: "Built on Jinn.",
+    commandName: "colophon",
+};

package/dist/profile/claim-consistency.d.ts

@@ -0,0 +1,26 @@
+import { type BenchmarkRecord, type MatrixRecord, type ReportRecord, type RunRecord } from "@jinn-network/benchmarking-records";
+import { type ClaimPackage } from "./claim.js";
+import type { ClaimAnchor } from "./anchor-claims.js";
+export interface ClaimRecordIdentities {
+    readonly benchmarkSha256: string;
+    readonly runSha256: string;
+    readonly matrixSha256: string;
+    readonly reportSha256: string | undefined;
+    readonly reportEnvelopeSha256: string;
+}
+export declare function assertClaimConsistency(input: {
+    readonly claim: ClaimPackage;
+    readonly identities: ClaimRecordIdentities;
+    readonly benchmarkRecord: BenchmarkRecord;
+    readonly runRecord: RunRecord;
+    readonly matrixRecord: MatrixRecord;
+    readonly reportRecord: ReportRecord;
+    readonly draftId: string;
+    readonly assurancePreset: string;
+    readonly additionalLimitations?: readonly string[];
+    readonly rehearsal?: {
+        readonly previewCount: number;
+        readonly timestamps: readonly string[];
+    }; /** anchor-evidence §7.4: the anchors section re-derived from the carried AnchorEvidence bytes, never read from the claim under test. */
+    readonly anchors?: readonly ClaimAnchor[];
+}): void;