blun-king-cli 9.1.567 → 9.1.570

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

@@ -0,0 +1,285 @@
+import {
+  ID_RE, DIGEST_RE, STALENESS_BOUND_EVALUATIONS, EVIDENCE_SOURCE_ATTESTED_EVALUATIONS, EVIDENCE_SOURCE_ATTESTATION_REVOCATION_REASONS
+} from "./learning-schema.js";
+import {
+  digest, learningTargetForCandidate
+} from "./learning-scope-targets.js";
+
+export function measurementLineagePayload({ measurementReceiptId, learningId, evaluationId, sourceDigest, runDigest,
+  evaluatorRootDigest, rootRunDigest, registeredAt,
+  schema = "agentspine.learning-measurement-lineage/v1" }) {
+  return {
+    schema, measurementReceiptId, learningId, evaluationId,
+    sourceDigest, runDigest,
+    ...(schema === "agentspine.learning-measurement-lineage/v2" ? { evaluatorRootDigest, rootRunDigest } : {}),
+    registeredAt, authority: "context-only"
+  };
+}
+
+export function storedMeasurementLineageStructure(receipt) {
+  if (!receipt || typeof receipt !== "object" || Array.isArray(receipt)) return false;
+  const payload = measurementLineagePayload(receipt);
+  return ["agentspine.learning-measurement-lineage/v1", "agentspine.learning-measurement-lineage/v2"].includes(receipt.schema)
+    && ID_RE.test(receipt.measurementReceiptId || "") && ID_RE.test(receipt.learningId || "")
+    && ID_RE.test(receipt.evaluationId || "") && DIGEST_RE.test(receipt.sourceDigest || "")
+    && DIGEST_RE.test(receipt.runDigest || "") && Number.isFinite(new Date(receipt.registeredAt).getTime())
+    && (receipt.schema !== "agentspine.learning-measurement-lineage/v2"
+      || (DIGEST_RE.test(receipt.evaluatorRootDigest || "") && DIGEST_RE.test(receipt.rootRunDigest || "")))
+    && receipt.authority === "context-only" && receipt.digest === digest(payload);
+}
+
+export function initialTrialPayload({ evaluationId, learningId, scope, metric, benchmark, phase, slot,
+  evaluatorId, evaluatorRootDigest, runId, caseCount }) {
+  return {
+    schema: "agentspine.learning-initial-trial/v1",
+    evaluationId,
+    learningId,
+    scopeDigest: digest(scope),
+    metricDigest: digest(metric),
+    benchmarkDigest: digest(benchmark),
+    phase,
+    slot,
+    evaluatorId,
+    evaluatorRootDigest,
+    runId,
+    caseCount,
+    authority: "context-only"
+  };
+}
+
+export function initialTrialDigest(input) {
+  return digest(initialTrialPayload(input));
+}
+
+export function storedInitialTrialPlanStructure(plan, contract) {
+  if (!plan || typeof plan !== "object" || Array.isArray(plan)
+    || plan.schema !== "agentspine.learning-initial-trials/v1"
+    || plan.mode !== "first-admitted-trials"
+    || !Number.isInteger(plan.requiredTrials) || plan.requiredTrials < 2 || plan.requiredTrials > 10
+    || plan.benchmarkDigest !== digest(contract.benchmark)
+    || plan.authority !== "context-only") return false;
+  const validPhase = (phase) => Array.isArray(plan[phase]) && plan[phase].length === plan.requiredTrials
+    && plan[phase].every((entry, index) => entry?.slot === index + 1
+      && ID_RE.test(entry?.evaluatorId || "") && DIGEST_RE.test(entry?.evaluatorRootDigest || "")
+      && ID_RE.test(entry?.runId || "") && Number.isInteger(entry?.caseCount)
+      && entry.caseCount === contract.benchmark.minCases && DIGEST_RE.test(entry?.trialDigest || "")
+      && entry.authority === "context-only"
+      && entry.trialDigest === initialTrialDigest({
+        evaluationId: contract.id, learningId: contract.learningId, scope: contract.scope,
+        metric: contract.metric, benchmark: contract.benchmark, phase, slot: entry.slot,
+        evaluatorId: entry.evaluatorId, evaluatorRootDigest: entry.evaluatorRootDigest,
+        runId: entry.runId, caseCount: entry.caseCount
+      }))
+    && new Set(plan[phase].map((entry) => entry.evaluatorId)).size === plan[phase].length
+    && new Set(plan[phase].map((entry) => entry.evaluatorRootDigest)).size === plan[phase].length
+    && new Set(plan[phase].map((entry) => entry.runId)).size === plan[phase].length;
+  return validPhase("before") && validPhase("after")
+    && plan.before.every((entry, index) => entry.evaluatorId === plan.after[index].evaluatorId
+      && entry.evaluatorRootDigest === plan.after[index].evaluatorRootDigest
+      && entry.runId !== plan.after[index].runId)
+    && plan.before.every((entry) => contract.evaluatorRoots.some((root) => root.evaluatorId === entry.evaluatorId
+      && root.principalDigest === entry.evaluatorRootDigest));
+}
+
+export function completionPolicyPayload({ deliveryTimeoutMs, outcomeTimeoutMs }) {
+  return {
+    schema: "agentspine.learning-completion-policy/v1",
+    deliveryTimeoutMs,
+    outcomeTimeoutMs,
+    missingDelivery: "blocking-defect",
+    missingOutcome: "blocking-defect",
+    authority: "context-only"
+  };
+}
+
+export function storedCompletionPolicyStructure(policy) {
+  if (!policy || typeof policy !== "object" || Array.isArray(policy)) return false;
+  const payload = completionPolicyPayload(policy);
+  return policy.schema === "agentspine.learning-completion-policy/v1"
+    && Number.isInteger(policy.deliveryTimeoutMs) && policy.deliveryTimeoutMs >= 60_000
+    && policy.deliveryTimeoutMs <= 15 * 60_000
+    && Number.isInteger(policy.outcomeTimeoutMs) && policy.outcomeTimeoutMs >= policy.deliveryTimeoutMs
+    && policy.outcomeTimeoutMs <= 7 * 86400000
+    && policy.missingDelivery === "blocking-defect" && policy.missingOutcome === "blocking-defect"
+    && policy.authority === "context-only" && policy.digest === digest(payload);
+}
+
+export function stalenessPolicyPayload({ outcomeMaxAgeDays, canaryTtlDays }) {
+  return {
+    schema: "agentspine.learning-staleness-policy/v1",
+    outcomeMaxAgeDays,
+    canaryTtlDays,
+    staleOutcome: "ineligible",
+    expiredCanary: "automatic-rollback",
+    authority: "context-only"
+  };
+}
+
+export function storedStalenessPolicyStructure(policy) {
+  if (!policy || typeof policy !== "object" || Array.isArray(policy)) return false;
+  const payload = stalenessPolicyPayload(policy);
+  return policy.schema === "agentspine.learning-staleness-policy/v1"
+    && Number.isInteger(policy.outcomeMaxAgeDays) && policy.outcomeMaxAgeDays >= 1
+    && policy.outcomeMaxAgeDays <= 365
+    && Number.isInteger(policy.canaryTtlDays) && policy.canaryTtlDays >= 1
+    && policy.canaryTtlDays <= 90
+    && policy.staleOutcome === "ineligible" && policy.expiredCanary === "automatic-rollback"
+    && policy.authority === "context-only" && policy.digest === digest(payload);
+}
+
+export function evaluationStalenessPolicy(contract, config) {
+  return STALENESS_BOUND_EVALUATIONS.has(contract?.schema)
+    ? contract.stalenessPolicy
+    : { outcomeMaxAgeDays: config.outcomeMaxAgeDays, canaryTtlDays: config.canaryTtlDays };
+}
+
+export function blockingDefectPolicyPayload() {
+  return {
+    schema: "agentspine.learning-blocking-defect-policy/v1",
+    phases: ["before", "after", "revalidation"],
+    aggregation: "any-defect-overrides-average",
+    beforeAction: "block-canary-admission",
+    afterAction: "automatic-rollback",
+    authority: "context-only"
+  };
+}
+
+export function storedBlockingDefectPolicyStructure(policy) {
+  if (!policy || typeof policy !== "object" || Array.isArray(policy)) return false;
+  const payload = blockingDefectPolicyPayload();
+  return Object.keys(policy).length === 7
+    && JSON.stringify(policy.phases) === JSON.stringify(payload.phases)
+    && policy.schema === payload.schema && policy.aggregation === payload.aggregation
+    && policy.beforeAction === payload.beforeAction && policy.afterAction === payload.afterAction
+    && policy.authority === "context-only" && policy.digest === digest(payload);
+}
+
+export function evidenceSourcePolicyPayload(schema = "agentspine.learning-evidence-source-policy/v1") {
+  return {
+    schema,
+    qualifyingTypes: ["user-statement", "test"],
+    minimumQualifyingEvidence: 1,
+    documentOnly: "insufficient",
+    interactionOnly: "insufficient",
+    ...(schema === "agentspine.learning-evidence-source-policy/v2"
+      ? { qualifyingEvidence: "explicit-local-attestation-required" } : {}),
+    insufficientCohort: "reject-before-evaluation",
+    authority: "context-only"
+  };
+}
+
+export function storedEvidenceSourcePolicyStructure(policy) {
+  if (!policy || typeof policy !== "object" || Array.isArray(policy)) return false;
+  const payload = evidenceSourcePolicyPayload(policy.schema);
+  const attested = policy.schema === "agentspine.learning-evidence-source-policy/v2";
+  return ["agentspine.learning-evidence-source-policy/v1",
+    "agentspine.learning-evidence-source-policy/v2"].includes(policy.schema)
+    && Object.keys(policy).length === (attested ? 9 : 8)
+    && JSON.stringify(policy.qualifyingTypes) === JSON.stringify(payload.qualifyingTypes)
+    && policy.minimumQualifyingEvidence === payload.minimumQualifyingEvidence
+    && policy.documentOnly === payload.documentOnly && policy.interactionOnly === payload.interactionOnly
+    && (!attested || policy.qualifyingEvidence === payload.qualifyingEvidence)
+    && policy.insufficientCohort === payload.insufficientCohort
+    && policy.authority === "context-only" && policy.digest === digest(payload);
+}
+
+export function qualifyingEvidenceCount(cohort, policy, attestations = []) {
+  if (policy.schema === "agentspine.learning-evidence-source-policy/v2") {
+    return new Set(attestations.map((entry) => entry.independenceDigest)).size;
+  }
+  return new Set(cohort.filter((entry) => policy.qualifyingTypes.includes(entry.type))
+    .map((entry) => entry.independenceDigest)).size;
+}
+
+export function evidenceSourceAttestations(cohort, confirmedAt) {
+  return cohort.filter((entry) => ["user-statement", "test"].includes(entry.type)).map((entry) => ({
+    schema: "agentspine.learning-evidence-source-attestation/v1",
+    evidenceDigest: entry.evidenceDigest,
+    independenceDigest: entry.independenceDigest,
+    sourceClass: entry.type === "test" ? "objective-test" : "explicit-user-feedback",
+    confirmedAt,
+    authority: "context-only"
+  })).sort((left, right) => left.evidenceDigest.localeCompare(right.evidenceDigest));
+}
+
+export function storedEvidenceSourceAttestationsStructure(attestations, cohort, confirmedAt) {
+  const expected = evidenceSourceAttestations(cohort, confirmedAt);
+  return Array.isArray(attestations) && attestations.length >= 1
+    && attestations.every((entry) => entry && typeof entry === "object" && !Array.isArray(entry)
+      && Object.keys(entry).length === 6
+      && entry.schema === "agentspine.learning-evidence-source-attestation/v1"
+      && DIGEST_RE.test(entry.evidenceDigest || "") && DIGEST_RE.test(entry.independenceDigest || "")
+      && ["explicit-user-feedback", "objective-test"].includes(entry.sourceClass)
+      && entry.confirmedAt === confirmedAt && entry.authority === "context-only")
+    && digest(attestations) === digest(expected);
+}
+
+export function evidenceSourceAttestationRevocationPayload({ id, learningId, evaluationId, evaluationDigest,
+  candidateAdmissionDigest, evidenceDigest, independenceDigest, sourceClass, targetDigest, scopeDigest,
+  reasonCode, reasonDigest, revokedAt }) {
+  return {
+    schema: "agentspine.learning-evidence-source-attestation-revocation/v1",
+    id,
+    learningId,
+    evaluationId,
+    evaluationDigest,
+    candidateAdmissionDigest,
+    evidenceDigest,
+    independenceDigest,
+    sourceClass,
+    targetDigest,
+    scopeDigest,
+    reasonCode,
+    reasonDigest,
+    revokedAt,
+    authority: "context-only"
+  };
+}
+
+export function storedEvidenceSourceAttestationRevocationStructure(receipt) {
+  if (!receipt || typeof receipt !== "object" || Array.isArray(receipt)) return false;
+  const payload = evidenceSourceAttestationRevocationPayload(receipt);
+  return receipt.schema === "agentspine.learning-evidence-source-attestation-revocation/v1"
+    && Object.keys(receipt).length === 16
+    && Object.keys(receipt).every((field) => ["schema", "id", "learningId", "evaluationId",
+      "evaluationDigest", "candidateAdmissionDigest", "evidenceDigest", "independenceDigest",
+      "sourceClass", "targetDigest", "scopeDigest", "reasonCode", "reasonDigest", "revokedAt",
+      "authority", "digest"].includes(field))
+    && ID_RE.test(receipt.id || "") && ID_RE.test(receipt.learningId || "")
+    && ID_RE.test(receipt.evaluationId || "") && DIGEST_RE.test(receipt.evaluationDigest || "")
+    && DIGEST_RE.test(receipt.candidateAdmissionDigest || "") && DIGEST_RE.test(receipt.evidenceDigest || "")
+    && DIGEST_RE.test(receipt.independenceDigest || "")
+    && ["explicit-user-feedback", "objective-test"].includes(receipt.sourceClass)
+    && DIGEST_RE.test(receipt.targetDigest || "") && DIGEST_RE.test(receipt.scopeDigest || "")
+    && EVIDENCE_SOURCE_ATTESTATION_REVOCATION_REASONS.has(receipt.reasonCode)
+    && DIGEST_RE.test(receipt.reasonDigest || "") && Number.isFinite(new Date(receipt.revokedAt).getTime())
+    && receipt.authority === "context-only" && receipt.digest === digest(payload);
+}
+
+export function evidenceSourceAttestationRevocationMatchesState(state, receipt) {
+  const candidate = state.candidates.find((entry) => entry.id === receipt.learningId);
+  const evaluation = state.evaluations.find((entry) => entry.id === receipt.evaluationId
+    && entry.learningId === receipt.learningId && entry.digest === receipt.evaluationDigest);
+  const attestation = evaluation?.candidateAdmission?.evidenceSourceAttestations?.find((entry) =>
+    entry.evidenceDigest === receipt.evidenceDigest && entry.independenceDigest === receipt.independenceDigest
+    && entry.sourceClass === receipt.sourceClass);
+  return Boolean(candidate && evaluation && EVIDENCE_SOURCE_ATTESTED_EVALUATIONS.has(evaluation.schema)
+    && evaluation.candidateAdmission.digest === receipt.candidateAdmissionDigest
+    && attestation && learningTargetForCandidate(candidate).digest === receipt.targetDigest
+    && digest(evaluation.scope) === receipt.scopeDigest);
+}
+
+export function revokedEvidenceSourceAttestation(state, evaluationId, evidenceDigest = null) {
+  return state.evidenceSourceAttestationRevocations.find((receipt) => receipt.evaluationId === evaluationId
+    && (evidenceDigest === null || receipt.evidenceDigest === evidenceDigest)) || null;
+}
+
+export function revokedEvidenceSourceAttestationForCandidate(state, candidate) {
+  const canary = candidate?.promotion?.mode === "outcome-canary" ? candidate.promotion.canary : null;
+  if (canary?.evaluationId) {
+    return state.evidenceSourceAttestationRevocations.find((receipt) => receipt.learningId === candidate.id
+      && receipt.evaluationId === canary.evaluationId && receipt.evaluationDigest === canary.evaluationDigest) || null;
+  }
+  return state.evidenceSourceAttestationRevocations.find((receipt) =>
+    receipt.learningId === candidate?.id) || null;
+}

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

@@ -0,0 +1,265 @@
+import { createHash, randomUUID } from "node:crypto";
+import {
+  OUTCOME_PHASES, MEASUREMENT_KINDS, ID_RE, DIGEST_RE, LINEAGE_EVALUATIONS, PAIRED_EVALUATIONS,
+  ROOT_BOUND_EVALUATIONS, REGISTRY_BOUND_EVALUATIONS, INITIAL_TRIAL_EVALUATIONS, TARGET_BOUND_EVALUATIONS, INITIAL_TRIAL_APPLICATIONS, TARGET_BOUND_APPLICATIONS,
+  DEADLINE_BOUND_APPLICATIONS, MEASUREMENT_REVOCATION_REASONS
+} from "./learning-schema.js";
+import {
+  normalizeScope, scopeContains, exactScope, digest, learningTargetForCandidate, measurementPayload,
+  measurementRevocationPayload, revokedMeasurement, measurementRunDigest, evaluatorRootRunDigest, activeEvaluationBinding, revokedEvaluation
+} from "./learning-scope-targets.js";
+import {
+  revokedValidationForCandidate
+} from "./learning-validation-runtime.js";
+import {
+  measurementLineagePayload, revokedEvidenceSourceAttestation
+} from "./learning-measurement-contracts.js";
+import {
+  revokedApplication, revokedDelivery
+} from "./learning-delivery-contracts.js";
+import {
+  date, number, integer, safeText, mutation
+} from "./learning-storage.js";
+
+export async function recordLearningMeasurement({
+  root = process.cwd(), id = `measurement:${randomUUID()}`, learningId, evaluationId, phase, scope, metric,
+  measurement, coverage, measuredAt, confirmLocalMeasurement = false, now = new Date()
+}) {
+  if (!confirmLocalMeasurement) throw new Error("measurement registration requires explicit local confirmation");
+  if (!ID_RE.test(id || "") || !ID_RE.test(learningId || "") || !ID_RE.test(evaluationId || "")) {
+    throw new Error("measurement id, learningId and evaluationId must be stable identifiers");
+  }
+  const timestamp = date(now, "now");
+  return mutation(root, (state, _catalog, learningPath) => {
+    const candidate = state.candidates.find((entry) => entry.id === learningId);
+    const evaluation = state.evaluations.find((entry) => entry.id === evaluationId);
+    const existing = state.measurements.find((entry) => entry.id === id);
+    if (!candidate || !evaluation || !LINEAGE_EVALUATIONS.has(evaluation.schema)
+      || evaluation.learningId !== learningId) {
+      throw new Error("measurements require a matching lineage evaluation contract");
+    }
+    if (revokedEvaluation(state, evaluation.id)) {
+      throw new Error("learning evaluation contract was explicitly revoked and cannot accept measurements");
+    }
+    if (revokedEvidenceSourceAttestation(state, evaluation.id)) {
+      throw new Error("learning evidence source attestation was explicitly revoked and cannot support measurements");
+    }
+    if (REGISTRY_BOUND_EVALUATIONS.has(evaluation.schema)
+      && !activeEvaluationBinding(state, evaluation)) {
+      throw new Error("measurement evaluator registry binding is missing, changed, or revoked");
+    }
+    const normalizedScope = normalizeScope(scope);
+    if (!scopeContains(candidate.scope, normalizedScope) || !exactScope(evaluation.scope, normalizedScope)) {
+      throw new Error("measurement scope does not match the evaluation contract");
+    }
+    if (!OUTCOME_PHASES.has(phase)) throw new Error("measurement phase must be before or after");
+    if (phase === "before" && candidate.status !== "candidate") {
+      throw new Error("before measurements require an unreviewed candidate");
+    }
+    const activeRevalidation = candidate?.promotion?.canary?.status === "validated"
+      && candidate.promotion.canary.revalidation?.status === "active"
+      && new Date(candidate.promotion.canary.revalidation.expiresAt).getTime() >= new Date(timestamp).getTime();
+    if (activeRevalidation && revokedValidationForCandidate(state, candidate)) {
+      throw new Error("learning validation decision was explicitly revoked and cannot accept renewal measurements");
+    }
+    if (phase === "after" && (candidate.status !== "accepted" || candidate.promotion?.mode !== "outcome-canary"
+      || (!activeRevalidation && candidate.promotion?.canary?.status !== "active")
+      || candidate.promotion.canary.evaluationId !== evaluationId)) {
+      throw new Error("after measurements require the matching active outcome canary");
+    }
+    const name = safeText(metric?.name, "measurement.metric.name", 120);
+    const direction = metric?.direction;
+    if (name !== evaluation.metric.name || direction !== evaluation.metric.direction) {
+      throw new Error("measurement metric does not match the evaluation contract");
+    }
+    const normalizedMetric = {
+      name, direction,
+      value: number(metric?.value, "measurement.metric.value", 0, 1),
+      blockingDefects: integer(metric?.blockingDefects ?? 0, "measurement.metric.blockingDefects", 0, 1000)
+    };
+    const kind = measurement?.kind;
+    const evaluatorId = measurement?.evaluatorId;
+    const runId = measurement?.runId;
+    const sourceDigest = measurement?.sourceDigest;
+    if (!MEASUREMENT_KINDS.has(kind)) throw new Error("measurement kind is unsupported");
+    if (!ID_RE.test(evaluatorId || "") || !evaluation.evaluatorIds.includes(evaluatorId)) {
+      throw new Error("measurement evaluator is not allowed by the evaluation contract");
+    }
+    if (!ID_RE.test(runId || "")) throw new Error("measurement runId must be a stable identifier");
+    if (!DIGEST_RE.test(sourceDigest || "")) throw new Error("measurement sourceDigest must be a SHA-256 digest");
+    const evaluatorRoot = ROOT_BOUND_EVALUATIONS.has(evaluation.schema)
+      ? evaluation.evaluatorRoots.find((root) => root.evaluatorId === evaluatorId) : null;
+    if (ROOT_BOUND_EVALUATIONS.has(evaluation.schema) && !evaluatorRoot) {
+      throw new Error("measurement evaluator root is not frozen by the evaluation contract");
+    }
+    const normalizedMeasurement = {
+      kind, evaluatorId, runId, sourceDigest,
+      ...(evaluatorRoot ? { evaluatorRootDigest: evaluatorRoot.principalDigest } : {}),
+      authority: "context-only"
+    };
+    const normalizedCoverage = {
+      datasetDigest: coverage?.datasetDigest,
+      caseCount: integer(coverage?.caseCount, "measurement.coverage.caseCount", 1, 1000000),
+      authority: "context-only"
+    };
+    if (normalizedCoverage.datasetDigest !== evaluation.benchmark.datasetDigest) {
+      throw new Error("measurement coverage dataset does not match the evaluation contract");
+    }
+    if (normalizedCoverage.caseCount < evaluation.benchmark.minCases) {
+      throw new Error(`measurement coverage requires at least ${evaluation.benchmark.minCases} cases`);
+    }
+    const initialTrial = INITIAL_TRIAL_EVALUATIONS.has(evaluation.schema) && !activeRevalidation
+      ? evaluation.initialTrials?.[phase]?.find((entry) => entry.evaluatorId === evaluatorId) : null;
+    if (INITIAL_TRIAL_EVALUATIONS.has(evaluation.schema) && !activeRevalidation
+      && (!initialTrial || initialTrial.evaluatorRootDigest !== evaluatorRoot?.principalDigest
+        || initialTrial.runId !== runId || initialTrial.caseCount !== normalizedCoverage.caseCount)) {
+      throw new Error("measurement does not match the precommitted initial trial");
+    }
+    const observedAt = date(measuredAt || existing?.measuredAt || timestamp, "measurement.measuredAt");
+    if (new Date(observedAt).getTime() < new Date(evaluation.registeredAt).getTime()
+      || new Date(observedAt).getTime() > new Date(evaluation.expiresAt).getTime()
+      || (!existing && new Date(observedAt).getTime() > new Date(timestamp).getTime())) {
+      throw new Error("measurement is outside its evaluation contract window");
+    }
+    if (INITIAL_TRIAL_EVALUATIONS.has(evaluation.schema) && phase === "after" && !activeRevalidation) {
+      const application = state.applications.find((entry) => INITIAL_TRIAL_APPLICATIONS.has(entry.schema)
+        && entry.learningId === learningId && entry.initialAdmission.evaluationId === evaluation.id
+        && entry.initialAdmission.evaluationDigest === evaluation.digest
+        && entry.initialAdmission.slot === initialTrial.slot
+        && entry.initialAdmission.trialDigest === initialTrial.trialDigest
+        && (!TARGET_BOUND_EVALUATIONS.has(evaluation.schema)
+          || (TARGET_BOUND_APPLICATIONS.has(entry.schema)
+            && entry.initialAdmission.targetDigest === evaluation.target.digest)));
+      const delivery = application && state.deliveries.find((entry) => entry.applicationId === application.id);
+      if (!application || revokedApplication(state, application.id) || !delivery || revokedDelivery(state, delivery.id)
+        || new Date(observedAt).getTime() < new Date(delivery.completedAt).getTime()) {
+        throw new Error("after measurement requires the precommitted first-admitted trial and completed delivery");
+      }
+      if (DEADLINE_BOUND_APPLICATIONS.has(application.schema)
+        && (new Date(observedAt).getTime() > new Date(application.outcomeExpiresAt).getTime()
+          || (!existing && new Date(timestamp).getTime() > new Date(application.outcomeExpiresAt).getTime()))) {
+        throw new Error("after measurement missed its immutable initial trial outcome deadline");
+      }
+    }
+    if (phase === "after" && activeRevalidation) {
+      const application = state.applications.find((entry) => entry.schema === "agentspine.learning-application/v4"
+        && entry.learningId === learningId
+        && entry.revalidationAdmission.evaluatorId === evaluatorId
+        && entry.revalidationAdmission.evaluatorRootDigest === evaluatorRoot?.principalDigest
+        && entry.revalidationAdmission.runId === runId);
+      const delivery = application && state.deliveries.find((entry) => entry.applicationId === application.id);
+      if (!application || revokedApplication(state, application.id) || !delivery || revokedDelivery(state, delivery.id)
+        || new Date(observedAt).getTime() < new Date(delivery.completedAt).getTime()) {
+        throw new Error("revalidation measurement requires its precommitted admission slot and completed delivery");
+      }
+    }
+    const payload = measurementPayload({
+      schema: ROOT_BOUND_EVALUATIONS.has(evaluation.schema)
+        ? "agentspine.learning-measurement/v2" : "agentspine.learning-measurement/v1",
+      id, learningId, evaluationId, phase, scope: normalizedScope,
+      metric: normalizedMetric, measurement: normalizedMeasurement, coverage: normalizedCoverage, measuredAt: observedAt });
+    const receipt = { ...payload, digest: digest(payload) };
+    const lineagePayload = measurementLineagePayload({
+      schema: evaluatorRoot ? "agentspine.learning-measurement-lineage/v2" : "agentspine.learning-measurement-lineage/v1",
+      measurementReceiptId: id, learningId, evaluationId, sourceDigest,
+      runDigest: measurementRunDigest(evaluatorId, runId),
+      evaluatorRootDigest: evaluatorRoot?.principalDigest,
+      rootRunDigest: evaluatorRoot ? evaluatorRootRunDigest(evaluatorRoot.principalDigest, runId) : undefined,
+      registeredAt: observedAt
+    });
+    const lineage = { ...lineagePayload, digest: digest(lineagePayload) };
+    if (existing) {
+      const existingLineage = state.measurementLineage.find((entry) => entry.measurementReceiptId === id);
+      if (existing.digest === receipt.digest && existingLineage?.digest === lineage.digest) {
+        return { receipt: existing, lineage: existingLineage, learningPath, unchanged: true };
+      }
+      throw new Error("measurement receipt IDs are immutable");
+    }
+    if (PAIRED_EVALUATIONS.has(evaluation.schema) && phase === "after") {
+      const beforeReceiptIds = new Set(candidate.promotion?.canary?.beforeReceipts || []);
+      const pairedBefore = state.outcomes.find((entry) => beforeReceiptIds.has(entry.id)
+        && ["agentspine.learning-outcome/v8", "agentspine.learning-outcome/v9"].includes(entry.schema)
+        && entry.measurement.evaluatorId === evaluatorId
+        && (!evaluatorRoot || entry.measurement.evaluatorRootDigest === evaluatorRoot.principalDigest));
+      if (!pairedBefore) throw new Error("after measurement requires the same evaluator as a frozen before measurement");
+      if (pairedBefore.measurement.kind !== kind || pairedBefore.coverage.caseCount !== normalizedCoverage.caseCount) {
+        throw new Error("after measurement must match the frozen evaluator's measurement kind and case count");
+      }
+    }
+    if (state.measurementLineage.some((entry) => entry.measurementReceiptId === id)) {
+      throw new Error("measurement receipt IDs are retained as immutable replay tombstones");
+    }
+    if (state.measurementLineage.some((entry) => entry.sourceDigest === sourceDigest)) {
+      throw new Error("measurement source provenance cannot be reused across evaluation contracts");
+    }
+    if (state.measurementLineage.some((entry) => entry.runDigest === lineage.runDigest)) {
+      throw new Error("measurement evaluator run cannot be replayed");
+    }
+    if (lineage.schema === "agentspine.learning-measurement-lineage/v2"
+      && state.measurementLineage.some((entry) => entry.schema === "agentspine.learning-measurement-lineage/v2"
+        && entry.rootRunDigest === lineage.rootRunDigest)) {
+      throw new Error("measurement evaluator-root run cannot be replayed through an alias ID");
+    }
+    state.measurements.push(receipt);
+    state.measurements.sort((a, b) => a.id.localeCompare(b.id));
+    state.measurementLineage.push(lineage);
+    state.measurementLineage.sort((a, b) => a.measurementReceiptId.localeCompare(b.measurementReceiptId));
+    return { receipt, lineage, learningPath, unchanged: false };
+  });
+}
+
+export async function revokeLearningMeasurement({
+  root = process.cwd(), measurementId, reasonCode, reason, confirmation, now = new Date()
+}) {
+  if (confirmation !== "local-measurement-revocation-confirmed") {
+    throw new Error("measurement revocation requires explicit local confirmation");
+  }
+  if (!ID_RE.test(measurementId || "")) throw new Error("measurementId must be a stable identifier");
+  if (!MEASUREMENT_REVOCATION_REASONS.has(reasonCode)) {
+    throw new Error("reasonCode must be source-invalid, evaluator-invalid, protocol-invalid, duplicate, or other");
+  }
+  const revokeReason = safeText(reason, "reason", 500);
+  const timestamp = date(now, "now");
+  return mutation(root, (state, _catalog, learningPath) => {
+    const measurement = state.measurements.find((entry) => entry.id === measurementId);
+    if (!measurement) throw new Error(`unknown learning measurement: ${measurementId}`);
+    const candidate = state.candidates.find((entry) => entry.id === measurement.learningId);
+    const evaluation = state.evaluations.find((entry) => entry.id === measurement.evaluationId);
+    if (!candidate || !evaluation || evaluation.learningId !== candidate.id) {
+      throw new Error("measurement revocation requires its bound candidate and evaluation contract");
+    }
+    const outcome = state.outcomes.find((entry) => entry.measurementReceiptId === measurement.id) || null;
+    const targetDigest = learningTargetForCandidate(candidate).digest;
+    const reasonDigest = digest(revokeReason);
+    const existing = revokedMeasurement(state, measurementId);
+    if (existing) {
+      if (existing.reasonCode !== reasonCode || existing.reasonDigest !== reasonDigest
+        || existing.measurementDigest !== measurement.digest || existing.evaluationDigest !== evaluation.digest
+        || existing.targetDigest !== targetDigest || existing.outcomeId !== (outcome?.id || null)
+        || existing.outcomeDigest !== (outcome?.digest || null)) {
+        throw new Error("learning measurement revocations are immutable");
+      }
+      return { receipt: existing, learningPath, unchanged: true, authority: "context-only" };
+    }
+    const id = `measurement-revocation:${createHash("sha256")
+      .update(`${measurement.id}\0${measurement.digest}\0${targetDigest}`).digest("hex").slice(0, 32)}`;
+    const payload = measurementRevocationPayload({
+      id,
+      learningId: candidate.id,
+      evaluationId: evaluation.id,
+      evaluationDigest: evaluation.digest,
+      measurementId: measurement.id,
+      measurementDigest: measurement.digest,
+      outcomeId: outcome?.id || null,
+      outcomeDigest: outcome?.digest || null,
+      targetDigest,
+      reasonCode,
+      reasonDigest,
+      revokedAt: timestamp
+    });
+    const receipt = { ...payload, digest: digest(payload) };
+    state.measurementRevocations.push(receipt);
+    state.measurementRevocations.sort((a, b) => a.id.localeCompare(b.id));
+    return { receipt, learningPath, unchanged: false, authority: "context-only" };
+  });
+}