chainlesschain 0.166.90 → 0.166.92

package/src/lib/evolution/rrsi-native-statistics-protocol.js

@@ -0,0 +1,330 @@
+/** Candidate-independent statistical scope. History must authenticate its registration. */
+import { isProxy } from "node:util/types";
+import { verifyRrsiCampaign } from "./rrsi-contracts.js";
+import {
+  verifySkillDependencyLock,
+  verifySkillRuntimeManifest,
+  verifySkillTargetMatrix,
+} from "./skill-execution-manifest.js";
+import {
+  buildRrsiGroupStatisticsSourceComponents,
+  RRSI_BOUNDED_CLUSTER_METHOD,
+  RRSI_CLUSTER_ENVELOPE_METHOD,
+} from "./rrsi-group-statistics.js";
+import { normalizeRrsiNativeEvaluationBatch } from "./rrsi-native-evaluation-batch.js";
+import { buildRrsiNativeGroupStatisticsPlan } from "./rrsi-native-group-statistics-plan.js";
+import {
+  snapshotRrsiData,
+  rrsiCanonical,
+  rrsiHash,
+  rrsiEnvelope,
+  freezeRrsiData,
+  rrsiFail,
+} from "./rrsi-data.js";
+
+export const RRSI_NATIVE_STATISTICS_SCOPE_PROTOCOL_SCHEMA =
+  "chainlesschain.rrsi-native-statistics-scope-protocol/v1";
+const MAX_BOOTSTRAP_SAMPLES = 1_000_000;
+const MAX_RESAMPLE_OPERATIONS = 50_000_000;
+const STAGES = {
+  training: ["train"],
+  selection: ["select"],
+  generalization: ["gate-validation", "gate-test", "audit"],
+};
+const COMPARISONS = new Set([
+  "rrsi-vs-rsi",
+  "rrsi-vs-baseline",
+  "rsi-vs-baseline",
+]);
+const compare = (a, b) => (a < b ? -1 : a > b ? 1 : 0);
+
+function fields(input, names, label) {
+  if (
+    !input ||
+    isProxy(input) ||
+    Object.getPrototypeOf(input) !== Object.prototype ||
+    Reflect.ownKeys(input).length !== names.length
+  )
+    rrsiFail(`${label} requires plain own fields`);
+  return Object.fromEntries(
+    names.map((name) => {
+      const field = Object.getOwnPropertyDescriptor(input, name);
+      if (!field?.enumerable || !("value" in field))
+        rrsiFail(`${label} cannot use accessors`);
+      return [name, field.value];
+    }),
+  );
+}
+
+function verifiedExecutionContract(input, campaign) {
+  const execution = fields(
+    input,
+    ["dependencyLock", "runtimeManifest", "targetMatrix"],
+    "native statistics execution contract",
+  );
+  // Original manifest validators accept their own null-prototype records and
+  // copy descriptors without executing caller accessors or Proxy traps.
+  const dependencyLock = verifySkillDependencyLock(execution.dependencyLock);
+  const runtimeManifest = verifySkillRuntimeManifest(execution.runtimeManifest);
+  if (
+    !execution.targetMatrix ||
+    typeof execution.targetMatrix !== "object" ||
+    isProxy(execution.targetMatrix)
+  )
+    rrsiFail("native statistics target matrix requires own data fields");
+  const root = Object.getOwnPropertyDescriptor(
+    execution.targetMatrix,
+    "targetMatrixRoot",
+  );
+  const cells = Object.getOwnPropertyDescriptor(
+    execution.targetMatrix,
+    "cells",
+  );
+  if (!root || !("value" in root) || !cells || !("value" in cells))
+    rrsiFail("native statistics target matrix cannot use accessors");
+  const targetMatrix = verifySkillTargetMatrix(execution.targetMatrix, {
+    dependencyLock,
+    runtimeManifest,
+    expectedTargetMatrixRoot: root.value,
+    expectedEnvironmentBindings: cells.value,
+  });
+  if (targetMatrix.tenantId !== campaign.tenantId)
+    rrsiFail("native statistics execution contract belongs to another tenant");
+  return { dependencyLock, runtimeManifest, targetMatrix };
+}
+
+function executionProjection(input, campaign) {
+  const { dependencyLock, runtimeManifest, targetMatrix } =
+    verifiedExecutionContract(input, campaign);
+  return {
+    dependencyLockDigest: dependencyLock.dependencyLockDigest,
+    runtimeManifestDigest: runtimeManifest.runtimeManifestDigest,
+    targetMatrixRoot: targetMatrix.targetMatrixRoot,
+    targets: targetMatrix.cells
+      .map((cell) => ({
+        slotId: cell.cellId,
+        runtimeId: cell.runtimeId,
+        targetEnvironmentRef: cell.targetEnvironmentRef,
+        environmentDigest: cell.environmentDigest,
+      }))
+      .sort((a, b) => compare(a.slotId, b.slotId)),
+  };
+}
+
+/** Convert only independent validator outputs, never stringify caller objects. */
+export function normalizeRrsiNativeStatisticsExecutionContract(input) {
+  const options = fields(
+    input,
+    ["campaign", "execution"],
+    "statistics execution normalization",
+  );
+  const campaign = verifyRrsiCampaign(options.campaign);
+  const verified = verifiedExecutionContract(options.execution, campaign);
+  return freezeRrsiData(snapshotRrsiData(JSON.parse(JSON.stringify(verified))));
+}
+
+function stageDesign(campaign, stage, partitions, targetCount) {
+  const variants =
+    stage === "training"
+      ? ["clean"]
+      : ["clean", ...campaign.experiment.perturbations];
+  const comparisons = campaign.experiment.comparisons.map((id) => {
+    const [leftArm, rightArm] = id.split("-vs-");
+    return { id, leftArm, rightArm };
+  });
+  const pools = partitions.map((partition) => ({
+    partition,
+    partitionDigest: campaign.dataset.pools[partition].partitionDigest,
+    taskCount: campaign.dataset.pools[partition].taskCount,
+    components: buildRrsiGroupStatisticsSourceComponents(campaign, partition),
+  }));
+  const hypothesisCount =
+    comparisons.length * partitions.length * variants.length * targetCount;
+  const alphaPerHypothesis = campaign.experiment.familyAlpha / hypothesisCount;
+  const tailReplicates =
+    (campaign.experiment.bootstrapSamples * alphaPerHypothesis) / 2;
+  const resampleOperations =
+    pools.reduce((sum, pool) => sum + pool.components.length, 0) *
+    variants.length *
+    comparisons.length *
+    campaign.experiment.bootstrapSamples *
+    targetCount;
+  if (resampleOperations > MAX_RESAMPLE_OPERATIONS)
+    rrsiFail(
+      `complete native statistics ${stage} family exceeds resampling operation limit`,
+      "CC_RRSI_BUDGET_EXCEEDED",
+    );
+  return {
+    stage,
+    seeds: campaign.experiment.seeds,
+    variants,
+    comparisons,
+    pools,
+    familyDefinition:
+      "comparisons-times-partitions-times-variants-times-targets/v1",
+    familyAlpha: campaign.experiment.familyAlpha,
+    hypothesisCount,
+    alphaPerHypothesis,
+    bootstrapSamples: campaign.experiment.bootstrapSamples,
+    bootstrapTailReplicates: tailReplicates,
+    bootstrapTailResolutionSufficient: tailReplicates >= 25,
+    resampleOperations,
+    decision: "HOLD",
+    blockingReasons:
+      tailReplicates >= 25 ? [] : ["INSUFFICIENT_BOOTSTRAP_TAIL_RESOLUTION"],
+  };
+}
+
+function scopeProtocol(campaign, execution) {
+  if (campaign.candidateKind !== "skill")
+    rrsiFail("native statistics scope requires a Skill campaign");
+  if (campaign.experiment.bootstrapSamples > MAX_BOOTSTRAP_SAMPLES)
+    rrsiFail("native statistical protocol exceeds the interval kernel bound");
+  if (
+    campaign.experiment.perturbations.includes("clean") ||
+    campaign.experiment.comparisons.some((id) => !COMPARISONS.has(id))
+  )
+    rrsiFail(
+      "native statistics scope has an unsupported variant or comparison",
+    );
+  if (
+    execution.targets.some(
+      (target) =>
+        target.environmentDigest !== campaign.execution.environmentDigest,
+    )
+  )
+    rrsiFail("native statistics target environment differs from campaign");
+  const stages = Object.fromEntries(
+    Object.entries(STAGES).map(([stage, partitions]) => [
+      stage,
+      stageDesign(campaign, stage, partitions, execution.targets.length),
+    ]),
+  );
+  const protocol = rrsiEnvelope(
+    RRSI_NATIVE_STATISTICS_SCOPE_PROTOCOL_SCHEMA,
+    "protocolDigest",
+    {
+      // Campaign aliases and per-query candidate/native plan identities do not
+      // create a new scope. Every fixed scientific and execution input does.
+      campaignScope: {
+        tenantId: campaign.tenantId,
+        goalId: campaign.goalId,
+        candidateKind: campaign.candidateKind,
+        sourceCommitSha: campaign.sourceCommitSha,
+        parentReleaseDigest: campaign.parentReleaseDigest,
+        anchorReleaseDigest: campaign.anchorReleaseDigest,
+        policyDigest: campaign.policy.policyDigest,
+        datasetDigest: campaign.dataset.datasetDigest,
+        execution: campaign.execution,
+        budgetDigest: rrsiHash(
+          "chainlesschain.rrsi-root-budget/v1",
+          campaign.budget,
+        ),
+        experiment: campaign.experiment,
+      },
+      execution,
+      stages,
+      fixedPairReplicasPerTaskSeedArm: 2,
+      aggregationMethod:
+        "mean-fixed-pair-replicas-then-seeds-then-task-weighted-source-components/v2",
+      successDefinition:
+        "reported-pass-and-zero-security-and-permission-violations/v2",
+      manualRemediationMeasured: false,
+      randomnessCommitment: campaign.experiment.randomnessCommitment,
+      resamplingUnit: "task-group-component",
+      bootstrapMethod: "task-weighted-cluster-percentile/v1",
+      boundedMethod: RRSI_BOUNDED_CLUSTER_METHOD,
+      intervalMethod: RRSI_CLUSTER_ENVELOPE_METHOD,
+      minimumIndependentGroups: campaign.policy.thresholds.minIndependentGroups,
+      stoppingRule: "fixed-full-denominator-no-interim-acceptance",
+      maxBootstrapSamples: MAX_BOOTSTRAP_SAMPLES,
+      maxResampleOperations: MAX_RESAMPLE_OPERATIONS,
+      operationLimitScope: "complete-family-per-stage/v1",
+      alphaControlScope: "per-stage-family-not-across-adaptive-queries/v1",
+      decision: "HOLD",
+      preObservationRegistrationVerified: false,
+      sourceIndependenceVerified: false,
+      perturbationSemanticsVerified: false,
+      statisticalProtocolValidated: false,
+    },
+  );
+  snapshotRrsiData(protocol);
+  return protocol;
+}
+
+/** Works before preparation: no candidate, batch, native plan or result is accepted. */
+export function buildRrsiNativeStatisticsScopeProtocol(input) {
+  const options = fields(input, ["campaign", "execution"], "statistics scope");
+  const campaign = verifyRrsiCampaign(options.campaign);
+  return scopeProtocol(
+    campaign,
+    executionProjection(options.execution, campaign),
+  );
+}
+
+export function verifyRrsiNativeStatisticsScopeProtocol(protocol, context) {
+  const rebuilt = buildRrsiNativeStatisticsScopeProtocol(context);
+  if (rrsiCanonical(snapshotRrsiData(protocol)) !== rrsiCanonical(rebuilt))
+    rrsiFail("native statistics scope protocol differs");
+  return rebuilt;
+}
+
+/** Structural match only. Genuine History separately proves registration order. */
+export function assertRrsiNativeStatisticsScopeBatch(protocol, context) {
+  const options = fields(
+    context,
+    ["campaign", "batch"],
+    "statistics scope batch",
+  );
+  const campaign = verifyRrsiCampaign(options.campaign);
+  const batch = normalizeRrsiNativeEvaluationBatch(options.batch, campaign);
+  const expected = scopeProtocol(campaign, {
+    dependencyLockDigest: batch.parentIdentity.dependencyLockDigest,
+    runtimeManifestDigest: batch.parentIdentity.runtimeManifestDigest,
+    targetMatrixRoot: batch.parentIdentity.targetMatrixRoot,
+    targets: batch.targetIdentity
+      .map(([slotId, runtimeId, targetEnvironmentRef, environmentDigest]) => ({
+        slotId,
+        runtimeId,
+        targetEnvironmentRef,
+        environmentDigest,
+      }))
+      .sort((a, b) => compare(a.slotId, b.slotId)),
+  });
+  if (rrsiCanonical(snapshotRrsiData(protocol)) !== rrsiCanonical(expected))
+    rrsiFail("native batch changes the frozen statistics scope protocol");
+  const plan = buildRrsiNativeGroupStatisticsPlan({ campaign, batch });
+  for (const field of [
+    "seeds",
+    "variants",
+    "comparisons",
+    "pools",
+    "familyAlpha",
+    "hypothesisCount",
+    "alphaPerHypothesis",
+    "bootstrapSamples",
+    "bootstrapTailReplicates",
+    "bootstrapTailResolutionSufficient",
+    "resampleOperations",
+  ])
+    if (
+      rrsiCanonical(plan[field]) !==
+      rrsiCanonical(expected.stages[batch.stage][field])
+    )
+      rrsiFail(`native statistics plan changes the frozen ${field}`);
+  for (const field of [
+    "fixedPairReplicasPerTaskSeedArm",
+    "aggregationMethod",
+    "successDefinition",
+    "manualRemediationMeasured",
+    "randomnessCommitment",
+    "resamplingUnit",
+    "bootstrapMethod",
+    "boundedMethod",
+    "minimumIndependentGroups",
+    "stoppingRule",
+  ])
+    if (rrsiCanonical(plan[field]) !== rrsiCanonical(expected[field]))
+      rrsiFail(`native statistics plan changes the frozen ${field}`);
+  return plan;
+}

package/src/lib/evolution/rrsi-parent-binding.js

@@ -0,0 +1,290 @@
+/** Effective Skill parent readback binding; never replaces mutation CAS or admission. */
+import { isProxy } from "node:util/types";
+import { captureSkillReleaseRegistryReader } from "./skill-release-registry.js";
+import { verifyRrsiCampaign } from "./rrsi-contracts.js";
+import {
+  captureRrsiRegistryHistoryBinding,
+  recheckRrsiRegistryHistoryBinding,
+} from "./rrsi-registry-history-binding.js";
+import {
+  snapshotRrsiData,
+  rrsiExact,
+  rrsiDigest,
+  rrsiInteger,
+  rrsiCanonical,
+  rrsiEnvelope,
+  rrsiFail,
+} from "./rrsi-data.js";
+
+export const RRSI_PARENT_BINDING_SCHEMA =
+  "chainlesschain.rrsi-effective-parent-binding/v1";
+export const RRSI_PARENT_READBACK_SCHEMA =
+  "chainlesschain.rrsi-effective-parent-readback/v1";
+export const RRSI_PARENT_BINDING_V2_SCHEMA =
+  "chainlesschain.rrsi-effective-parent-binding/v2";
+export const RRSI_PARENT_READBACK_V2_SCHEMA =
+  "chainlesschain.rrsi-effective-parent-readback/v2";
+const BINDINGS = new WeakMap();
+
+function options(input, extraKeys = []) {
+  const keys = [
+    "campaign",
+    "releaseRegistry",
+    "transactionLedger",
+    "expectedParent",
+    ...extraKeys,
+  ];
+  if (
+    !input ||
+    typeof input !== "object" ||
+    isProxy(input) ||
+    Object.getPrototypeOf(input) !== Object.prototype ||
+    Reflect.ownKeys(input).length !== keys.length
+  )
+    rrsiFail("effective parent composition requires plain own fields");
+  return Object.fromEntries(
+    keys.map((key) => {
+      const field = Object.getOwnPropertyDescriptor(input, key);
+      if (!field?.enumerable || !("value" in field))
+        rrsiFail("effective parent composition cannot use accessors");
+      return [key, field.value];
+    }),
+  );
+}
+
+function readParent(reader, campaign, expected) {
+  const current = reader.readActive(campaign.goalId);
+  if (
+    !current ||
+    current.state.tenantId !== campaign.tenantId ||
+    current.release.tenantId !== campaign.tenantId ||
+    current.state.skillName !== campaign.goalId ||
+    current.release.skillName !== campaign.goalId ||
+    current.state.activeReleaseDigest !== campaign.parentReleaseDigest ||
+    current.release.releaseDigest !== campaign.parentReleaseDigest ||
+    current.state.revision !== expected.revision ||
+    current.state.stateDigest !== expected.stateDigest ||
+    current.release.contentDigest !== expected.contentDigest
+  )
+    rrsiFail(
+      "effective parent differs from frozen active release, content or revision",
+      "CC_RRSI_PARENT_DRIFT",
+    );
+  // Preserve the campaign's initial anchor even when the registry LKG moves.
+  // A readable release does not prove activation, stability or suitability.
+  const parent = reader.readRelease(campaign.parentReleaseDigest);
+  const anchor = reader.readRelease(campaign.anchorReleaseDigest);
+  if (
+    rrsiCanonical(parent) !== rrsiCanonical(current.release) ||
+    anchor.tenantId !== campaign.tenantId ||
+    anchor.skillName !== campaign.goalId
+  )
+    rrsiFail(
+      "parent or campaign anchor readback differs",
+      "CC_RRSI_PARENT_DRIFT",
+    );
+  // Detect a committed transition during multi-artifact readback. Dispatch and
+  // promotion still need the registry's own atomic authorization/CAS boundary.
+  const after = reader.readActive(campaign.goalId);
+  if (!after || rrsiCanonical(after) !== rrsiCanonical(current))
+    rrsiFail(
+      "effective parent changed during readback",
+      "CC_RRSI_PARENT_DRIFT",
+    );
+  return {
+    parentContentDigest: parent.contentDigest,
+    parentCandidateId: parent.candidateId,
+    activeRevision: current.state.revision,
+    activeStateDigest: current.state.stateDigest,
+    stateTransactionId: current.state.transactionId,
+    stateAuthorityReceiptDigest: current.state.authorityReceiptDigest,
+    stateFence: current.state.fence,
+    lastKnownGoodReleaseDigest: current.state.lastKnownGoodReleaseDigest,
+    dependencyLockDigest: parent.dependencyLockDigest,
+    runtimeManifestDigest: parent.runtimeManifestDigest,
+    targetMatrixRoot: parent.targetMatrixRoot,
+    targetRuntimes: parent.targetRuntimes,
+    anchorContentDigest: anchor.contentDigest,
+    anchorIdentity: {
+      candidateId: anchor.candidateId,
+      dependencyLockDigest: anchor.dependencyLockDigest,
+      runtimeManifestDigest: anchor.runtimeManifestDigest,
+      targetMatrixRoot: anchor.targetMatrixRoot,
+      targetRuntimes: anchor.targetRuntimes,
+    },
+  };
+}
+
+export function createRrsiEffectiveParentBinding(input) {
+  const value = options(input);
+  const campaign = verifyRrsiCampaign(snapshotRrsiData(value.campaign));
+  if (campaign.candidateKind !== "skill")
+    rrsiFail(
+      "Skill release parent adapter cannot authenticate a Memory-policy parent",
+    );
+  const reader = captureSkillReleaseRegistryReader(value.releaseRegistry);
+  if (reader.tenantId !== campaign.tenantId)
+    rrsiFail("effective parent registry belongs to another tenant");
+  if (
+    !value.transactionLedger ||
+    !reader.matchesTransactionLedger(value.transactionLedger)
+  )
+    rrsiFail("effective parent registry uses another transaction Ledger");
+  const expected = snapshotRrsiData(value.expectedParent);
+  rrsiExact(
+    expected,
+    ["revision", "stateDigest", "contentDigest"],
+    "frozen effective parent",
+  );
+  rrsiInteger(expected.revision, "effective parent revision", 1);
+  rrsiDigest(expected.stateDigest, "effective parent state digest");
+  rrsiDigest(expected.contentDigest, "effective parent content digest");
+  const identity = readParent(reader, campaign, expected);
+  const descriptor = rrsiEnvelope(
+    RRSI_PARENT_BINDING_SCHEMA,
+    "parentBindingDigest",
+    {
+      campaignDigest: campaign.campaignDigest,
+      tenantId: campaign.tenantId,
+      skillName: campaign.goalId,
+      candidateKind: campaign.candidateKind,
+      parentReleaseDigest: campaign.parentReleaseDigest,
+      anchorReleaseDigest: campaign.anchorReleaseDigest,
+      ...identity,
+      registryReadbackVerified: true,
+      transactionLedgerBound: true,
+      transactionLedgerAuthorityVerified: false,
+      productionAuthorityVerified: false,
+      anchorPolicy: "frozen-campaign-anchor-artifact-reference",
+      anchorArtifactIntegrityVerified: true,
+      anchorHistoricalActivationVerified: false,
+      anchorStabilityVerified: false,
+      anchorRevocationStatusVerified: false,
+      anchorDeploymentCompatibilityVerified: false,
+      deploymentAdmissionVerified: false,
+      historicalStabilityIndependentlyVerified: false,
+      sourceProvenanceVerified: false,
+      modelPricingAdmissionVerified: false,
+      grantsMutationOrDispatchAuthority: false,
+    },
+  );
+  const binding = Object.freeze({ descriptor });
+  BINDINGS.set(binding, { reader, campaign, expected, identity });
+  return binding;
+}
+
+/** Versioned storage association keeps all existing parent and anchor checks. */
+export function createRrsiEffectiveParentBindingV2(input) {
+  const value = options(input, ["registryHistoryBinding"]);
+  const storage = captureRrsiRegistryHistoryBinding(
+    value.registryHistoryBinding,
+  );
+  recheckRrsiRegistryHistoryBinding(value.registryHistoryBinding);
+  if (
+    !storage.matchesReleaseRegistry(value.releaseRegistry) ||
+    !storage.matchesTransactionLedger(value.transactionLedger)
+  )
+    rrsiFail(
+      "effective parent requires the Registry History binding's actual registry and transaction ports",
+    );
+  const campaign = verifyRrsiCampaign(value.campaign);
+  for (const [field, expected] of [
+    ["tenantId", campaign.tenantId],
+    ["skillName", campaign.goalId],
+    ["parentReleaseDigest", campaign.parentReleaseDigest],
+    ["anchorReleaseDigest", campaign.anchorReleaseDigest],
+  ])
+    if (storage.descriptor[field] !== expected)
+      rrsiFail("effective parent differs from the bound History scope");
+  const original = createRrsiEffectiveParentBinding({
+    campaign: value.campaign,
+    releaseRegistry: value.releaseRegistry,
+    transactionLedger: value.transactionLedger,
+    expectedParent: value.expectedParent,
+  });
+  const core = Object.fromEntries(
+    Object.entries(original.descriptor).filter(
+      ([name]) =>
+        ![
+          "schema",
+          "parentBindingDigest",
+          "structuralOnly",
+          "authenticated",
+          "readyForExecution",
+          "qualifiesForPromotion",
+        ].includes(name),
+    ),
+  );
+  const descriptor = rrsiEnvelope(
+    RRSI_PARENT_BINDING_V2_SCHEMA,
+    "parentBindingDigest",
+    {
+      ...core,
+      registryHistoryBindingDigest:
+        storage.descriptor.registryHistoryBindingDigest,
+      ledgerIdentity: storage.descriptor.ledgerIdentity,
+      transactionJournalObjectIdentityVerified: true,
+      backendArtifactPortsAndResolverIdentityVerified: true,
+      registryOriginCutoverAuthenticated: false,
+    },
+  );
+  recheckRrsiRegistryHistoryBinding(value.registryHistoryBinding);
+  const binding = Object.freeze({ descriptor });
+  BINDINGS.set(binding, {
+    ...BINDINGS.get(original),
+    registryHistoryBinding: value.registryHistoryBinding,
+  });
+  return binding;
+}
+
+/** The PM bridge passes its captured genuine History, never a descriptor. */
+export function assertRrsiEffectiveParentHistory(binding, history) {
+  const state = BINDINGS.get(binding);
+  if (!state?.registryHistoryBinding)
+    rrsiFail("effective parent requires a genuine Registry History binding");
+  if (
+    !captureRrsiRegistryHistoryBinding(
+      state.registryHistoryBinding,
+    ).matchesCapturedHistory(history)
+  )
+    rrsiFail(
+      "effective parent and PM bridge use different genuine History compositions",
+    );
+  recheckRrsiRegistryHistoryBinding(state.registryHistoryBinding);
+}
+
+/** A recovered JSON descriptor is not a live read capability. */
+export function recheckRrsiEffectiveParent(binding) {
+  const state = BINDINGS.get(binding);
+  if (!state) rrsiFail("a branded live effective-parent binding is required");
+  if (state.registryHistoryBinding)
+    recheckRrsiRegistryHistoryBinding(state.registryHistoryBinding);
+  const identity = readParent(state.reader, state.campaign, state.expected);
+  if (rrsiCanonical(identity) !== rrsiCanonical(state.identity))
+    rrsiFail(
+      "effective parent immutable identity changed",
+      "CC_RRSI_PARENT_DRIFT",
+    );
+  if (state.registryHistoryBinding)
+    recheckRrsiRegistryHistoryBinding(state.registryHistoryBinding);
+  return rrsiEnvelope(
+    state.registryHistoryBinding
+      ? RRSI_PARENT_READBACK_V2_SCHEMA
+      : RRSI_PARENT_READBACK_SCHEMA,
+    "parentReadbackDigest",
+    {
+      parentBindingDigest: binding.descriptor.parentBindingDigest,
+      registryReadbackVerified: true,
+      effectiveParentUnchanged: true,
+      atomicDispatchOrPromotionAuthorized: false,
+      ...(state.registryHistoryBinding
+        ? {
+            registryHistoryBindingDigest:
+              binding.descriptor.registryHistoryBindingDigest,
+            originalStorageGraphRechecked: true,
+            registryOriginCutoverAuthenticated: false,
+          }
+        : {}),
+    },
+  );
+}