blun-king-cli 9.1.562 → 9.1.564

package/agent-spine-plugin/src/cli.js

@@ -8,9 +8,12 @@ import {
   recordActivity, resolveAttention, upsertAttention
 } from "./lib/attention.js";
 import {
-  addLearningEvidence, configureLearning, deleteLearning, evaluateLearning,
+  addLearningEvidence, beginLearningRevalidation, configureLearning, deleteLearning, evaluateLearning,
   learningContext, learningOutcomeStatus, loadLearning, proposeLearning,
-  recordLearningOutcome, reviewLearning, rollbackLearning
+  purgeStaleLearningApplications, purgeStaleLearningMeasurements, recordLearningMeasurement,
+  recordLearningOutcome, registerLearningEvaluation, registerLearningEvaluator, renewLearningValidation, revokeLearningEvaluator,
+  reviewLearning, revokeLearningApplication, revokeLearningDelivery, revokeLearningEvaluation, revokeLearningEvidence, revokeLearningMeasurement, revokeLearningOutcome, revokeLearningTrialFailure, revokeLearningValidation,
+  rollbackLearning
 } from "./lib/learning.js";
 import { configureContinuity, loadContinuity, purgeContinuity } from "./lib/continuity.js";
 import {
@@ -109,6 +112,14 @@ function hasLearningScope(flags) {
   return ["persona", "user", "tenant", "project", "group", "task"].some((name) => flags[name] !== undefined);
 }
 
+function evaluatorRootsFlag(value) {
+  return String(value || "").split(",").filter(Boolean).map((entry) => {
+    const separator = entry.lastIndexOf("=");
+    if (separator <= 0) throw new Error("evaluator roots must use evaluator-id=sha256 entries");
+    return { evaluatorId: entry.slice(0, separator), principalDigest: entry.slice(separator + 1) };
+  });
+}
+
 function help() {
   return `AgentSpine ${VERSION}
 
@@ -134,11 +145,27 @@ Usage:
   agentspine attention-config [root] [--enabled true|false] [--quiet-start 22 --quiet-end 7 --utc-offset 120]
   agentspine learn-propose [id] --kind preference|behavior --claim text --evidence text [--persona id --user id --tenant id --project id --group id --task id]
   agentspine learn-evidence <id> --summary text [--type interaction] [--source path.md]
+  agentspine learn-evidence-revoke <learning-id> --evidence-id id --reason-code retracted|source-invalid|measurement-invalid|duplicate|other --reason text --confirm-local-evidence
   agentspine learn-review <id> --decision accept|reject --reason text [--confirmed-by-user]
   agentspine learn-context [root] [--group id] [--include-private] [--kind preference,goal]
   agentspine learn-evaluate [root]
-  agentspine learn-outcome <id> --phase before|after --metric name --direction higher|lower --value 0..1 --evaluator id --measurement objective|user-feedback|model-suggestion [--blocking-defects n]
+  agentspine learn-evaluator-register <id> --principal-digest sha256 --confirm-local-evaluator
+  agentspine learn-evaluator-revoke <id> --reason text --confirm-local-evaluator
+  agentspine learn-evaluation <id> --learning id --metric name --direction higher|lower --task-digest sha256 --dataset-digest sha256 --protocol-digest sha256 --min-cases n --evaluators id,id --evaluator-roots id=sha256,id=sha256 [--expires-at date] [--retry-trial-failure id --confirm-local-trial-retry] --confirm-local-evaluation
+  agentspine learn-evaluation-revoke <evaluation-id> --reason-code benchmark-invalid|protocol-invalid|scope-invalid|threshold-invalid|duplicate|other --reason text --confirm-local-evaluation-revocation
+  agentspine learn-validation-revoke <validation-lease-id> --reason-code decision-invalid|cohort-invalid|binding-invalid|scope-invalid|duplicate|other --reason text --confirm-local-validation-revocation
+  agentspine learn-trial-failure-revoke <trial-failure-id> --reason-code clock-invalid|host-invalid|receipt-invalid|scope-invalid|duplicate|other --reason text --confirm-local-trial-failure-revocation
+  agentspine learn-revalidation-start <learning-id> --confirm-local-validation
+  agentspine learn-revalidate <learning-id> --measurements id,id --applications id,id --deliveries id,id --confirm-local-validation
+  agentspine learn-measurement <id> --learning id --evaluation id --phase before|after --metric name --direction higher|lower --value 0..1 --measurement objective|user-feedback|model-suggestion --evaluator id --run id --source-digest sha256 --dataset-digest sha256 --case-count n --confirm-local-measurement
+  agentspine learn-measurement-revoke <measurement-id> --reason-code source-invalid|evaluator-invalid|protocol-invalid|duplicate|other --reason text --confirm-local-measurement-revocation
+  agentspine learn-application-revoke <application-id> --reason-code preflight-invalid|scope-invalid|projection-invalid|duplicate|other --reason text --confirm-local-application-revocation
+  agentspine learn-delivery-revoke <delivery-id> --reason-code host-invalid|session-invalid|hook-invalid|duplicate|other --reason text --confirm-local-delivery-revocation
+  agentspine learn-outcome-revoke <outcome-id> --reason-code binding-invalid|phase-invalid|scope-invalid|duplicate|other --reason text --confirm-local-outcome-revocation
+  agentspine learn-outcome <learning-id> --id id --evaluation id --measurement-receipt id [--application id --delivery id]
   agentspine learn-status [root] [--persona id --user id --tenant id --project id --group id --task id]
+  agentspine learn-delivery-purge [root] --confirm-local-purge
+  agentspine learn-measurement-purge [root] --confirm-local-purge
   agentspine learn-rollback <id> --reason text
   agentspine learn-delete <id>
   agentspine learn-config [root] [--auto-promote true|false] [--min-confidence 0.85] [--min-outcomes 2 --min-improvement 0.05 --canary-receipts 2 --canary-ttl-days 14]
@@ -429,6 +456,15 @@ export async function run(argv = process.argv.slice(2)) {
     }), json);
   }
 
+  if (command === "learn-evidence-revoke") {
+    return output(await revokeLearningEvidence({
+      root: flags.root || process.cwd(), learningId: positional[0], evidenceId: flags["evidence-id"],
+      reasonCode: flags["reason-code"], reason: flags.reason,
+      confirmation: booleanFlag(flags["confirm-local-evidence"])
+        ? "local-evidence-revocation-confirmed" : null
+    }), json);
+  }
+
   if (command === "learn-review") {
     return output(await reviewLearning({
       root: flags.root || process.cwd(), id: positional[0], decision: flags.decision,
@@ -451,11 +487,147 @@ export async function run(argv = process.argv.slice(2)) {
     return output(await evaluateLearning({ root: positional[0] || process.cwd() }), json);
   }
 
+  if (command === "learn-evaluator-register") {
+    return output(await registerLearningEvaluator({
+      root: flags.root || process.cwd(), id: positional[0], principalDigest: flags["principal-digest"],
+      confirmLocalEvaluator: booleanFlag(flags["confirm-local-evaluator"])
+    }), json);
+  }
+
+  if (command === "learn-evaluator-revoke") {
+    return output(await revokeLearningEvaluator({
+      root: flags.root || process.cwd(), id: positional[0], reason: flags.reason,
+      confirmLocalEvaluator: booleanFlag(flags["confirm-local-evaluator"])
+    }), json);
+  }
+
+  if (command === "learn-evaluation") {
+    return output(await registerLearningEvaluation({
+      root: flags.root || process.cwd(), id: positional[0], learningId: flags.learning,
+      scope: learningScope(flags), metric: { name: flags.metric, direction: flags.direction },
+      benchmark: {
+        taskDigest: flags["task-digest"], datasetDigest: flags["dataset-digest"],
+        protocolDigest: flags["protocol-digest"], minCases: Number(flags["min-cases"])
+      },
+      evaluatorIds: String(flags.evaluators || "").split(",").filter(Boolean),
+      evaluatorRoots: evaluatorRootsFlag(flags["evaluator-roots"]),
+      expiresAt: flags["expires-at"] || null,
+      retryTrialFailureId: flags["retry-trial-failure"] || null,
+      confirmLocalTrialRetry: booleanFlag(flags["confirm-local-trial-retry"]),
+      confirmLocalEvaluation: booleanFlag(flags["confirm-local-evaluation"])
+    }), json);
+  }
+
+  if (command === "learn-revalidation-start") {
+    return output(await beginLearningRevalidation({
+      root: flags.root || process.cwd(), learningId: positional[0],
+      confirmLocalValidation: booleanFlag(flags["confirm-local-validation"])
+    }), json);
+  }
+
+  if (command === "learn-revalidate") {
+    const measurements = String(flags.measurements || "").split(",").filter(Boolean);
+    const applications = String(flags.applications || "").split(",").filter(Boolean);
+    const deliveries = String(flags.deliveries || "").split(",").filter(Boolean);
+    if (!measurements.length || measurements.length !== applications.length || measurements.length !== deliveries.length) {
+      throw new Error("revalidation requires equally sized measurement, application, and delivery lists");
+    }
+    return output(await renewLearningValidation({
+      root: flags.root || process.cwd(), learningId: positional[0],
+      evidence: measurements.map((measurementId, index) => ({ measurementId,
+        applicationId: applications[index], deliveryId: deliveries[index] })),
+      confirmLocalValidation: booleanFlag(flags["confirm-local-validation"])
+    }), json);
+  }
+
+  if (command === "learn-measurement") {
+    return output(await recordLearningMeasurement({
+      root: flags.root || process.cwd(), id: positional[0], learningId: flags.learning,
+      evaluationId: flags.evaluation, phase: flags.phase, scope: learningScope(flags),
+      metric: {
+        name: flags.metric, direction: flags.direction, value: Number(flags.value),
+        blockingDefects: Number(flags["blocking-defects"] ?? 0)
+      },
+      measurement: {
+        kind: flags.measurement || "objective", evaluatorId: flags.evaluator,
+        runId: flags.run, sourceDigest: flags["source-digest"]
+      },
+      coverage: { datasetDigest: flags["dataset-digest"], caseCount: Number(flags["case-count"]) },
+      measuredAt: flags.at,
+      confirmLocalMeasurement: booleanFlag(flags["confirm-local-measurement"])
+    }), json);
+  }
+
+  if (command === "learn-measurement-revoke") {
+    return output(await revokeLearningMeasurement({
+      root: flags.root || process.cwd(), measurementId: positional[0], reasonCode: flags["reason-code"],
+      reason: flags.reason,
+      confirmation: booleanFlag(flags["confirm-local-measurement-revocation"])
+        ? "local-measurement-revocation-confirmed" : null
+    }), json);
+  }
+
+  if (command === "learn-evaluation-revoke") {
+    return output(await revokeLearningEvaluation({
+      root: flags.root || process.cwd(), evaluationId: positional[0], reasonCode: flags["reason-code"],
+      reason: flags.reason,
+      confirmation: booleanFlag(flags["confirm-local-evaluation-revocation"])
+        ? "local-evaluation-revocation-confirmed" : null
+    }), json);
+  }
+
+  if (command === "learn-validation-revoke") {
+    return output(await revokeLearningValidation({
+      root: flags.root || process.cwd(), validationLeaseId: positional[0], reasonCode: flags["reason-code"],
+      reason: flags.reason,
+      confirmation: booleanFlag(flags["confirm-local-validation-revocation"])
+        ? "local-validation-revocation-confirmed" : null
+    }), json);
+  }
+
+  if (command === "learn-trial-failure-revoke") {
+    return output(await revokeLearningTrialFailure({
+      root: flags.root || process.cwd(), trialFailureId: positional[0], reasonCode: flags["reason-code"],
+      reason: flags.reason,
+      confirmation: booleanFlag(flags["confirm-local-trial-failure-revocation"])
+        ? "local-trial-failure-revocation-confirmed" : null
+    }), json);
+  }
+
+  if (command === "learn-application-revoke") {
+    return output(await revokeLearningApplication({
+      root: flags.root || process.cwd(), applicationId: positional[0], reasonCode: flags["reason-code"],
+      reason: flags.reason,
+      confirmation: booleanFlag(flags["confirm-local-application-revocation"])
+        ? "local-application-revocation-confirmed" : null
+    }), json);
+  }
+
+  if (command === "learn-delivery-revoke") {
+    return output(await revokeLearningDelivery({
+      root: flags.root || process.cwd(), deliveryId: positional[0], reasonCode: flags["reason-code"],
+      reason: flags.reason,
+      confirmation: booleanFlag(flags["confirm-local-delivery-revocation"])
+        ? "local-delivery-revocation-confirmed" : null
+    }), json);
+  }
+
+  if (command === "learn-outcome-revoke") {
+    return output(await revokeLearningOutcome({
+      root: flags.root || process.cwd(), outcomeId: positional[0], reasonCode: flags["reason-code"],
+      reason: flags.reason,
+      confirmation: booleanFlag(flags["confirm-local-outcome-revocation"])
+        ? "local-outcome-revocation-confirmed" : null
+    }), json);
+  }
+
   if (command === "learn-outcome") {
+    const lineage = flags["measurement-receipt"] || null;
     return output(await recordLearningOutcome({
       root: flags.root || process.cwd(), learningId: positional[0], id: flags.id,
-      phase: flags.phase, scope: learningScope(flags),
-      metric: {
+      evaluationId: flags.evaluation, measurementReceiptId: lineage,
+      applicationId: flags.application || null, deliveryId: flags.delivery || null,
+      ...(lineage ? {} : { phase: flags.phase, scope: learningScope(flags), metric: {
         name: flags.metric, direction: flags.direction, value: Number(flags.value),
         blockingDefects: Number(flags["blocking-defects"] ?? 0)
       },
@@ -463,7 +635,11 @@ export async function run(argv = process.argv.slice(2)) {
         kind: flags.measurement || "objective", evaluatorId: flags.evaluator,
         sourceDigest: flags["source-digest"] || null
       },
-      measuredAt: flags.at
+      coverage: {
+        datasetDigest: flags["dataset-digest"],
+        caseCount: Number(flags["case-count"])
+      },
+      measuredAt: flags.at })
     }), json);
   }
 
@@ -473,6 +649,20 @@ export async function run(argv = process.argv.slice(2)) {
     }), json);
   }
 
+  if (command === "learn-delivery-purge") {
+    return output(await purgeStaleLearningApplications({
+      root: positional[0] || process.cwd(),
+      confirmation: booleanFlag(flags["confirm-local-purge"]) ? "local-user-purge-confirmed" : null
+    }), json);
+  }
+
+  if (command === "learn-measurement-purge") {
+    return output(await purgeStaleLearningMeasurements({
+      root: positional[0] || process.cwd(),
+      confirmation: booleanFlag(flags["confirm-local-purge"]) ? "local-user-purge-confirmed" : null
+    }), json);
+  }
+
   if (command === "learn-rollback") {
     return output(await rollbackLearning({
       root: flags.root || process.cwd(), id: positional[0], reason: flags.reason
@@ -496,6 +686,9 @@ export async function run(argv = process.argv.slice(2)) {
     if (flags["outcome-max-age-days"] !== undefined) config.outcomeMaxAgeDays = Number(flags["outcome-max-age-days"]);
     if (flags["canary-receipts"] !== undefined) config.canaryReceipts = Number(flags["canary-receipts"]);
     if (flags["canary-ttl-days"] !== undefined) config.canaryTtlDays = Number(flags["canary-ttl-days"]);
+    if (flags["initial-trial-outcome-timeout-minutes"] !== undefined) {
+      config.initialTrialOutcomeTimeoutMinutes = Number(flags["initial-trial-outcome-timeout-minutes"]);
+    }
     if (!Object.keys(config).length) return output((await loadLearning(root)).learning.config, json);
     return output(await configureLearning({ root, config }), json);
   }
@@ -1005,12 +1198,202 @@ export async function run(argv = process.argv.slice(2)) {
     let learningOutcomes;
     try {
       const status = await learningOutcomeStatus({ root: positional[0] || process.cwd() });
+      const unboundAfterReceipts = status.records.reduce((sum, item) => sum + item.afterReceipts - item.boundAfterReceipts, 0);
+      const undeliveredAfterReceipts = status.records.reduce((sum, item) => sum + item.afterReceipts - item.deliveredAfterReceipts, 0);
+      const stalePendingApplications = status.records.reduce((sum, item) => sum + item.stalePendingApplications, 0);
+      const totalOutcomeReceipts = status.records.reduce((sum, item) => sum + item.beforeReceipts + item.afterReceipts, 0);
+      const plannedOutcomeReceipts = status.records.reduce((sum, item) => sum + item.plannedOutcomeReceipts, 0);
+      const coverageBoundReceipts = status.records.reduce((sum, item) => sum + item.coverageBoundReceipts, 0);
+      const legacyCoverageReceipts = status.records.reduce((sum, item) => sum + item.legacyCoverageReceipts, 0);
+      const provenanceBoundReceipts = status.records.reduce((sum, item) => sum + item.provenanceBoundReceipts, 0);
+      const legacyProvenanceReceipts = status.records.reduce((sum, item) => sum + item.legacyProvenanceReceipts, 0);
+      const measurementReceipts = status.records.reduce((sum, item) => sum + item.measurementReceipts, 0);
+      const measurementLineageReceipts = status.records.reduce((sum, item) => sum + item.measurementLineageReceipts, 0);
+      const consumedMeasurementReceipts = status.records.reduce((sum, item) => sum + item.consumedMeasurementReceipts, 0);
+      const staleUnconsumedMeasurements = status.records.reduce((sum, item) => sum + item.staleUnconsumedMeasurements, 0);
+      const lineageBoundReceipts = status.records.reduce((sum, item) => sum + item.lineageBoundReceipts, 0);
+      const pairedOutcomeReceipts = status.records.reduce((sum, item) => sum + item.pairedOutcomeReceipts, 0);
+      const pairedEvaluatorPairs = status.records.reduce((sum, item) => sum + item.pairedEvaluatorPairs, 0);
+      const evaluatorRootBoundReceipts = status.records.reduce((sum, item) => sum + item.evaluatorRootBoundReceipts, 0);
+      const independentEvaluatorRoots = status.records.reduce((sum, item) => sum + item.independentEvaluatorRoots, 0);
+      const evaluatorRegistryContracts = status.records.reduce((sum, item) => sum + item.evaluatorRegistryContracts, 0);
+      const inactiveEvaluatorRegistryContracts = status.records.reduce((sum, item) => sum + item.inactiveEvaluatorRegistryContracts, 0);
+      const currentValidatedLessons = status.records.filter((item) => item.validationLeaseStatus === "current-validated").length;
+      const staleValidatedLessons = status.records.filter((item) => item.validationLeaseStatus === "stale-validated").length;
+      const unprovenValidatedLessons = status.records.filter((item) => item.validationLeaseStatus === "unproven-validated").length;
+      const revokedValidatedLessons = status.records.filter((item) => item.validationLeaseStatus === "revoked-validated").length;
+      const renewedValidationLeases = status.records.filter((item) =>
+        ["agentspine.learning-validation/v2", "agentspine.learning-validation/v3",
+          "agentspine.learning-validation/v4", "agentspine.learning-validation/v5"].includes(item.validationLeaseSchema)).length;
+      const fixedCohortValidationLeases = status.records.filter((item) =>
+        ["agentspine.learning-validation/v3", "agentspine.learning-validation/v4",
+          "agentspine.learning-validation/v5"]
+          .includes(item.validationLeaseSchema)).length;
+      const admissionBoundValidationLeases = status.records.filter((item) =>
+        ["agentspine.learning-validation/v4", "agentspine.learning-validation/v5"]
+          .includes(item.validationLeaseSchema)).length;
+      const trialBoundValidationLeases = status.records.filter((item) =>
+        item.validationLeaseSchema === "agentspine.learning-validation/v5").length;
+      const activeRevalidations = status.records.filter((item) => item.revalidationStatus === "active").length;
+      const staleRevalidations = status.records.filter((item) => item.revalidationStatus === "stale").length;
+      const fixedCohortRevalidations = status.records.filter((item) =>
+        item.revalidationStatus === "active"
+          && ["first-completed-turns", "first-admitted-turns",
+            "first-admitted-trials"].includes(item.revalidationSelectionMode)).length;
+      const admissionBoundRevalidations = status.records.filter((item) =>
+        item.revalidationStatus === "active" && ["first-admitted-turns", "first-admitted-trials"]
+          .includes(item.revalidationSelectionMode)).length;
+      const trialBoundRevalidations = status.records.filter((item) =>
+        item.revalidationStatus === "active" && item.revalidationSelectionMode === "first-admitted-trials").length;
+      const requiredRevalidationDeliveries = status.records.reduce((sum, item) =>
+        sum + item.revalidationRequiredDeliveries, 0);
+      const completedRevalidationDeliveries = status.records.reduce((sum, item) =>
+        sum + item.revalidationCompletedDeliveries, 0);
+      const admittedRevalidationApplications = status.records.reduce((sum, item) =>
+        sum + item.revalidationAdmittedApplications, 0);
+      const initialTrialContracts = status.records.filter((item) => item.initialTrialMode === "first-admitted-trials").length;
+      const requiredInitialTrials = status.records.reduce((sum, item) => sum + item.initialTrialSlots, 0);
+      const admittedInitialApplications = status.records.reduce((sum, item) =>
+        sum + item.initialAdmittedApplications, 0);
+      const completedInitialDeliveries = status.records.reduce((sum, item) =>
+        sum + item.initialCompletedDeliveries, 0);
+      const incompleteInitialAdmissions = status.records.reduce((sum, item) =>
+        sum + item.incompleteInitialAdmissions, 0);
+      const targetBoundEvaluationContracts = status.records.reduce((sum, item) =>
+        sum + item.targetBoundEvaluationContracts, 0);
+      const targetBoundApplications = status.records.reduce((sum, item) =>
+        sum + item.targetBoundApplications, 0);
+      const deadlineBoundEvaluationContracts = status.records.reduce((sum, item) =>
+        sum + item.deadlineBoundEvaluationContracts, 0);
+      const stalenessBoundEvaluationContracts = status.records.reduce((sum, item) =>
+        sum + item.stalenessBoundEvaluationContracts, 0);
+      const promotionBoundEvaluationContracts = status.records.reduce((sum, item) =>
+        sum + item.promotionBoundEvaluationContracts, 0);
+      const candidateAdmissionEvaluationContracts = status.records.reduce((sum, item) =>
+        sum + item.candidateAdmissionEvaluationContracts, 0);
+      const candidateEvidenceCohortEvaluationContracts = status.records.reduce((sum, item) =>
+        sum + item.candidateEvidenceCohortEvaluationContracts, 0);
+      const blockingDefectBoundEvaluationContracts = status.records.reduce((sum, item) =>
+        sum + item.blockingDefectBoundEvaluationContracts, 0);
+      const evidenceSourceBoundEvaluationContracts = status.records.reduce((sum, item) =>
+        sum + item.evidenceSourceBoundEvaluationContracts, 0);
+      const blockingDefectOutcomeReceipts = status.records.reduce((sum, item) =>
+        sum + item.blockingDefectOutcomeReceipts, 0);
+      const deadlineBoundApplications = status.records.reduce((sum, item) =>
+        sum + item.deadlineBoundApplications, 0);
+      const trialRetryEvaluationContracts = status.records.reduce((sum, item) =>
+        sum + item.trialRetryEvaluationContracts, 0);
+      const comparableTrialRetryEvaluationContracts = status.records.reduce((sum, item) =>
+        sum + item.comparableTrialRetryEvaluationContracts, 0);
+      const boundedTrialRetryEvaluationContracts = status.records.reduce((sum, item) =>
+        sum + item.boundedTrialRetryEvaluationContracts, 0);
+      const trialRetryExhaustionReceipts = status.records.reduce((sum, item) =>
+        sum + item.trialRetryExhaustionReceipts, 0);
+      const trialFailureReceipts = status.records.reduce((sum, item) => sum + item.trialFailureReceipts, 0);
+      const trialFailureRevocationReceipts = status.records.reduce((sum, item) =>
+        sum + item.trialFailureRevocationReceipts, 0);
+      const evaluationRevocationReceipts = status.records.reduce((sum, item) => sum + item.evaluationRevocationReceipts, 0);
+      const validationRevocationReceipts = status.records.reduce((sum, item) => sum + item.validationRevocationReceipts, 0);
+      const evidenceRevocationReceipts = status.records.reduce((sum, item) => sum + item.evidenceRevocationReceipts, 0);
+      const measurementRevocationReceipts = status.records.reduce((sum, item) => sum + item.measurementRevocationReceipts, 0);
+      const applicationRevocationReceipts = status.records.reduce((sum, item) => sum + item.applicationRevocationReceipts, 0);
+      const deliveryRevocationReceipts = status.records.reduce((sum, item) => sum + item.deliveryRevocationReceipts, 0);
+      const outcomeRevocationReceipts = status.records.reduce((sum, item) => sum + item.outcomeRevocationReceipts, 0);
+      const deliveryTimeoutFailures = status.records.reduce((sum, item) => sum + item.deliveryTimeoutFailures, 0);
+      const outcomeTimeoutFailures = status.records.reduce((sum, item) => sum + item.outcomeTimeoutFailures, 0);
+      const pendingInitialOutcomes = status.records.reduce((sum, item) => sum + item.pendingInitialOutcomes, 0);
+      const staleInitialOutcomes = status.records.reduce((sum, item) => sum + item.staleInitialOutcomes, 0);
+      const unplannedOutcomeReceipts = totalOutcomeReceipts - plannedOutcomeReceipts;
       learningOutcomes = {
-        status: status.records.some((item) => item.canaryStatus === "stale") ? "degraded" : "healthy",
+        status: status.records.some((item) => ["stale", "revoked", "revoked-evaluation", "revoked-validation", "revoked-evidence", "revoked-measurement", "revoked-application", "revoked-delivery", "revoked-outcome", "unproven", "failed-trial"].includes(item.canaryStatus))
+          || unboundAfterReceipts > 0 || undeliveredAfterReceipts > 0 || unplannedOutcomeReceipts > 0
+          || stalePendingApplications > 0 || staleUnconsumedMeasurements > 0
+          || inactiveEvaluatorRegistryContracts > 0 || staleRevalidations > 0
+          || staleInitialOutcomes > 0 || trialFailureRevocationReceipts > 0 ? "degraded" : "healthy",
         candidates: status.records.length,
         activeCanaries: status.records.filter((item) => item.canaryStatus === "active").length,
         validatedCanaries: status.records.filter((item) => item.canaryStatus === "validated").length,
         staleCanaries: status.records.filter((item) => item.canaryStatus === "stale").length,
+        awaitingApplication: status.records.filter((item) => item.canaryStatus === "active" && item.applicationReceipts === 0).length,
+        applicationReceipts: status.records.reduce((sum, item) => sum + item.applicationReceipts, 0),
+        deliveryReceipts: status.records.reduce((sum, item) => sum + item.deliveryReceipts, 0),
+        pendingApplications: status.records.reduce((sum, item) => sum + item.pendingApplications, 0),
+        stalePendingApplications,
+        evaluationContracts: status.records.reduce((sum, item) => sum + item.evaluationContracts, 0),
+        targetBoundEvaluationContracts,
+        targetBoundApplications,
+        deadlineBoundEvaluationContracts,
+        stalenessBoundEvaluationContracts,
+        promotionBoundEvaluationContracts,
+        candidateAdmissionEvaluationContracts,
+        candidateEvidenceCohortEvaluationContracts,
+        blockingDefectBoundEvaluationContracts,
+        evidenceSourceBoundEvaluationContracts,
+        blockingDefectOutcomeReceipts,
+        deadlineBoundApplications,
+        trialRetryEvaluationContracts,
+        comparableTrialRetryEvaluationContracts,
+        boundedTrialRetryEvaluationContracts,
+        trialRetryExhaustionReceipts,
+        trialFailureReceipts,
+        trialFailureRevocationReceipts,
+        evaluationRevocationReceipts,
+        validationRevocationReceipts,
+        evidenceRevocationReceipts,
+        measurementRevocationReceipts,
+        applicationRevocationReceipts,
+        deliveryRevocationReceipts,
+        outcomeRevocationReceipts,
+        deliveryTimeoutFailures,
+        outcomeTimeoutFailures,
+        pendingInitialOutcomes,
+        staleInitialOutcomes,
+        plannedOutcomeReceipts,
+        coverageBoundReceipts,
+        legacyCoverageReceipts,
+        provenanceBoundReceipts,
+        legacyProvenanceReceipts,
+        measurementReceipts,
+        measurementLineageReceipts,
+        consumedMeasurementReceipts,
+        staleUnconsumedMeasurements,
+        lineageBoundReceipts,
+        pairedOutcomeReceipts,
+        pairedEvaluatorPairs,
+        evaluatorRootBoundReceipts,
+        independentEvaluatorRoots,
+        activeEvaluatorRoots: status.evaluatorRegistry.active,
+        revokedEvaluatorRoots: status.evaluatorRegistry.revoked,
+        evaluatorRegistryBindings: status.evaluatorRegistry.bindings,
+        validationLeases: status.evaluatorRegistry.validationLeases,
+        renewedValidationLeases,
+        fixedCohortValidationLeases,
+        admissionBoundValidationLeases,
+        trialBoundValidationLeases,
+        initialTrialContracts,
+        requiredInitialTrials,
+        admittedInitialApplications,
+        completedInitialDeliveries,
+        incompleteInitialAdmissions,
+        activeRevalidations,
+        staleRevalidations,
+        fixedCohortRevalidations,
+        admissionBoundRevalidations,
+        trialBoundRevalidations,
+        requiredRevalidationDeliveries,
+        admittedRevalidationApplications,
+        completedRevalidationDeliveries,
+        currentValidatedLessons,
+        staleValidatedLessons,
+        unprovenValidatedLessons,
+        revokedValidatedLessons,
+        evaluatorRegistryContracts,
+        inactiveEvaluatorRegistryContracts,
+        unplannedOutcomeReceipts,
+        boundAfterReceipts: status.records.reduce((sum, item) => sum + item.boundAfterReceipts, 0),
+        unboundAfterReceipts,
+        deliveredAfterReceipts: status.records.reduce((sum, item) => sum + item.deliveredAfterReceipts, 0),
+        undeliveredAfterReceipts,
         contradictions: status.records.filter((item) => item.conflictsWith.length > 0).length,
         authority: "context-only"
       };