chainlesschain 0.166.91 → 0.166.92

package/src/lib/evolution/rrsi-data.js

@@ -0,0 +1,196 @@
+import { createHash } from "node:crypto";
+import { isProxy } from "node:util/types";
+
+export const RRSI_STRUCTURAL_FLAGS = Object.freeze({
+  structuralOnly: true,
+  authenticated: false,
+  readyForExecution: false,
+  qualifiesForPromotion: false,
+});
+
+export class RrsiContractError extends TypeError {
+  constructor(message, code = "CC_RRSI_INVALID") {
+    super(message);
+    this.name = "RrsiContractError";
+    this.code = code;
+  }
+}
+
+export function rrsiFail(message, code) {
+  throw new RrsiContractError(message, code);
+}
+
+/** Copy descriptors, never call input getters, toJSON, or proxy traps. */
+export function snapshotRrsiData(input) {
+  const ancestors = new WeakSet();
+  let nodes = 0;
+  let bytes = 0;
+  const charge = (text) => {
+    bytes += Buffer.byteLength(text, "utf8");
+    if (bytes > 2 * 1024 * 1024) rrsiFail("RRSI data exceeds byte limit");
+  };
+  const copy = (value, depth) => {
+    if (++nodes > 100_000 || depth > 16)
+      rrsiFail("RRSI data exceeds structural limits");
+    if (value === null || typeof value === "boolean") return value;
+    if (typeof value === "string") {
+      if (value.length > 8192) rrsiFail("RRSI string exceeds limit");
+      charge(value);
+      return value;
+    }
+    if (typeof value === "number") {
+      if (
+        !Number.isFinite(value) ||
+        Object.is(value, -0) ||
+        (Number.isInteger(value) && !Number.isSafeInteger(value))
+      )
+        rrsiFail("RRSI numbers must be finite and safe");
+      return value;
+    }
+    if (!value || typeof value !== "object" || isProxy(value))
+      rrsiFail("RRSI input must be plain data");
+    if (ancestors.has(value)) rrsiFail("RRSI data must be acyclic");
+    const array = Array.isArray(value);
+    if (
+      Object.getPrototypeOf(value) !==
+      (array ? Array.prototype : Object.prototype)
+    )
+      rrsiFail("RRSI input has an unsupported prototype");
+    if (array && value.length > 5000) rrsiFail("RRSI array exceeds limit");
+    const keys = Reflect.ownKeys(value);
+    if (
+      (!array && keys.length > 64) ||
+      (array && keys.length !== value.length + 1)
+    )
+      rrsiFail("RRSI input has extra fields or array holes");
+    ancestors.add(value);
+    const result = array ? [] : {};
+    for (const key of keys) {
+      if (array && key === "length") continue;
+      const descriptor = Object.getOwnPropertyDescriptor(value, key);
+      if (
+        typeof key !== "string" ||
+        key.length > 128 ||
+        !descriptor?.enumerable ||
+        !("value" in descriptor) ||
+        ["__proto__", "constructor", "prototype"].includes(key) ||
+        (array && (!/^(0|[1-9]\d*)$/u.test(key) || Number(key) >= value.length))
+      )
+        rrsiFail("RRSI input has accessor, symbol, or noncanonical fields");
+      charge(key);
+      Object.defineProperty(result, key, {
+        value: copy(descriptor.value, depth + 1),
+        enumerable: true,
+        writable: true,
+        configurable: true,
+      });
+    }
+    ancestors.delete(value);
+    return result;
+  };
+  return copy(input, 0);
+}
+
+export function rrsiExact(value, keys, label) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    rrsiFail(`${label} must be a record`);
+  const actual = Object.keys(value);
+  if (
+    actual.length !== keys.length ||
+    actual.some((key) => !keys.includes(key))
+  )
+    rrsiFail(`${label} has missing or unexpected fields`);
+}
+
+export function rrsiId(value, label) {
+  if (typeof value !== "string" || !/^[a-z][a-z0-9._:-]{0,127}$/u.test(value))
+    rrsiFail(`${label} is invalid`);
+  return value;
+}
+
+export function rrsiDigest(value, label) {
+  if (typeof value !== "string" || !/^sha256:[a-f0-9]{64}$/u.test(value))
+    rrsiFail(`${label} must be a sha256 digest`);
+  return value;
+}
+
+export function rrsiInteger(
+  value,
+  label,
+  min = 0,
+  max = Number.MAX_SAFE_INTEGER,
+) {
+  if (!Number.isSafeInteger(value) || value < min || value > max)
+    rrsiFail(`${label} is outside its allowed range`);
+  return value;
+}
+
+export function rrsiFinite(value, label, min = 0, max = 1) {
+  if (
+    typeof value !== "number" ||
+    !Number.isFinite(value) ||
+    value < min ||
+    value > max
+  )
+    rrsiFail(`${label} is outside its allowed range`);
+  return value;
+}
+
+export function rrsiBoolean(value, label) {
+  if (typeof value !== "boolean") rrsiFail(`${label} must be boolean`);
+  return value;
+}
+
+export function rrsiCanonical(value) {
+  if (value === null || typeof value !== "object") return JSON.stringify(value);
+  if (Array.isArray(value)) return `[${value.map(rrsiCanonical).join(",")}]`;
+  return `{${Object.keys(value)
+    .sort()
+    .map((key) => `${JSON.stringify(key)}:${rrsiCanonical(value[key])}`)
+    .join(",")}}`;
+}
+
+export function rrsiHash(domain, value) {
+  return `sha256:${createHash("sha256").update(domain).update("\0").update(rrsiCanonical(value)).digest("hex")}`;
+}
+
+export function freezeRrsiData(value) {
+  if (value && typeof value === "object") {
+    Object.values(value).forEach(freezeRrsiData);
+    Object.freeze(value);
+  }
+  return value;
+}
+
+export function rrsiEnvelope(schema, digestField, core) {
+  const record = { schema, ...core, ...RRSI_STRUCTURAL_FLAGS };
+  return freezeRrsiData({ ...record, [digestField]: rrsiHash(schema, record) });
+}
+
+export function verifyRrsiEnvelope(
+  input,
+  schema,
+  digestField,
+  inputKeys,
+  rebuild,
+  derivedKeys = [],
+) {
+  const value = snapshotRrsiData(input);
+  rrsiExact(
+    value,
+    [
+      "schema",
+      ...inputKeys,
+      ...derivedKeys,
+      ...Object.keys(RRSI_STRUCTURAL_FLAGS),
+      digestField,
+    ],
+    schema,
+  );
+  if (value.schema !== schema) rrsiFail("RRSI schema mismatch");
+  const core = Object.fromEntries(inputKeys.map((key) => [key, value[key]]));
+  const result = rebuild(core);
+  if (rrsiCanonical(result) !== rrsiCanonical(value))
+    rrsiFail("RRSI envelope, digest, or structural flags mismatch");
+  return result;
+}

package/src/lib/evolution/rrsi-evaluation-adapter.js

@@ -0,0 +1,275 @@
+/** Five RRSI pools over existing strict Eval Suites; no runner or signing factory. */
+import { verifyRrsiCampaign } from "./rrsi-contracts.js";
+import {
+  verifyEvolutionEvalPolicy,
+  isEvolutionEvalReceiptVerifier,
+  verifyEvolutionEvalResultEvidence,
+  computeEvolutionEvalContextDigest,
+} from "./evolution-eval-gate.js";
+import { projectRrsiPmTaskReferences } from "./rrsi-pm-training-mapping.js";
+import {
+  snapshotRrsiData,
+  rrsiExact,
+  rrsiDigest,
+  rrsiCanonical,
+  rrsiHash,
+  rrsiEnvelope,
+  freezeRrsiData,
+  rrsiFail,
+} from "./rrsi-data.js";
+
+export const RRSI_EVALUATION_MAPPING_SCHEMA =
+  "chainlesschain.rrsi-evaluation-mapping/v1";
+export const RRSI_EVAL_ROW_EVIDENCE_SCHEMA =
+  "chainlesschain.rrsi-eval-row-evidence/v1";
+const ROLES = ["gate", "selection", "audit"];
+const MAPPINGS = new WeakSet();
+const PARTITIONS = {
+  gate: { training: "train", validation: "gate-validation", test: "gate-test" },
+  selection: { training: "train", validation: "select", test: "select" },
+  audit: { training: "train", validation: "audit", test: "audit" },
+};
+
+/** Selection and audit use disjoint whole components within their own pool. */
+export function buildRrsiEvaluationMapping(input) {
+  const value = snapshotRrsiData(input);
+  rrsiExact(
+    value,
+    ["campaign", "suites", "policies", "versions"],
+    "five-pool mapping input",
+  );
+  const campaign = verifyRrsiCampaign(value.campaign);
+  rrsiExact(
+    value.versions,
+    campaign.experiment.arms,
+    "frozen evaluation arm artifacts",
+  );
+  for (const arm of campaign.experiment.arms)
+    rrsiDigest(value.versions[arm], `${arm} evaluation artifact`);
+  rrsiExact(value.suites, ROLES, "independent evaluation suites");
+  rrsiExact(value.policies, ROLES, "frozen evaluation policies");
+  const sources = new Map(
+    campaign.dataset.tasks.map((task) => [task.contentDigest, task]),
+  );
+  const roles = ROLES.map((role) => {
+    const projection = projectRrsiPmTaskReferences(value.suites[role]);
+    const policy = verifyEvolutionEvalPolicy(value.policies[role]);
+    if (
+      rrsiCanonical([...policy.seeds].sort((a, b) => a - b)) !==
+      rrsiCanonical(campaign.experiment.seeds)
+    )
+      rrsiFail("Eval repeats differ from the frozen RRSI denominator");
+    const counts = Object.fromEntries(
+      ["training", "validation", "test"].map((split) => [
+        split,
+        projection.tasks.filter((task) => task.split === split).length,
+      ]),
+    );
+    for (const [split, field, floor] of [
+      ["training", "minTrainingTasks", 30],
+      ["validation", "minValidationTasks", 20],
+      ["test", "minTestTasks", 20],
+    ])
+      if (counts[split] < Math.max(floor, policy[field]))
+        rrsiFail("Eval Suite does not satisfy the original sample floors");
+    const mappings = projection.tasks.map((task) => {
+      const source = sources.get(task.contentDigest);
+      if (
+        !source ||
+        source.partition !== PARTITIONS[role][task.split] ||
+        rrsiCanonical(source.groups) !== rrsiCanonical(task.groups)
+      )
+        rrsiFail(
+          "Eval task content, source or pool differs from RRSI",
+          "CC_RRSI_DATA_LEAKAGE",
+        );
+      return {
+        ...task,
+        rrsiTaskId: source.id,
+        rrsiPartition: source.partition,
+      };
+    });
+    if (new Set(mappings.map((row) => row.rrsiTaskId)).size !== mappings.length)
+      rrsiFail("evaluation suite maps multiple aliases to one RRSI task");
+    const expectedPartitions = new Set(Object.values(PARTITIONS[role]));
+    const expectedIds = campaign.dataset.tasks
+      .filter((task) => expectedPartitions.has(task.partition))
+      .map((task) => task.id)
+      .sort();
+    if (
+      rrsiCanonical(mappings.map((row) => row.rrsiTaskId).sort()) !==
+      rrsiCanonical(expectedIds)
+    )
+      rrsiFail("evaluation mapping omits part of the frozen pool denominator");
+    return {
+      role,
+      suiteDigest: projection.suiteDigest,
+      policyDigest: policy.policyDigest,
+      pmTrainingPartitionDigest: projection.pmTrainingPartitionDigest,
+      splitCounts: counts,
+      mappings,
+    };
+  });
+  const mapping = rrsiEnvelope(
+    RRSI_EVALUATION_MAPPING_SCHEMA,
+    "evaluationMappingDigest",
+    {
+      campaignDigest: campaign.campaignDigest,
+      datasetDigest: campaign.dataset.datasetDigest,
+      versions: value.versions,
+      rrsiTrainingPartitionDigest: campaign.dataset.pools.train.partitionDigest,
+      roles,
+      sourceProvenanceVerified: false,
+      independentExecutionContextsVerified: false,
+      mappingAuthenticated: false,
+    },
+  );
+  MAPPINGS.add(mapping);
+  return mapping;
+}
+
+export function verifyRrsiEvaluationMapping(mapping, context) {
+  const rebuilt = buildRrsiEvaluationMapping(context);
+  if (rrsiCanonical(snapshotRrsiData(mapping)) !== rrsiCanonical(rebuilt))
+    rrsiFail("five-pool mapping differs from frozen sources or policy");
+  return rebuilt;
+}
+
+/** Explicit training-only data plane. Selection/Gate/audit summaries are absent. */
+export function projectRrsiEvaluationTrainingView(input) {
+  if (!MAPPINGS.has(input))
+    rrsiFail("training projection requires a verified evaluation mapping");
+  const mapping = snapshotRrsiData(input);
+  if (mapping.schema !== RRSI_EVALUATION_MAPPING_SCHEMA)
+    rrsiFail("unknown evaluation mapping schema");
+  const gate = mapping.roles.find((role) => role.role === "gate");
+  if (!gate) rrsiFail("evaluation mapping has no gate training view");
+  return freezeRrsiData({
+    trainingPartitionDigest: mapping.rrsiTrainingPartitionDigest,
+    tasks: gate.mappings
+      .filter((row) => row.rrsiPartition === "train")
+      .map((row) => ({
+        taskId: row.rrsiTaskId,
+        contentDigest: row.contentDigest,
+      })),
+    sourceProvenanceVerified: false,
+    qualifiesForPromotion: false,
+  });
+}
+
+/** Authenticate raw rows through the existing branded final-receipt verifier. */
+export async function collectRrsiEvalRowEvidence(verifier, input) {
+  if (!isEvolutionEvalReceiptVerifier(verifier))
+    rrsiFail("RRSI evaluation requires the existing branded Eval verifier");
+  const value = snapshotRrsiData(input);
+  rrsiExact(
+    value,
+    [
+      "context",
+      "mapping",
+      "role",
+      "bundle",
+      "expectedReceipt",
+      "evaluationContext",
+      "armBindings",
+    ],
+    "RRSI signed row collection",
+  );
+  const mapping = verifyRrsiEvaluationMapping(value.mapping, value.context);
+  if (
+    value.evaluationContext.planDigest !== mapping.evaluationMappingDigest ||
+    computeEvolutionEvalContextDigest(value.evaluationContext) !==
+      value.expectedReceipt.evaluationContextDigest
+  )
+    rrsiFail("Eval run context was not bound to the frozen RRSI mapping");
+  const role = mapping.roles.find((entry) => entry.role === value.role);
+  if (!role) rrsiFail("unknown evaluation evidence role");
+  rrsiExact(
+    value.armBindings,
+    ["baseline", "candidate"],
+    "paired Eval arm binding",
+  );
+  if (
+    !Object.values(value.armBindings).every((arm) =>
+      ["baseline", "rsi", "rrsi"].includes(arm),
+    ) ||
+    value.armBindings.baseline === value.armBindings.candidate
+  )
+    rrsiFail("Eval evidence requires two different preregistered arms");
+  rrsiExact(
+    value.bundle,
+    ["receipt", "resultEvidence", "suite", "policy"],
+    "existing Eval evidence bundle",
+  );
+  if (
+    value.bundle.suite.suiteDigest !== role.suiteDigest ||
+    value.bundle.policy.policyDigest !== role.policyDigest
+  )
+    rrsiFail("signed Eval evidence differs from frozen five-pool mapping");
+  if (
+    value.bundle.receipt.baselineId !==
+      mapping.versions[value.armBindings.baseline] ||
+    value.bundle.receipt.candidateId !==
+      mapping.versions[value.armBindings.candidate] ||
+    value.bundle.receipt.environmentDigest !==
+      value.context.campaign.execution.environmentDigest ||
+    value.bundle.receipt.tenantId !== value.context.campaign.tenantId ||
+    value.bundle.receipt.trainingPartitionDigest !==
+      role.pmTrainingPartitionDigest
+  )
+    rrsiFail(
+      "signed Eval arms, tenant, environment or training binding differ",
+    );
+  const evidence = await verifyEvolutionEvalResultEvidence(
+    verifier,
+    value.bundle,
+    value.expectedReceipt,
+  );
+  const indexed = new Map(role.mappings.map((row) => [row.pmTaskDigest, row]));
+  const rows = ["validation", "test"].flatMap((split) =>
+    ["baseline", "candidate"].flatMap((arm) =>
+      evidence[split][arm].map((row) => {
+        const task = indexed.get(row.taskDigest);
+        if (!task || task.split !== split)
+          rrsiFail("signed row has foreign task mapping");
+        return {
+          rrsiTaskId: task.rrsiTaskId,
+          rrsiPartition: task.rrsiPartition,
+          pmTaskDigest: row.taskDigest,
+          seed: row.seed,
+          arm: value.armBindings[arm],
+          versionDigest: mapping.versions[value.armBindings[arm]],
+          reportedPass: row.pass,
+          strictPass:
+            row.pass &&
+            row.securityViolations === 0 &&
+            row.permissionViolations === 0,
+          securityViolations: row.securityViolations,
+          permissionViolations: row.permissionViolations,
+          executionDigest: row.executionDigest,
+          gradeDigest: row.gradeDigest,
+          safetyDigest: row.safetyDigest,
+          metrics: row.metrics,
+          rowDigest: rrsiHash("chainlesschain.rrsi-signed-eval-row/v1", row),
+        };
+      }),
+    ),
+  );
+  return rrsiEnvelope(RRSI_EVAL_ROW_EVIDENCE_SCHEMA, "rowEvidenceDigest", {
+    evaluationMappingDigest: mapping.evaluationMappingDigest,
+    role: role.role,
+    finalReceiptDigest: evidence.receiptDigest,
+    rows,
+    finalReceiptRowsAuthenticated: true,
+    runContextBoundToMapping: true,
+    ledgerReservationVerified: false,
+    armLifecycleVerified: false,
+    perturbationIdentityVerified: false,
+    launchSlotVerified: false,
+    underlyingExecutionReceiptsReverified: false,
+    sourceProvenanceVerified: false,
+    completeLifecycleCostVerified: false,
+    cleanupReverified: false,
+    qualityVerdictVerified: false,
+  });
+}