@colophon-claims/verify 0.0.0 → 0.2.0

package/dist/version.d.ts

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

package/dist/version.js

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

package/package.json

@@ -1,14 +1,74 @@
 {
   "name": "@colophon-claims/verify",
-  "version": "0.0.0",
-  "description": "Bootstrap placeholder. The first Colophon verifier cut is 2.0.0 from GitHub Actions.",
+  "version": "0.2.0",
+  "description": "Standalone public-bundle verifier for Colophon claims.",
+  "type": "module",
+  "engines": {
+    "node": ">=22"
+  },
   "license": "MIT",
   "repository": {
     "type": "git",
     "url": "https://github.com/Jinn-Network/mono.git",
     "directory": "packages/benchmark-product/verify"
   },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    },
+    "./admission": {
+      "import": "./dist/admission/index.js",
+      "types": "./dist/admission/index.d.ts"
+    }
+  },
+  "bin": {
+    "colophon-verify": "./dist/bin.js"
+  },
+  "files": [
+    "dist/",
+    "schemas/",
+    "scripts/external-verify.py",
+    "README.md"
+  ],
   "publishConfig": {
     "access": "public"
-  }
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "typecheck": "tsc --noEmit -p tsconfig.json",
+    "test": "yarn build && node --test test/*.test.mjs && vitest run",
+    "pack:smoke": "node scripts/pack-smoke.mjs",
+    "prepack": "npm run build"
+  },
+  "dependencies": {
+    "@fontsource-variable/newsreader": "5.3.0",
+    "@fontsource-variable/public-sans": "5.3.0",
+    "@fontsource/ibm-plex-mono": "5.3.0",
+    "@jinn-network/benchmarking-aggregate": "0.1.0-canary.sha.e00b2fc47fc5635b007eb349fb1e41aa81bb3c50",
+    "@jinn-network/benchmarking-evidence": "0.1.0-canary.sha.e00b2fc47fc5635b007eb349fb1e41aa81bb3c50",
+    "@jinn-network/benchmarking-interop": "0.1.0-canary.sha.e00b2fc47fc5635b007eb349fb1e41aa81bb3c50",
+    "@jinn-network/benchmarking-local": "0.1.0-canary.sha.e00b2fc47fc5635b007eb349fb1e41aa81bb3c50",
+    "@jinn-network/benchmarking-protocol": "0.1.0-canary.sha.e00b2fc47fc5635b007eb349fb1e41aa81bb3c50",
+    "@jinn-network/benchmarking-records": "0.1.0-canary.sha.e00b2fc47fc5635b007eb349fb1e41aa81bb3c50",
+    "@jinn-network/benchmarking-run": "0.1.0-canary.sha.e00b2fc47fc5635b007eb349fb1e41aa81bb3c50",
+    "@jinn-network/task-admission": "0.1.0-canary.sha.e00b2fc47fc5635b007eb349fb1e41aa81bb3c50",
+    "@jinn-network/task-execution-profiles": "0.1.0-canary.sha.e00b2fc47fc5635b007eb349fb1e41aa81bb3c50",
+    "@jinn-network/task-execution-protocol": "0.1.0-canary.sha.e00b2fc47fc5635b007eb349fb1e41aa81bb3c50",
+    "@jinn-network/trust-core": "0.1.0-canary.sha.e00b2fc47fc5635b007eb349fb1e41aa81bb3c50",
+    "zod": "4.4.3"
+  },
+  "resolutions": {
+    "@noble/hashes": "2.2.0"
+  },
+  "devDependencies": {
+    "@jinn-network/trust-testing": "0.1.0-canary.sha.e00b2fc47fc5635b007eb349fb1e41aa81bb3c50",
+    "@types/node": "^22.0.0",
+    "ajv": "8.17.1",
+    "typescript": "^5.9.3",
+    "vitest": "^4.1.8"
+  },
+  "gitHead": "892a10067cc653d4971b22d77aea716b617ef2d6"
 }

package/schemas/assembly-row.schema.json

@@ -0,0 +1,194 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$comment": "Describes one row of verification/assembly.jsonl (format benchmark-product-assembly/2): the first row is the run header, every following row is one matrix cell. Source of truth: BundleAssemblyHeaderSchema and BundleAssemblyCellSchema in @colophon-claims/verify src/schema.ts (open objects there, so unknown members are permitted here). The verifier additionally requires each row to be canonical JSON, cellKeys to be unique, and the graph edges to close exactly against the content-addressed records, the matrix, and the verdict catalog.",
+  "description": "One JSONL row of a benchmark-product public bundle's verification assembly.",
+  "oneOf": [
+    { "$ref": "#/$defs/header" },
+    { "$ref": "#/$defs/cell" }
+  ],
+  "$defs": {
+    "sha256": { "type": "string", "pattern": "^[a-f0-9]{64}$" },
+    "namedOutput": {
+      "type": "object",
+      "properties": {
+        "name": { "type": "string" },
+        "sha256": { "$ref": "#/$defs/sha256" }
+      },
+      "required": ["name", "sha256"]
+    },
+    "verdict": {
+      "type": "object",
+      "properties": {
+        "sha256": { "$ref": "#/$defs/sha256" },
+        "relationship": { "enum": ["same-execution-scorer", "separate-log-verifier"] },
+        "evalTaskSha256": { "$ref": "#/$defs/sha256" },
+        "evalSubmissionSha256": { "$ref": "#/$defs/sha256" },
+        "evalDeliverySha256": { "$ref": "#/$defs/sha256" },
+        "evalAttempt": { "type": "string", "minLength": 1 },
+        "evalIndex": { "type": "integer", "minimum": 1 },
+        "evaluator": { "type": "string", "minLength": 1 },
+        "verdict": { "enum": ["pass", "fail", "inconclusive"] },
+        "evaluationSpecSha256": { "$ref": "#/$defs/sha256" },
+        "measurements": {
+          "type": "object",
+          "additionalProperties": { "type": ["string", "number", "boolean"] }
+        }
+      },
+      "required": ["sha256", "evalIndex", "evaluator", "verdict", "evaluationSpecSha256", "measurements"]
+    },
+    "header": {
+      "type": "object",
+      "properties": {
+        "format": { "const": "benchmark-product-assembly/2" },
+        "kind": { "const": "run" },
+        "runCancelled": { "type": "boolean" },
+        "draftId": { "type": "string", "minLength": 1 },
+        "assurancePreset": { "type": "string", "minLength": 1 },
+        "rehearsal": {
+          "type": "object",
+          "properties": {
+            "previewCount": { "type": "integer", "minimum": 1 },
+            "timestamps": {
+              "type": "array",
+              "items": { "type": "string", "format": "date-time" },
+              "minItems": 1
+            }
+          },
+          "required": ["previewCount", "timestamps"]
+        },
+        "graph": {
+          "type": "object",
+          "properties": {
+            "admissions": {
+              "type": "array",
+              "items": {
+                "type": "object",
+                "properties": {
+                  "taskSha256": { "$ref": "#/$defs/sha256" },
+                  "receiptSha256": { "$ref": "#/$defs/sha256" }
+                },
+                "required": ["taskSha256", "receiptSha256"]
+              }
+            },
+            "solveSubmissions": {
+              "type": "array",
+              "items": {
+                "type": "object",
+                "properties": {
+                  "cellKey": { "type": "string", "minLength": 1 },
+                  "dispatch": { "type": "integer", "minimum": 1 },
+                  "sha256": { "$ref": "#/$defs/sha256" },
+                  "pinningEvidenceSha256": { "$ref": "#/$defs/sha256" }
+                },
+                "required": ["cellKey", "dispatch", "sha256"]
+              }
+            },
+            "evaluationSubmissions": {
+              "type": "array",
+              "items": {
+                "type": "object",
+                "properties": {
+                  "cellKey": { "type": "string", "minLength": 1 },
+                  "dispatch": { "type": "integer", "minimum": 1 },
+                  "evalIndex": { "type": "integer", "minimum": 1 },
+                  "evaluationAttempt": { "type": "integer", "minimum": 1 },
+                  "evaluator": { "type": "string", "minLength": 1 },
+                  "evalTaskSha256": { "$ref": "#/$defs/sha256" },
+                  "sha256": { "$ref": "#/$defs/sha256" }
+                },
+                "required": ["cellKey", "dispatch", "evalIndex", "evaluator", "evalTaskSha256", "sha256"]
+              }
+            },
+            "solveDeliveries": {
+              "type": "array",
+              "items": {
+                "type": "object",
+                "properties": {
+                  "cellKey": { "type": "string", "minLength": 1 },
+                  "dispatch": { "type": "integer", "minimum": 1 },
+                  "attempt": { "type": "string", "minLength": 1 },
+                  "sha256": { "$ref": "#/$defs/sha256" },
+                  "outputs": { "type": "array", "items": { "$ref": "#/$defs/namedOutput" } }
+                },
+                "required": ["cellKey", "dispatch", "attempt", "sha256", "outputs"]
+              }
+            },
+            "evaluations": {
+              "type": "array",
+              "items": {
+                "type": "object",
+                "properties": {
+                  "cellKey": { "type": "string", "minLength": 1 },
+                  "evalIndex": { "type": "integer", "minimum": 1 },
+                  "evaluationAttempt": { "type": "integer", "minimum": 1 },
+                  "relationship": { "enum": ["same-execution-scorer", "separate-log-verifier"] },
+                  "evaluator": { "type": "string" },
+                  "evalTaskSha256": { "$ref": "#/$defs/sha256" },
+                  "evalSubmissionSha256": { "$ref": "#/$defs/sha256" },
+                  "evalAttempt": { "type": "string" },
+                  "evalDeliverySha256": { "$ref": "#/$defs/sha256" },
+                  "verdictSha256": { "$ref": "#/$defs/sha256" },
+                  "evaluationTerminal": { "const": "could-not-grade" },
+                  "failureCategory": { "type": "string", "minLength": 1 }
+                },
+                "required": ["cellKey", "evalIndex"]
+              }
+            },
+            "evaluationRetries": {
+              "type": "array",
+              "items": {
+                "type": "object",
+                "properties": {
+                  "cellKey": { "type": "string", "minLength": 1 },
+                  "dispatch": { "type": "integer", "minimum": 1 },
+                  "evalIndex": { "type": "integer", "minimum": 1 },
+                  "evaluationAttempt": { "type": "integer", "minimum": 1 },
+                  "evaluator": { "type": "string", "minLength": 1 },
+                  "evalTaskSha256": { "$ref": "#/$defs/sha256" },
+                  "evalSubmissionSha256": { "$ref": "#/$defs/sha256" },
+                  "evalAttempt": { "type": "string", "minLength": 1 },
+                  "failureCategory": { "type": "string", "minLength": 1 },
+                  "recoveryAdvice": { "const": "new-attempt-required" },
+                  "detail": { "type": "string", "minLength": 1 }
+                },
+                "required": ["cellKey", "dispatch", "evalIndex", "evaluationAttempt", "evaluator", "failureCategory", "recoveryAdvice", "detail"]
+              }
+            }
+          },
+          "required": ["admissions", "solveSubmissions", "evaluationSubmissions", "solveDeliveries", "evaluations"]
+        }
+      },
+      "required": ["format", "kind", "runCancelled", "draftId", "assurancePreset", "graph"]
+    },
+    "cell": {
+      "type": "object",
+      "properties": {
+        "kind": { "const": "cell" },
+        "cellKey": { "type": "string", "minLength": 1 },
+        "armId": { "type": "string", "minLength": 1 },
+        "replicate": { "type": "integer", "minimum": 1 },
+        "taskDigest": { "$ref": "#/$defs/sha256" },
+        "dispatches": { "type": "integer", "minimum": 0 },
+        "accounted": { "type": "integer", "minimum": 1 },
+        "submissionSha256": { "$ref": "#/$defs/sha256" },
+        "pinningEvidenceSha256": { "$ref": "#/$defs/sha256" },
+        "attempt": { "type": "string", "minLength": 1 },
+        "deliverySha256": { "$ref": "#/$defs/sha256" },
+        "solveOutputs": { "type": "array", "items": { "$ref": "#/$defs/namedOutput" } },
+        "evaluationSpecSha256": { "$ref": "#/$defs/sha256" },
+        "evaluationTerminal": { "const": "could-not-grade" },
+        "admission": {
+          "type": "object",
+          "properties": {
+            "zeroReplayVariance": { "type": "boolean" },
+            "externalCapabilities": { "type": "boolean" }
+          },
+          "required": ["zeroReplayVariance", "externalCapabilities"]
+        },
+        "admissionReceiptSha256": { "$ref": "#/$defs/sha256" },
+        "verdicts": { "type": "array", "items": { "$ref": "#/$defs/verdict" } }
+      },
+      "required": ["kind", "cellKey", "armId", "replicate", "taskDigest", "dispatches", "verdicts"]
+    }
+  }
+}

package/schemas/bundle-manifest.schema.json

@@ -0,0 +1,23 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$comment": "Describes bundle.json for the benchmark-product-public-bundle/2 format. Source of truth: BundleManifestSchema in @colophon-claims/verify src/manifest.ts, a union of this legacy shape (an open object, so unknown members are permitted here) and the evidence-native v5 manifest; the v4 and v5 bundle formats are outside this schema's scope. Structural validity only: the verifier additionally requires canonical JSON bytes, entries sorted strictly by path, per-file byte and digest equality, path-safety and symlink refusal, and two-way tree closure. bundle.json never lists itself; the bundle identity is the SHA-256 of bundle.json's own bytes.",
+  "description": "File manifest of a benchmark-product public bundle (format benchmark-product-public-bundle/2).",
+  "type": "object",
+  "properties": {
+    "format": { "const": "benchmark-product-public-bundle/2" },
+    "files": {
+      "type": "array",
+      "minItems": 1,
+      "items": {
+        "type": "object",
+        "properties": {
+          "bytes": { "type": "integer", "minimum": 0 },
+          "path": { "type": "string", "minLength": 1 },
+          "sha256": { "type": "string", "pattern": "^[a-f0-9]{64}$" }
+        },
+        "required": ["bytes", "path", "sha256"]
+      }
+    }
+  },
+  "required": ["format", "files"]
+}

package/schemas/claim-package.schema.json

@@ -0,0 +1,279 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$comment": "Describes claim-package.json (claimSchema benchmark-product.claim-package/1, or /2 for binary-qualification bundles). Source of truth: ClaimPackageWireSchema in @colophon-claims/verify src/profile/claim.ts (an open object there, so unknown members are permitted here). Every number is extracted verbatim from the sealed records the claim cites, never recomputed; the verifier rebuilds the whole package from verified facts and byte-compares it, so schema validity never substitutes for that recomputation. A claim carries exactly one method projection -- the wilson headline, the paired-delta comparison, pairwise-disagreement's panel, paired-majority-delta's contrast, or binary-instrument's qualification -- never neither.",
+  "description": "Standalone claim package of a benchmark-product public bundle.",
+  "type": "object",
+  "properties": {
+    "claimSchema": {
+      "enum": ["benchmark-product.claim-package/1", "benchmark-product.claim-package/2"]
+    },
+    "scope": {
+      "type": "object",
+      "properties": {
+        "draftId": { "type": "string", "minLength": 1 },
+        "benchmarkSha256": { "type": "string", "pattern": "^[a-f0-9]{64}$" },
+        "taskCount": { "type": "integer", "minimum": 0 },
+        "arms": {
+          "type": "array",
+          "items": {
+            "type": "object",
+            "properties": {
+              "armId": { "type": "string", "minLength": 1 },
+              "pinning": { "type": "object" }
+            },
+            "required": ["armId", "pinning"]
+          }
+        },
+        "replicates": { "type": "integer", "minimum": 1 },
+        "venue": { "const": "self-run" }
+      },
+      "required": ["draftId", "benchmarkSha256", "taskCount", "arms", "replicates", "venue"]
+    },
+    "records": {
+      "type": "object",
+      "properties": {
+        "benchmarkSha256": { "type": "string", "pattern": "^[a-f0-9]{64}$" },
+        "runSha256": { "type": "string", "pattern": "^[a-f0-9]{64}$" },
+        "matrixSha256": { "type": "string", "pattern": "^[a-f0-9]{64}$" },
+        "reportSha256": { "type": "string", "pattern": "^[a-f0-9]{64}$" },
+        "reportEnvelopeSha256": { "type": "string", "pattern": "^[a-f0-9]{64}$" }
+      },
+      "required": ["benchmarkSha256", "runSha256", "matrixSha256", "reportSha256", "reportEnvelopeSha256"]
+    },
+    "method": {
+      "type": "object",
+      "properties": {
+        "id": { "type": "string", "minLength": 1 },
+        "version": { "type": "string", "minLength": 1 },
+        "parameters": { "type": "object" },
+        "preregistered": { "type": "boolean" }
+      },
+      "required": ["id", "version", "parameters", "preregistered"]
+    },
+    "results": {},
+    "headline": {
+      "type": "object",
+      "additionalProperties": {
+        "type": "object",
+        "properties": {
+          "n": { "type": "integer", "minimum": 0 },
+          "passRate": { "type": "string" },
+          "wilsonInterval": {
+            "type": "object",
+            "properties": {
+              "low": { "type": "string" },
+              "high": { "type": "string" }
+            },
+            "required": ["low", "high"]
+          }
+        },
+        "required": ["n", "passRate", "wilsonInterval"]
+      }
+    },
+    "comparison": {
+      "type": "object",
+      "properties": {
+        "pairs": { "type": "integer", "minimum": 0 },
+        "delta": { "type": ["string", "null"] },
+        "interval": {
+          "type": ["object", "null"],
+          "properties": {
+            "alpha": { "type": "string" },
+            "low": { "type": "string" },
+            "high": { "type": "string" }
+          },
+          "required": ["alpha", "low", "high"]
+        },
+        "reasons": { "type": "array", "items": { "type": "string" } },
+        "pairing": {
+          "type": "object",
+          "properties": { "taskDigests": { "type": "array", "items": { "type": "string" } } },
+          "required": ["taskDigests"]
+        },
+        "clustering": {
+          "type": "object",
+          "properties": {
+            "basis": { "type": "string" },
+            "clusters": { "type": "integer", "minimum": 0 }
+          },
+          "required": ["basis", "clusters"]
+        },
+        "excluded": { "$ref": "#/$defs/conflicted" },
+        "conflicted": { "$ref": "#/$defs/conflicted" },
+        "bootstrap": {}
+      },
+      "required": ["pairs", "delta", "interval", "reasons", "pairing", "clustering", "excluded", "conflicted"]
+    },
+    "completeness": {},
+    "attrition": {},
+    "conflicted": { "$ref": "#/$defs/conflicted" },
+    "assurance": {
+      "type": "object",
+      "properties": {
+        "preset": { "type": "string", "minLength": 1 },
+        "resolved": {
+          "type": "object",
+          "properties": {
+            "independence": { "enum": ["gating", "disclosed"] },
+            "minVerdicts": { "type": "integer", "minimum": 1 },
+            "distinctEvaluator": { "type": "boolean" },
+            "verdictRule": { "enum": ["sole", "majority", "unanimous"] }
+          },
+          "required": ["independence", "minVerdicts", "distinctEvaluator", "verdictRule"]
+        },
+        "disclosure": { "type": "string", "minLength": 1 }
+      },
+      "required": ["preset", "resolved", "disclosure"]
+    },
+    "disclosures": {
+      "type": "object",
+      "properties": {
+        "perSubject": { "type": "array" },
+        "integrityTierCounts": {
+          "type": "object",
+          "properties": {
+            "re-derivable": { "type": "integer", "minimum": 0 },
+            "attested-only": { "type": "integer", "minimum": 0 }
+          },
+          "required": ["re-derivable", "attested-only"]
+        },
+        "pinningUnverifiableCounts": {
+          "type": "object",
+          "properties": {
+            "harness": { "type": "integer", "minimum": 0 },
+            "model": { "type": "integer", "minimum": 0 },
+            "loadout": { "type": "integer", "minimum": 0 },
+            "isolation": { "type": "integer", "minimum": 0 }
+          },
+          "required": ["harness", "model", "loadout", "isolation"]
+        }
+      },
+      "required": ["perSubject", "integrityTierCounts", "pinningUnverifiableCounts"]
+    },
+    "limitations": { "type": "array", "items": { "type": "string" } },
+    "venueHonesty": {},
+    "verification": {
+      "type": "object",
+      "properties": {
+        "command": { "type": "string", "minLength": 1 },
+        "compatibleCommand": { "type": "string", "minLength": 1 },
+        "checks": {
+          "type": "array",
+          "items": { "type": "string", "minLength": 1 },
+          "minItems": 1
+        },
+        "trustRoot": { "type": "string", "minLength": 1 }
+      },
+      "required": ["command", "compatibleCommand", "checks", "trustRoot"]
+    },
+    "rehearsal": {
+      "type": "object",
+      "properties": {
+        "previewCount": { "type": "integer", "minimum": 1 },
+        "timestamps": {
+          "type": "array",
+          "items": { "type": "string", "format": "date-time" },
+          "minItems": 1
+        }
+      },
+      "required": ["previewCount", "timestamps"]
+    },
+    "qualification": {},
+    "pairwiseDisagreement": {
+      "type": "object",
+      "properties": {
+        "pairs": {
+          "type": "array",
+          "items": {
+            "type": "object",
+            "properties": {
+              "armA": { "type": "string", "minLength": 1 },
+              "armB": { "type": "string", "minLength": 1 },
+              "n": { "type": "integer", "minimum": 0 },
+              "disagreements": { "type": "integer", "minimum": 0 },
+              "rate": { "type": ["string", "null"] },
+              "interval": { "$ref": "#/$defs/judgeInterval" },
+              "byCandidateClass": { "type": "array", "items": { "type": "object" } },
+              "byStratum": { "type": "array", "items": { "type": "object" } },
+              "exclusions": { "type": "array", "items": { "$ref": "#/$defs/exclusionTriple" } }
+            },
+            "required": ["armA", "armB", "n", "disagreements", "rate", "interval", "byCandidateClass", "byStratum", "exclusions"]
+          }
+        },
+        "conflicted": { "$ref": "#/$defs/conflicted" }
+      },
+      "required": ["pairs", "conflicted"]
+    },
+    "pairedMajorityDelta": {
+      "type": "object",
+      "properties": {
+        "baseline": { "type": "string", "minLength": 1 },
+        "candidate": { "type": "string", "minLength": 1 },
+        "n": { "type": "integer", "minimum": 0 },
+        "delta": { "type": ["string", "null"] },
+        "interval": { "$ref": "#/$defs/judgeInterval" },
+        "reasons": { "type": "array", "items": { "type": "string" } },
+        "clusters": {
+          "type": "object",
+          "properties": { "count": { "type": "integer", "minimum": 0 }, "manifest": {} },
+          "required": ["count"]
+        },
+        "byCandidateClass": { "type": "array", "items": { "type": "object" } },
+        "byStratum": { "type": "array", "items": { "type": "object" } },
+        "exclusions": { "type": "array", "items": { "$ref": "#/$defs/exclusionTriple" } },
+        "conflicted": { "$ref": "#/$defs/conflicted" }
+      },
+      "required": ["baseline", "candidate", "n", "delta", "interval", "reasons", "clusters", "byCandidateClass", "byStratum", "exclusions", "conflicted"]
+    }
+  },
+  "required": [
+    "claimSchema",
+    "scope",
+    "records",
+    "method",
+    "results",
+    "completeness",
+    "attrition",
+    "conflicted",
+    "assurance",
+    "disclosures",
+    "limitations",
+    "venueHonesty",
+    "verification"
+  ],
+  "anyOf": [
+    { "required": ["headline"] },
+    { "required": ["comparison"] },
+    { "required": ["pairwiseDisagreement"] },
+    { "required": ["pairedMajorityDelta"] }
+  ],
+  "$defs": {
+    "judgeInterval": {
+      "$comment": "pairwise-disagreement@1 and paired-majority-delta@1 key their intervals {lower, upper, alpha}, NOT paired-delta@1's {low, high, alpha}.",
+      "type": ["object", "null"],
+      "properties": {
+        "lower": { "type": "string" },
+        "upper": { "type": "string" },
+        "alpha": { "type": "string" }
+      },
+      "required": ["lower", "upper", "alpha"]
+    },
+    "exclusionTriple": {
+      "type": "object",
+      "properties": {
+        "taskDigest": { "type": "string", "minLength": 1 },
+        "armId": { "type": "string", "minLength": 1 },
+        "reason": { "type": "string", "minLength": 1 }
+      },
+      "required": ["taskDigest", "armId", "reason"]
+    },
+    "conflicted": {
+      "type": "object",
+      "properties": {
+        "count": { "type": "integer", "minimum": 0 },
+        "cellKeys": { "type": "array", "items": { "type": "string" } }
+      },
+      "required": ["count", "cellKeys"]
+    }
+  }
+}

package/schemas/dsse-envelope.schema.json

@@ -0,0 +1,25 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$comment": "Describes the DSSE v1 envelopes a public bundle carries: report-envelope.json (payloadType application/vnd.jinn.benchmarking.report.v1+json; its decoded payload is byte-identical to report.json) and every verdict record (payloadType application/vnd.in-toto+json over an in-toto Statement v1). Source of truth: parseExactDsseEnvelope in @jinn-network/trust-core src/dsse.ts, which admits exactly these three members. Signatures are Ed25519 over the DSSE pre-authentication encoding 'DSSEv1 ' || len(payloadType) || ' ' || payloadType || ' ' || len(payload) || ' ' || payload (lengths as ASCII decimals, payload as raw decoded bytes). See https://github.com/secure-systems-lab/dsse.",
+  "description": "DSSE v1 signature envelope as carried by benchmark-product public bundles.",
+  "type": "object",
+  "properties": {
+    "payload": { "type": "string", "contentEncoding": "base64", "minLength": 1 },
+    "payloadType": { "type": "string", "minLength": 1 },
+    "signatures": {
+      "type": "array",
+      "minItems": 1,
+      "items": {
+        "type": "object",
+        "properties": {
+          "keyid": { "type": "string" },
+          "sig": { "type": "string", "contentEncoding": "base64", "minLength": 1 }
+        },
+        "required": ["sig"],
+        "additionalProperties": false
+      }
+    }
+  },
+  "required": ["payload", "payloadType", "signatures"],
+  "additionalProperties": false
+}

package/schemas/evidence-catalog.schema.json

@@ -0,0 +1,43 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$comment": "Describes evidence.json, format benchmark-product-evidence-catalog/2. Source of truth: BundleEvidenceCatalogSchema in @colophon-claims/verify src/schema.ts (an open object there, so unknown members are permitted here). Every listed sha256 names records/<sha256>.bin, whose exact bytes re-hash to that digest. The verifier additionally requires canonical JSON bytes, unique digests, unique roles per record, and exact two-way closure between declared roles and the roles derived from the evidence graph.",
+  "description": "Content-addressed record catalog of a benchmark-product public bundle (format benchmark-product-evidence-catalog/2).",
+  "type": "object",
+  "properties": {
+    "format": { "const": "benchmark-product-evidence-catalog/2" },
+    "records": {
+      "type": "array",
+      "items": {
+        "type": "object",
+        "properties": {
+          "sha256": { "type": "string", "pattern": "^[a-f0-9]{64}$" },
+          "roles": {
+            "type": "array",
+            "items": {
+              "enum": [
+                "task",
+                "runtime-selection",
+                "evaluation-spec",
+                "admission-receipt",
+                "solve-submission",
+                "run-pinning-evidence",
+                "evaluation-submission",
+                "solve-delivery",
+                "solve-output",
+                "evaluation-task",
+                "evaluation-delivery",
+                "verdict",
+                "judge-instrument",
+                "analysis-context",
+                "label-resolution"
+              ]
+            },
+            "minItems": 1
+          }
+        },
+        "required": ["sha256", "roles"]
+      }
+    }
+  },
+  "required": ["format", "records"]
+}