chainlesschain 0.166.91 → 0.166.92

package/src/lib/evolution/rrsi-preparation-contracts.js

@@ -0,0 +1,213 @@
+/** Frozen preparation declarations; these do not authenticate a PM mapping. */
+import { RRSI_BUDGET_FIELDS } from "./rrsi-contracts.js";
+import {
+  rrsiExact,
+  rrsiId,
+  rrsiDigest,
+  rrsiInteger,
+  rrsiCanonical,
+  rrsiHash,
+  rrsiEnvelope,
+  rrsiFail,
+} from "./rrsi-data.js";
+
+export const RRSI_PREPARATION_PLAN_SCHEMA =
+  "chainlesschain.rrsi-preparation-plan/v1";
+export const RRSI_PREPARATION_RESERVATION_SCHEMA =
+  "chainlesschain.rrsi-preparation-reservation/v1";
+export const RRSI_PREPARATION_RESERVATION_SCHEMA_V2 =
+  "chainlesschain.rrsi-preparation-reservation/v2";
+export function isRrsiPreparationReservation(value) {
+  return (
+    value.schema === RRSI_PREPARATION_RESERVATION_SCHEMA ||
+    value.schema === RRSI_PREPARATION_RESERVATION_SCHEMA_V2
+  );
+}
+export const RRSI_PREPARATION_SETTLEMENT_SCHEMA =
+  "chainlesschain.rrsi-preparation-settlement/v1";
+export const RRSI_PREPARATION_PHASES = Object.freeze([
+  "curriculum-planning",
+  "exploration",
+  "candidate-proposal",
+  "memory-distillation",
+  "failure-retry",
+  "environment-reset",
+]);
+export const RRSI_PREPARATION_BINDING_FIELDS = Object.freeze([
+  "phase",
+  "preparationPlanDigest",
+  "trainingPartitionDigest",
+  "trainingSourceDigest",
+  "inputDigest",
+  "requestDigest",
+  "roundId",
+  "branchId",
+]);
+
+function sources(campaign, taskIds = null) {
+  const training = campaign.dataset.tasks.filter(
+    (task) => task.partition === "train",
+  );
+  if (taskIds !== null) {
+    if (!Array.isArray(taskIds) || taskIds.length < 1 || taskIds.length > 256)
+      rrsiFail("preparation sources must be a bounded nonempty list");
+    const allowed = new Set(training.map((task) => task.id));
+    for (const id of taskIds) {
+      rrsiId(id, "preparation training task ID");
+      if (!allowed.has(id)) rrsiFail("preparation source is outside training");
+    }
+    if (new Set(taskIds).size !== taskIds.length)
+      rrsiFail("preparation sources contain duplicate IDs");
+  }
+  // IDs and ordering are deliberately excluded from source identity.
+  return training
+    .filter((task) => taskIds === null || taskIds.includes(task.id))
+    .map((task) => ({ contentDigest: task.contentDigest, groups: task.groups }))
+    .sort((a, b) =>
+      rrsiCanonical(a) < rrsiCanonical(b)
+        ? -1
+        : rrsiCanonical(a) > rrsiCanonical(b)
+          ? 1
+          : 0,
+    );
+}
+
+export function rrsiTrainingSourcesDigest(campaign, taskIds = null) {
+  return rrsiHash(
+    "chainlesschain.rrsi-training-sources/v1",
+    sources(campaign, taskIds),
+  );
+}
+
+export function normalizeRrsiPreparationPlan(payload, rootCampaign) {
+  rrsiExact(
+    payload,
+    [
+      "campaignDigest",
+      "maxAttempts",
+      "planDigest",
+      "manifestDigest",
+      "trainingMappingDigest",
+      "pmTrainingPartitionDigest",
+    ],
+    "preparation plan registration",
+  );
+  rrsiDigest(payload.campaignDigest, "preparation campaign digest");
+  rrsiInteger(payload.maxAttempts, "preparation attempt limit", 1);
+  if (
+    payload.maxAttempts >
+    rootCampaign.budget.proposalPerExploringArm.maxExecutions
+  )
+    rrsiFail("preparation attempt limit exceeds frozen proposal allocation");
+  const context = Object.fromEntries(
+    [
+      "planDigest",
+      "manifestDigest",
+      "trainingMappingDigest",
+      "pmTrainingPartitionDigest",
+    ].map((key) => [key, rrsiDigest(payload[key], key)]),
+  );
+  return rrsiEnvelope(RRSI_PREPARATION_PLAN_SCHEMA, "preparationPlanDigest", {
+    maxAttempts: payload.maxAttempts,
+    ...context,
+    trainingPartitionDigest: rootCampaign.dataset.pools.train.partitionDigest,
+    trainingSourcesDigest: rrsiTrainingSourcesDigest(rootCampaign),
+    executionDigest: rrsiHash(
+      "chainlesschain.rrsi-execution-bindings/v1",
+      rootCampaign.execution,
+    ),
+    mappingAuthenticated: false,
+  });
+}
+
+export function normalizeRrsiPreparationRequest(payload, campaign, plan) {
+  const versioned = Object.hasOwn(payload, "plannedExecutions");
+  rrsiExact(
+    payload,
+    [
+      "campaignDigest",
+      "phase",
+      "sourceTaskIds",
+      "inputs",
+      "roundId",
+      "branchId",
+      "slotId",
+      "executionId",
+      "budget",
+      ...(versioned ? ["plannedExecutions"] : []),
+    ],
+    "preparation reservation",
+  );
+  if (!RRSI_PREPARATION_PHASES.includes(payload.phase))
+    rrsiFail("invalid preparation phase");
+  for (const key of ["roundId", "branchId", "slotId", "executionId"])
+    rrsiId(payload[key], key);
+  if (rrsiTrainingSourcesDigest(campaign) !== plan.trainingSourcesDigest)
+    rrsiFail("preparation campaign training sources differ from frozen plan");
+  const trainingSourceDigest = rrsiTrainingSourcesDigest(
+    campaign,
+    payload.sourceTaskIds,
+  );
+  rrsiExact(
+    payload.inputs,
+    ["instructionDigest", "memoryDigest", "artifactDigests"],
+    "preparation inputs",
+  );
+  for (const key of ["instructionDigest", "memoryDigest"])
+    rrsiDigest(payload.inputs[key], key);
+  const artifacts = payload.inputs.artifactDigests;
+  if (!Array.isArray(artifacts) || artifacts.length > 64)
+    rrsiFail("preparation artifacts must be a bounded list");
+  const artifactDigests = artifacts
+    .map((entry) => rrsiDigest(entry, "input artifact digest"))
+    .sort();
+  if (new Set(artifactDigests).size !== artifactDigests.length)
+    rrsiFail("preparation artifacts contain duplicate digests");
+  const inputDigest = rrsiHash("chainlesschain.rrsi-preparation-inputs/v1", {
+    instructionDigest: payload.inputs.instructionDigest,
+    memoryDigest: payload.inputs.memoryDigest,
+    artifactDigests,
+  });
+  // A new campaign/slot/round/branch/execution name cannot replay the same work.
+  const requestDigest = rrsiHash("chainlesschain.rrsi-preparation-request/v1", {
+    phase: payload.phase,
+    trainingSourceDigest,
+    inputDigest,
+    preparationPlanDigest: plan.preparationPlanDigest,
+    executionDigest: plan.executionDigest,
+  });
+  rrsiExact(payload.budget, RRSI_BUDGET_FIELDS, "preparation budget");
+  const ceiling = Object.fromEntries(
+    RRSI_BUDGET_FIELDS.map((key) => [
+      key,
+      rrsiInteger(payload.budget[key], key),
+    ]),
+  );
+  const plannedExecutions = versioned
+    ? rrsiInteger(
+        payload.plannedExecutions,
+        "planned preparation executions",
+        1,
+        64,
+      )
+    : 1;
+  if (ceiling.maxExecutions < plannedExecutions)
+    rrsiFail("preparation reservation must cover its planned executions");
+  return {
+    schema: versioned
+      ? RRSI_PREPARATION_RESERVATION_SCHEMA_V2
+      : RRSI_PREPARATION_RESERVATION_SCHEMA,
+    plannedExecutions,
+    budget: ceiling,
+    bindings: {
+      phase: payload.phase,
+      preparationPlanDigest: plan.preparationPlanDigest,
+      trainingPartitionDigest: campaign.dataset.pools.train.partitionDigest,
+      trainingSourceDigest,
+      inputDigest,
+      requestDigest,
+      roundId: payload.roundId,
+      branchId: payload.branchId,
+    },
+  };
+}

package/src/lib/evolution/rrsi-registry-history-binding.js

@@ -0,0 +1,193 @@
+/** Genuine storage graph binding; origin cutover and promotion remain separate. */
+import { isProxy } from "node:util/types";
+import {
+  captureEvolutionLedgerFileBackend,
+  captureEvolutionLedgerFileBackendBinding,
+} from "./evolution-ledger-file-backend.js";
+import { captureEvolutionLedgerArtifactResolverBinding } from "./evolution-artifact-ports.js";
+import { captureSkillReleaseOperationReader } from "./evolution-ledger-ports.js";
+import { captureSkillReleaseRegistryReader } from "./skill-release-registry.js";
+import { captureRrsiHistoryLedgerAdapter } from "./rrsi-history-ledger-adapter.js";
+import { isEvolutionLedgerV2Journal } from "./evolution-ledger-v2-journal.js";
+import { rrsiCanonical, rrsiEnvelope, rrsiFail } from "./rrsi-data.js";
+
+export const RRSI_REGISTRY_HISTORY_BINDING_SCHEMA =
+  "chainlesschain.rrsi-registry-history-binding/v1";
+export const RRSI_REGISTRY_HISTORY_READBACK_SCHEMA =
+  "chainlesschain.rrsi-registry-history-readback/v1";
+const BINDINGS = new WeakMap();
+function captureOptions(input) {
+  const names = [
+    "backend",
+    "historyAdapter",
+    "releaseRegistry",
+    "transactionLedger",
+  ];
+  if (
+    !input ||
+    isProxy(input) ||
+    Object.getPrototypeOf(input) !== Object.prototype ||
+    Reflect.ownKeys(input).length !== names.length
+  )
+    rrsiFail("Registry History binding requires plain own composition fields");
+  return Object.fromEntries(
+    names.map((name) => {
+      const field = Object.getOwnPropertyDescriptor(input, name);
+      if (!field?.enumerable || !("value" in field))
+        rrsiFail("Registry History binding cannot use accessors");
+      return [name, field.value];
+    }),
+  );
+}
+function same(left, right, label) {
+  if (rrsiCanonical(left) !== rrsiCanonical(right))
+    rrsiFail(
+      `Registry History ${label} differs`,
+      "CC_RRSI_STORAGE_BINDING_DRIFT",
+    );
+}
+function assertGraph(state) {
+  const {
+    backend,
+    backendBinding,
+    history,
+    release,
+    operations,
+    resolver,
+    ports,
+  } = state;
+  if (
+    !backendBinding.matchesLedger(history.ledger) ||
+    backend.ledger !== history.ledger ||
+    !operations.matchesLedger(backend.ledger)
+  )
+    rrsiFail(
+      "Registry transaction ports and History require the same genuine backend journal",
+    );
+  if (!release.matchesTransactionLedger(ports.transactionLedger))
+    rrsiFail("Registry uses another transaction port instance");
+  if (
+    !operations.matchesArtifactPorts(history.artifactPorts) ||
+    !resolver.matchesArtifactPorts(history.artifactPorts) ||
+    !backendBinding.matchesArtifactResolver(history.ledgerArtifactResolver)
+  )
+    rrsiFail(
+      "Registry and History require the original backend artifact ports and resolver",
+    );
+  if (
+    release.tenantId !== history.descriptor.tenantId ||
+    resolver.tenantId !== history.descriptor.artifactTenantId ||
+    resolver.audience !== history.descriptor.audience ||
+    resolver.purpose !== history.descriptor.purpose
+  )
+    rrsiFail("Registry History tenant or artifact scope differs");
+}
+function readGraph(state) {
+  assertGraph(state);
+  for (let attempt = 0; attempt < 3; attempt++) {
+    // v2 verify may legitimately recover a pending, already authorized WAL
+    // suffix. Its complete retained readback still precedes this context.
+    const before = state.operations.currentContext();
+    const root = state.history.resolveCampaignRoot();
+    // The genuine reader rechecks actual Registry directories and marker.
+    // This does not authenticate a persistent origin policy or cutover yet.
+    state.release.readState(state.history.descriptor.goalId);
+    const after = state.operations.currentContext();
+    if (rrsiCanonical(before) !== rrsiCanonical(after)) continue;
+    for (const field of ["ledgerId", "identityDigest", "epoch"])
+      if (root.identity[field] !== after.checkpoint[field])
+        rrsiFail("Registry History root belongs to another journal");
+    return { root, context: after };
+  }
+  rrsiFail(
+    "Registry History changed repeatedly during binding",
+    "CC_RRSI_STORAGE_BINDING_DRIFT",
+  );
+}
+
+export function createRrsiRegistryHistoryBinding(input) {
+  const ports = captureOptions(input),
+    backend = captureEvolutionLedgerFileBackend(ports.backend);
+  const state = {
+    ports,
+    backend,
+    backendBinding: captureEvolutionLedgerFileBackendBinding(ports.backend),
+    history: captureRrsiHistoryLedgerAdapter(ports.historyAdapter),
+    release: captureSkillReleaseRegistryReader(ports.releaseRegistry),
+    operations: captureSkillReleaseOperationReader(ports.transactionLedger),
+  };
+  state.resolver = captureEvolutionLedgerArtifactResolverBinding(
+    state.history.ledgerArtifactResolver,
+  );
+  const { root } = readGraph(state);
+  const descriptor = rrsiEnvelope(
+    RRSI_REGISTRY_HISTORY_BINDING_SCHEMA,
+    "registryHistoryBindingDigest",
+    {
+      tenantId: state.history.descriptor.tenantId,
+      skillName: state.history.descriptor.goalId,
+      artifactTenantId: state.history.descriptor.artifactTenantId,
+      audience: state.history.descriptor.audience,
+      purpose: state.history.descriptor.purpose,
+      historyScopeId: state.history.descriptor.scopeId,
+      ledgerIdentity: root.identity,
+      journalKind: isEvolutionLedgerV2Journal(backend.ledger)
+        ? "manifest-v2"
+        : "file-v1",
+      rootCampaignDigest: root.campaign.campaignDigest,
+      parentReleaseDigest: root.campaign.parentReleaseDigest,
+      anchorReleaseDigest: root.campaign.anchorReleaseDigest,
+      rootRegistrationRecord: root.registrationRecord,
+      transactionJournalObjectIdentityVerified: true,
+      registryTransactionPortObjectIdentityVerified: true,
+      artifactResolverObjectIdentityVerified: true,
+      artifactPortsObjectIdentityVerified: true,
+      registryBoundaryRechecked: true,
+      registryStoreIdentityAuthenticated: false,
+      originCutoverAuthenticated: false,
+      originClassificationAvailable: false,
+      productionAuthorityVerified: false,
+      grantsMutationOrDispatchAuthority: false,
+    },
+  );
+  const binding = Object.freeze({ descriptor });
+  BINDINGS.set(binding, Object.freeze({ ...state, root }));
+  return binding;
+}
+
+export function captureRrsiRegistryHistoryBinding(binding) {
+  const state = BINDINGS.get(binding);
+  if (!state) rrsiFail("a genuine Registry History binding is required");
+  return Object.freeze({
+    descriptor: binding.descriptor,
+    matchesHistory: (historyAdapter) =>
+      captureRrsiHistoryLedgerAdapter(historyAdapter) === state.history,
+    matchesCapturedHistory: (history) => history === state.history,
+    matchesReleaseRegistry: (registry) =>
+      captureSkillReleaseRegistryReader(registry) === state.release,
+    matchesTransactionLedger: (ledger) =>
+      ledger === state.ports.transactionLedger,
+  });
+}
+
+export function recheckRrsiRegistryHistoryBinding(binding) {
+  const state = BINDINGS.get(binding);
+  if (!state) rrsiFail("a genuine Registry History binding is required");
+  const { root, context } = readGraph(state);
+  same(root, state.root, "root registration");
+  return rrsiEnvelope(
+    RRSI_REGISTRY_HISTORY_READBACK_SCHEMA,
+    "registryHistoryReadbackDigest",
+    {
+      registryHistoryBindingDigest:
+        binding.descriptor.registryHistoryBindingDigest,
+      ledgerIdentity: root.identity,
+      currentHead: context.checkpoint,
+      originalStorageGraphRechecked: true,
+      registryBoundaryRechecked: true,
+      originCutoverAuthenticated: false,
+      originClassificationAvailable: false,
+      atomicDispatchOrPromotionAuthorized: false,
+    },
+  );
+}