blun-king-cli 9.1.567 → 9.1.570

package/agent-spine-plugin/src/lib/learning-reconciliation.js

@@ -0,0 +1,290 @@
+import { createHash, randomUUID } from "node:crypto";
+import {
+  ID_RE, DIGEST_RE, ROOT_BOUND_EVALUATIONS, REGISTRY_BOUND_EVALUATIONS, INITIAL_TRIAL_EVALUATIONS, TARGET_BOUND_EVALUATIONS,
+  BOUNDED_TRIAL_RETRY_EVALUATIONS, BLOCKING_DEFECT_BOUND_EVALUATIONS, INITIAL_TRIAL_APPLICATIONS, TARGET_BOUND_APPLICATIONS, TRIAL_FAILURE_REVOCATION_REASONS
+} from "./learning-schema.js";
+import {
+  exactScope, digest, learningTargetForCandidate, revokedMeasurement, activeEvaluationBinding, revokedEvaluation
+} from "./learning-scope-targets.js";
+import {
+  revokedEvidenceSourceAttestation
+} from "./learning-measurement-contracts.js";
+import {
+  trialFailurePayload, storedTrialFailureStructure, trialFailureMatchesState, trialFailureRevocationPayload
+} from "./learning-evaluation-contracts.js";
+import {
+  revokedTrialFailure, trialRetryExhaustionPayload, trialRetryExhaustionMatchesState
+} from "./learning-retry-contracts.js";
+import {
+  date, safeText, mutation, preserve
+} from "./learning-storage.js";
+import {
+  outcomeFresh
+} from "./learning-applications.js";
+
+export function outcomeMatchesContract(receipt, contract) {
+  if (ROOT_BOUND_EVALUATIONS.has(contract.schema)) {
+    const root = contract.evaluatorRoots.find((item) => item.evaluatorId === receipt.measurement?.evaluatorId);
+    return receipt.schema === "agentspine.learning-outcome/v9"
+      && ID_RE.test(receipt.measurementReceiptId || "") && DIGEST_RE.test(receipt.measurementReceiptDigest || "")
+      && DIGEST_RE.test(receipt.measurement?.sourceDigest || "")
+      && root?.principalDigest === receipt.measurement?.evaluatorRootDigest
+      && receipt.coverage?.datasetDigest === contract.benchmark.datasetDigest
+      && receipt.coverage?.caseCount >= contract.benchmark.minCases;
+  }
+  if (contract.schema === "agentspine.learning-evaluation/v5") {
+    return receipt.schema === "agentspine.learning-outcome/v8"
+      && ID_RE.test(receipt.measurementReceiptId || "") && DIGEST_RE.test(receipt.measurementReceiptDigest || "")
+      && DIGEST_RE.test(receipt.measurement?.sourceDigest || "")
+      && receipt.coverage?.datasetDigest === contract.benchmark.datasetDigest
+      && receipt.coverage?.caseCount >= contract.benchmark.minCases;
+  }
+  if (contract.schema === "agentspine.learning-evaluation/v4") {
+    return receipt.schema === "agentspine.learning-outcome/v7"
+      && ID_RE.test(receipt.measurementReceiptId || "") && DIGEST_RE.test(receipt.measurementReceiptDigest || "")
+      && DIGEST_RE.test(receipt.measurement?.sourceDigest || "")
+      && receipt.coverage?.datasetDigest === contract.benchmark.datasetDigest
+      && receipt.coverage?.caseCount >= contract.benchmark.minCases;
+  }
+  if (contract.schema === "agentspine.learning-evaluation/v3") {
+    return receipt.schema === "agentspine.learning-outcome/v6"
+      && DIGEST_RE.test(receipt.measurement?.sourceDigest || "")
+      && receipt.coverage?.datasetDigest === contract.benchmark.datasetDigest
+      && receipt.coverage?.caseCount >= contract.benchmark.minCases;
+  }
+  if (contract.schema === "agentspine.learning-evaluation/v2") {
+    return receipt.schema === "agentspine.learning-outcome/v5"
+      && receipt.coverage?.datasetDigest === contract.benchmark.datasetDigest
+      && receipt.coverage?.caseCount >= contract.benchmark.minCases;
+  }
+  return ["agentspine.learning-outcome/v3", "agentspine.learning-outcome/v4"].includes(receipt.schema);
+}
+
+export function outcomeMatchesInitialTrial(state, receipt, contract) {
+  if (!INITIAL_TRIAL_EVALUATIONS.has(contract?.schema)) return true;
+  const trial = contract.initialTrials?.[receipt.phase]?.find((entry) =>
+    entry.evaluatorId === receipt.measurement?.evaluatorId);
+  const measurement = state.measurements.find((entry) => entry.id === receipt.measurementReceiptId
+    && entry.digest === receipt.measurementReceiptDigest);
+  if (!trial || !measurement || measurement.measurement.evaluatorRootDigest !== trial.evaluatorRootDigest
+    || measurement.measurement.runId !== trial.runId || measurement.coverage.caseCount !== trial.caseCount) return false;
+  if (receipt.phase !== "after") return true;
+  const application = state.applications.find((entry) => entry.id === receipt.applicationId
+    && INITIAL_TRIAL_APPLICATIONS.has(entry.schema)
+    && entry.initialAdmission.evaluationId === contract.id
+    && entry.initialAdmission.evaluationDigest === contract.digest
+    && entry.initialAdmission.slot === trial.slot
+    && entry.initialAdmission.trialDigest === trial.trialDigest
+    && (!TARGET_BOUND_EVALUATIONS.has(contract.schema)
+      || (TARGET_BOUND_APPLICATIONS.has(entry.schema)
+        && entry.initialAdmission.targetDigest === contract.target.digest)));
+  const delivery = application && state.deliveries.find((entry) => entry.id === receipt.deliveryId
+    && entry.applicationId === application.id);
+  return Boolean(application && delivery);
+}
+
+export function promotableReceipts(state, candidate, timestamp) {
+  const contracts = state.evaluations.filter((contract) => contract.learningId === candidate.id
+    && !revokedEvaluation(state, contract.id)
+    && !revokedEvidenceSourceAttestation(state, contract.id)
+    && new Date(contract.expiresAt).getTime() >= new Date(timestamp).getTime()
+    && (!REGISTRY_BOUND_EVALUATIONS.has(contract.schema)
+      || activeEvaluationBinding(state, contract)));
+  const groups = contracts.map((contract) => {
+    const receipts = state.outcomes.filter((item) => outcomeMatchesContract(item, contract)
+      && item.learningId === candidate.id && item.evaluationId === contract.id && item.phase === "before"
+      && exactScope(item.scope, contract.scope) && outcomeFresh(item, contract, state.config, timestamp)
+      && !revokedMeasurement(state, item.measurementReceiptId)
+      && item.measurement.kind !== "model-suggestion" && outcomeMatchesInitialTrial(state, item, contract));
+    if (INITIAL_TRIAL_EVALUATIONS.has(contract.schema)) receipts.sort((a, b) =>
+      contract.initialTrials.before.findIndex((trial) => trial.evaluatorId === a.measurement.evaluatorId)
+      - contract.initialTrials.before.findIndex((trial) => trial.evaluatorId === b.measurement.evaluatorId));
+    return { contract, receipts };
+  }).filter(({ contract, receipts }) => receipts.some((item) => item.measurement.kind === "objective")
+    && (!BLOCKING_DEFECT_BOUND_EVALUATIONS.has(contract.schema)
+      || receipts.every((item) => item.metric.blockingDefects === 0))
+    && new Set(receipts.map((item) => ROOT_BOUND_EVALUATIONS.has(contract.schema)
+      ? item.measurement.evaluatorRootDigest : item.measurement.evaluatorId)).size >= contract.thresholds.beforeReceipts)
+    .sort((a, b) => b.receipts.length - a.receipts.length || a.contract.id.localeCompare(b.contract.id));
+  return groups[0] || null;
+}
+
+export function improvement(direction, baseline, value) {
+  return direction === "higher" ? value - baseline : baseline - value;
+}
+
+export function rollbackCandidate(state, candidate, reason, timestamp, mode = "manual", trialFailure = null) {
+  preserve(state, "learning-candidate", candidate, timestamp);
+  const validationLeaseId = candidate.promotion?.mode === "outcome-canary"
+    ? candidate.promotion.canary?.validationLeaseId : null;
+  if (validationLeaseId) {
+    const validationLease = state.validationLeases.find((entry) => entry.id === validationLeaseId);
+    preserve(state, "learning-validation", validationLease, timestamp);
+    state.validationLeases = state.validationLeases.filter((entry) => entry.id !== validationLeaseId);
+  }
+  const restored = [];
+  for (const previousId of candidate.supersededIds || []) {
+    const previous = state.candidates.find((entry) => entry.id === previousId);
+    if (previous?.status === "superseded") {
+      preserve(state, "learning-candidate", previous, timestamp);
+      state.candidates = state.candidates.map((entry) => entry.id === previousId
+        ? { ...entry, status: "accepted", updatedAt: timestamp, authority: "context-only" }
+        : entry);
+      restored.push(previousId);
+    }
+  }
+  const rolledBack = {
+    ...candidate,
+    status: "rolled-back",
+    ...(candidate.promotion?.mode === "outcome-canary" ? {
+      promotion: { ...candidate.promotion, canary: { ...candidate.promotion.canary, revalidation: null } }
+    } : {}),
+    updatedAt: timestamp,
+    rollback: {
+      reason,
+      mode,
+      rolledBackAt: timestamp,
+      ...(trialFailure ? { trialFailureId: trialFailure.id, trialFailureDigest: trialFailure.digest } : {}),
+      authority: "context-only"
+    },
+    authority: "context-only"
+  };
+  state.candidates = state.candidates.map((entry) => entry.id === candidate.id ? rolledBack : entry);
+  return { candidate: rolledBack, restored };
+}
+
+export function recordInitialTrialFailure(state, timeout, timestamp) {
+  const { evaluation, application, failure, deadline } = timeout;
+  const id = `trial-failure:${createHash("sha256").update(`${application.id}\0${failure}`).digest("hex").slice(0, 32)}`;
+  const payload = trialFailurePayload({
+    id,
+    learningId: application.learningId,
+    evaluationId: evaluation.id,
+    evaluationDigest: evaluation.digest,
+    applicationId: application.id,
+    applicationDigest: application.digest,
+    slot: application.initialAdmission.slot,
+    trialDigest: application.initialAdmission.trialDigest,
+    targetDigest: application.initialAdmission.targetDigest,
+    completionPolicyDigest: application.completionPolicyDigest,
+    failure,
+    deadline,
+    observedAt: timestamp
+  });
+  const receipt = { ...payload, digest: digest(payload) };
+  const existing = state.trialFailures.find((entry) => entry.id === id);
+  if (existing) {
+    if (existing.applicationId !== application.id || existing.failure !== failure) {
+      throw new Error("learning trial failure receipt IDs are immutable");
+    }
+    return existing;
+  }
+  state.trialFailures.push(receipt);
+  state.trialFailures.sort((a, b) => a.id.localeCompare(b.id));
+  return receipt;
+}
+
+export function recordTrialRetryExhaustion(state, failure) {
+  const evaluation = state.evaluations.find((entry) => entry.id === failure.evaluationId
+    && entry.digest === failure.evaluationDigest && entry.learningId === failure.learningId);
+  if (!evaluation || !BOUNDED_TRIAL_RETRY_EVALUATIONS.has(evaluation.schema)) return null;
+  const retry = evaluation.retry;
+  const id = `trial-retry-exhaustion:${createHash("sha256")
+    .update(`${retry.rootEvaluationId}\0${evaluation.id}\0${failure.id}`).digest("hex").slice(0, 32)}`;
+  const payload = trialRetryExhaustionPayload({
+    id,
+    learningId: failure.learningId,
+    rootEvaluationId: retry.rootEvaluationId,
+    rootEvaluationDigest: retry.rootEvaluationDigest,
+    correctiveEvaluationId: evaluation.id,
+    correctiveEvaluationDigest: evaluation.digest,
+    trialFailureId: failure.id,
+    trialFailureDigest: failure.digest,
+    targetDigest: evaluation.target.digest,
+    scopeDigest: digest(evaluation.scope),
+    attempt: retry.attempt,
+    maxAttempts: retry.maxAttempts,
+    exhaustedAt: failure.observedAt
+  });
+  const receipt = { ...payload, digest: digest(payload) };
+  const existing = state.trialRetryExhaustions.find((entry) => entry.id === id);
+  if (existing) {
+    if (existing.digest !== receipt.digest) throw new Error("learning trial retry exhaustion IDs are immutable");
+    return existing;
+  }
+  if (!trialRetryExhaustionMatchesState(state, receipt)) {
+    throw new Error("learning trial retry exhaustion binding is invalid");
+  }
+  state.trialRetryExhaustions.push(receipt);
+  state.trialRetryExhaustions.sort((a, b) => a.id.localeCompare(b.id));
+  return receipt;
+}
+
+export async function revokeLearningTrialFailure({
+  root = process.cwd(), trialFailureId, reasonCode, reason, confirmation, now = new Date()
+}) {
+  if (confirmation !== "local-trial-failure-revocation-confirmed") {
+    throw new Error("trial failure revocation requires explicit local confirmation");
+  }
+  if (!ID_RE.test(trialFailureId || "")) throw new Error("trialFailureId must be a stable identifier");
+  if (!TRIAL_FAILURE_REVOCATION_REASONS.has(reasonCode)) {
+    throw new Error("reasonCode must be clock-invalid, host-invalid, receipt-invalid, scope-invalid, duplicate, or other");
+  }
+  const revokeReason = safeText(reason, "reason", 500);
+  const timestamp = date(now, "now");
+  return mutation(root, (state, _catalog, learningPath) => {
+    const failure = state.trialFailures.find((entry) => entry.id === trialFailureId);
+    if (!failure || !storedTrialFailureStructure(failure) || !trialFailureMatchesState(state, failure)) {
+      throw new Error(`unknown or non-current learning trial failure: ${trialFailureId}`);
+    }
+    const candidate = state.candidates.find((entry) => entry.id === failure.learningId);
+    const evaluation = state.evaluations.find((entry) => entry.id === failure.evaluationId
+      && entry.digest === failure.evaluationDigest);
+    const binding = state.evaluationBindings.find((entry) => entry.evaluationId === failure.evaluationId
+      && entry.evaluationDigest === failure.evaluationDigest);
+    const application = state.applications.find((entry) => entry.id === failure.applicationId
+      && entry.digest === failure.applicationDigest);
+    if (!candidate || !evaluation || !binding || !application) {
+      throw new Error("trial failure revocation requires its immutable candidate, contract, binding, and application");
+    }
+    const targetDigest = learningTargetForCandidate(candidate).digest;
+    const scopeDigest = digest(application.scope);
+    const reasonDigest = digest(revokeReason);
+    const existing = revokedTrialFailure(state, trialFailureId);
+    if (existing) {
+      if (existing.reasonCode !== reasonCode || existing.reasonDigest !== reasonDigest
+        || existing.learningId !== candidate.id || existing.evaluationId !== evaluation.id
+        || existing.evaluationDigest !== evaluation.digest || existing.evaluatorBindingDigest !== binding.digest
+        || existing.applicationId !== application.id || existing.applicationDigest !== application.digest
+        || existing.trialFailureDigest !== failure.digest || existing.targetDigest !== targetDigest
+        || existing.scopeDigest !== scopeDigest) {
+        throw new Error("learning trial failure revocations are immutable");
+      }
+      return { receipt: existing, learningPath, unchanged: true, requiresFreshCandidate: true,
+        authority: "context-only" };
+    }
+    const id = `trial-failure-revocation:${createHash("sha256")
+      .update(`${failure.id}\0${failure.digest}\0${targetDigest}`).digest("hex").slice(0, 32)}`;
+    const payload = trialFailureRevocationPayload({
+      id,
+      learningId: candidate.id,
+      evaluationId: evaluation.id,
+      evaluationDigest: evaluation.digest,
+      evaluatorBindingDigest: binding.digest,
+      applicationId: application.id,
+      applicationDigest: application.digest,
+      trialFailureId: failure.id,
+      trialFailureDigest: failure.digest,
+      targetDigest,
+      scopeDigest,
+      reasonCode,
+      reasonDigest,
+      revokedAt: timestamp
+    });
+    const receipt = { ...payload, digest: digest(payload) };
+    state.trialFailureRevocations.push(receipt);
+    state.trialFailureRevocations.sort((a, b) => a.id.localeCompare(b.id));
+    return { receipt, learningPath, unchanged: false, requiresFreshCandidate: true,
+      authority: "context-only" };
+  });
+}

package/agent-spine-plugin/src/lib/learning-retry-contracts.js

@@ -0,0 +1,188 @@
+import {
+  ID_RE, DIGEST_RE, TRIAL_RETRY_EVALUATIONS, COMPARABLE_TRIAL_RETRY_EVALUATIONS, BOUNDED_TRIAL_RETRY_EVALUATIONS
+} from "./learning-schema.js";
+import {
+  exactScope, digest, learningTargetForCandidate
+} from "./learning-scope-targets.js";
+import {
+  trialComparisonDigest, storedTrialRetryStructure
+} from "./learning-evidence-contracts.js";
+import {
+  trialFailureMatchesState, trialFailureRevocationMatchesState
+} from "./learning-evaluation-contracts.js";
+
+export function revokedTrialFailure(state, trialFailureId) {
+  return state.trialFailureRevocations.find((receipt) => receipt.trialFailureId === trialFailureId) || null;
+}
+
+export function evidenceIdentity(evidence) {
+  return evidence.sourceSha256 || evidence.sourceDocument || evidence.id;
+}
+
+export function retryableTrialFailures(state, candidate) {
+  return state.trialFailureRevocations.map((revocation) => {
+    const failure = state.trialFailures.find((entry) => entry.id === revocation.trialFailureId
+      && entry.digest === revocation.trialFailureDigest);
+    const predecessor = state.candidates.find((entry) => entry.id === revocation.learningId);
+    return { revocation, failure, predecessor };
+  }).filter(({ revocation, failure, predecessor }) => failure && predecessor
+    && predecessor.id !== candidate.id && predecessor.status === "rolled-back"
+    && predecessor.kind === candidate.kind && predecessor.claim === candidate.claim
+    && predecessor.subjectId === candidate.subjectId && predecessor.privacy === candidate.privacy
+    && predecessor.groupId === candidate.groupId && exactScope(predecessor.scope, candidate.scope)
+    && trialFailureRevocationMatchesState(state, revocation))
+    .sort((left, right) => new Date(left.revocation.revokedAt).getTime()
+      - new Date(right.revocation.revokedAt).getTime());
+}
+
+export function trialRetryMatchesState(state, contract) {
+  if (!TRIAL_RETRY_EVALUATIONS.has(contract?.schema) || !storedTrialRetryStructure(contract.retry)) return false;
+  const retry = contract.retry;
+  const failure = state.trialFailures.find((entry) => entry.id === retry.trialFailureId
+    && entry.digest === retry.trialFailureDigest);
+  const revocation = state.trialFailureRevocations.find((entry) => entry.id === retry.trialFailureRevocationId
+    && entry.digest === retry.trialFailureRevocationDigest && entry.trialFailureId === retry.trialFailureId);
+  const predecessor = state.candidates.find((entry) => entry.id === retry.predecessorLearningId);
+  const candidate = state.candidates.find((entry) => entry.id === retry.learningId);
+  const predecessorEvaluation = state.evaluations.find((entry) => entry.id === failure?.evaluationId
+    && entry.digest === failure?.evaluationDigest);
+  if (!failure || !revocation || !predecessor || !candidate
+    || !trialFailureRevocationMatchesState(state, revocation)
+    || predecessor.id !== failure.learningId || predecessor.status !== "rolled-back"
+    || candidate.id !== contract.learningId
+    || predecessor.kind !== candidate.kind || predecessor.claim !== candidate.claim
+    || predecessor.subjectId !== candidate.subjectId || predecessor.privacy !== candidate.privacy
+    || predecessor.groupId !== candidate.groupId || !exactScope(predecessor.scope, candidate.scope)
+    || retry.targetDigest !== learningTargetForCandidate(candidate).digest
+    || retry.scopeDigest !== digest(candidate.scope)
+    || retry.minimumEvidenceObservedAt !== revocation.revokedAt
+    || new Date(candidate.createdAt).getTime() <= new Date(revocation.revokedAt).getTime()) return false;
+  if (COMPARABLE_TRIAL_RETRY_EVALUATIONS.has(contract.schema)
+    && (!predecessorEvaluation
+      || !["agentspine.learning-trial-retry/v2", "agentspine.learning-trial-retry/v3"].includes(retry.schema)
+      || retry.predecessorEvaluationId !== predecessorEvaluation.id
+      || retry.predecessorEvaluationDigest !== predecessorEvaluation.digest
+      || retry.comparisonDigest !== trialComparisonDigest(predecessorEvaluation, predecessor.promotion)
+      || retry.comparisonDigest !== trialComparisonDigest(contract))) return false;
+  if (BOUNDED_TRIAL_RETRY_EVALUATIONS.has(contract.schema)
+    && (retry.schema !== "agentspine.learning-trial-retry/v3"
+      || TRIAL_RETRY_EVALUATIONS.has(predecessorEvaluation?.schema)
+      || retry.rootEvaluationId !== predecessorEvaluation.id
+      || retry.rootEvaluationDigest !== predecessorEvaluation.digest
+      || retry.attempt !== 2 || retry.maxAttempts !== 2)) return false;
+  const predecessorEvidence = new Set(predecessor.evidence.map(evidenceIdentity));
+  const candidateEvidence = candidate.evidence.map(evidenceIdentity);
+  return candidate.evidence.length >= Math.max(2,
+    contract.thresholds?.minEvidence ?? state.config.minEvidence)
+    && new Set(candidateEvidence).size === candidateEvidence.length
+    && candidate.evidence.every((entry) =>
+    new Date(entry.observedAt).getTime() > new Date(revocation.revokedAt).getTime()
+      && !predecessorEvidence.has(evidenceIdentity(entry)));
+}
+
+export function trialRetryExhaustionPayload({ id, learningId, rootEvaluationId, rootEvaluationDigest,
+  correctiveEvaluationId, correctiveEvaluationDigest, trialFailureId, trialFailureDigest,
+  targetDigest, scopeDigest, attempt, maxAttempts, exhaustedAt }) {
+  return {
+    schema: "agentspine.learning-trial-retry-exhaustion/v1",
+    id,
+    learningId,
+    rootEvaluationId,
+    rootEvaluationDigest,
+    correctiveEvaluationId,
+    correctiveEvaluationDigest,
+    trialFailureId,
+    trialFailureDigest,
+    targetDigest,
+    scopeDigest,
+    attempt,
+    maxAttempts,
+    exhaustedAt,
+    terminalPolicy: "no-further-retry",
+    authority: "context-only"
+  };
+}
+
+export function storedTrialRetryExhaustionStructure(receipt) {
+  if (!receipt || typeof receipt !== "object" || Array.isArray(receipt)) return false;
+  const payload = trialRetryExhaustionPayload(receipt);
+  return receipt.schema === "agentspine.learning-trial-retry-exhaustion/v1"
+    && Object.keys(receipt).length === 17
+    && Object.keys(receipt).every((field) => ["schema", "id", "learningId", "rootEvaluationId",
+      "rootEvaluationDigest", "correctiveEvaluationId", "correctiveEvaluationDigest",
+      "trialFailureId", "trialFailureDigest", "targetDigest", "scopeDigest", "attempt",
+      "maxAttempts", "exhaustedAt", "terminalPolicy", "authority", "digest"].includes(field))
+    && [receipt.id, receipt.learningId, receipt.rootEvaluationId, receipt.correctiveEvaluationId,
+      receipt.trialFailureId].every((value) => ID_RE.test(value || ""))
+    && [receipt.rootEvaluationDigest, receipt.correctiveEvaluationDigest, receipt.trialFailureDigest,
+      receipt.targetDigest, receipt.scopeDigest].every((value) => DIGEST_RE.test(value || ""))
+    && receipt.attempt === 2 && receipt.maxAttempts === 2
+    && Number.isFinite(new Date(receipt.exhaustedAt).getTime())
+    && receipt.terminalPolicy === "no-further-retry"
+    && receipt.authority === "context-only" && receipt.digest === digest(payload);
+}
+
+export function trialRetryExhaustionMatchesState(state, receipt) {
+  const correctiveEvaluation = state.evaluations.find((entry) =>
+    entry.id === receipt.correctiveEvaluationId && entry.digest === receipt.correctiveEvaluationDigest
+      && entry.learningId === receipt.learningId);
+  const rootEvaluation = state.evaluations.find((entry) =>
+    entry.id === receipt.rootEvaluationId && entry.digest === receipt.rootEvaluationDigest);
+  const failure = state.trialFailures.find((entry) => entry.id === receipt.trialFailureId
+    && entry.digest === receipt.trialFailureDigest && entry.learningId === receipt.learningId);
+  const retry = correctiveEvaluation?.retry;
+  return Boolean(correctiveEvaluation && BOUNDED_TRIAL_RETRY_EVALUATIONS.has(correctiveEvaluation.schema)
+    && rootEvaluation && failure && trialFailureMatchesState(state, failure)
+    && failure.evaluationId === correctiveEvaluation.id
+    && failure.evaluationDigest === correctiveEvaluation.digest
+    && retry?.schema === "agentspine.learning-trial-retry/v3"
+    && retry.rootEvaluationId === rootEvaluation.id && retry.rootEvaluationDigest === rootEvaluation.digest
+    && retry.targetDigest === receipt.targetDigest && correctiveEvaluation.target.digest === receipt.targetDigest
+    && retry.scopeDigest === receipt.scopeDigest && digest(correctiveEvaluation.scope) === receipt.scopeDigest
+    && retry.attempt === receipt.attempt && retry.maxAttempts === receipt.maxAttempts
+    && failure.observedAt === receipt.exhaustedAt);
+}
+
+export function revalidationAdmissionWindow(state, receipt) {
+  const admission = receipt.revalidationAdmission;
+  const candidates = [
+    ...state.candidates,
+    ...state.history.filter((entry) => entry.kind === "learning-candidate").map((entry) => entry.value)
+  ];
+  return candidates.find((candidate) => candidate?.id === receipt.learningId
+    && candidate.promotion?.canary?.revalidation?.id === admission?.revalidationWindowId
+    && candidate.promotion.canary.revalidation.digest === admission?.revalidationWindowDigest)
+    ?.promotion?.canary?.revalidation || null;
+}
+
+export function revalidationAdmissionsMatchState(state) {
+  const admitted = state.applications.filter((receipt) => ["agentspine.learning-application/v3",
+    "agentspine.learning-application/v4"].includes(receipt.schema));
+  const groups = new Map();
+  for (const receipt of admitted) {
+    const window = revalidationAdmissionWindow(state, receipt);
+    const admission = receipt.revalidationAdmission;
+    const expectedWindowSchema = receipt.schema === "agentspine.learning-application/v4"
+      ? "agentspine.learning-revalidation-window/v4" : "agentspine.learning-revalidation-window/v3";
+    const expectedMode = receipt.schema === "agentspine.learning-application/v4"
+      ? "first-admitted-trials" : "first-admitted-turns";
+    const frozen = window?.selection?.evaluatorRoots?.[admission.slot - 1];
+    if (!window || window.schema !== expectedWindowSchema
+      || window.selection.mode !== expectedMode
+      || admission.slot > window.selection.requiredDeliveries
+      || admission.evaluatorRootDigest !== frozen?.evaluatorRootDigest
+      || (receipt.schema === "agentspine.learning-application/v4"
+        && (admission.evaluatorId !== frozen.evaluatorId || admission.runId !== frozen.runId
+          || admission.trialDigest !== frozen.trialDigest))
+      || new Date(receipt.projectedAt).getTime() < new Date(window.startedAt).getTime()
+      || new Date(receipt.projectedAt).getTime() > new Date(window.expiresAt).getTime()) return false;
+    const key = `${window.id}\0${window.digest}`;
+    if (!groups.has(key)) groups.set(key, []);
+    groups.get(key).push(receipt);
+  }
+  return [...groups.values()].every((receipts) => {
+    const ordered = [...receipts].sort((a, b) => a.revalidationAdmission.slot - b.revalidationAdmission.slot);
+    return new Set(ordered.map((receipt) => receipt.revalidationAdmission.slot)).size === ordered.length
+      && ordered.every((receipt, index) => receipt.revalidationAdmission.slot === index + 1);
+  });
+}