blun-king-cli 9.1.561 → 9.1.563

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"
       };

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

@@ -8,6 +8,7 @@ import { canonicalPath } from "./lib/paths.js";
 import { resolveHostSourceCatalog } from "./lib/source-roots.js";
 import { sessionBriefing } from "./lib/briefing.js";
 import { captureContinuityPrompt, loadContinuity } from "./lib/continuity.js";
+import { recordLearningApplications, recordLearningDeliveries } from "./lib/learning.js";
 import {
   authorizeJobEffect, checkpointJobEffect, closeJobLease, resolveSessionJob, startOrResumeJob
 } from "./lib/selfstarter.js";
@@ -26,15 +27,25 @@ const KNOWN_EVENTS = new Set([
 const ID_RE = /^[A-Za-z0-9][A-Za-z0-9:_.@/-]{0,127}$/;
 const ATTENTION_WRITE_EVENTS = new Set(["UserPromptSubmit", "PostToolUse", "Stop", "SubagentStop"]);
 const SELFSTART_EVENTS = new Set(["SessionStart", "PostCompact"]);
+const SILENT_OVERSIZE_POST_TOOL_USE = Symbol("silent-oversize-post-tool-use");
+const SILENT_OVERSIZE_POST_TOOL_USE_ARG = "--silent-oversize-post-tool-use";
 
-async function readStdin() {
-  let value = "";
+async function readStdin({ silentOversizePostToolUse = false } = {}) {
+  const chunks = [];
   let bytes = 0;
+  let oversized = false;
   for await (const chunk of process.stdin) {
-    bytes += Buffer.byteLength(chunk);
-    if (bytes > MAX_STDIN_BYTES) throw new Error("hook input exceeds the 64 KiB limit");
-    value += chunk;
+    const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+    const remaining = Math.max(0, MAX_STDIN_BYTES - bytes);
+    if (remaining) chunks.push(buffer.subarray(0, remaining));
+    bytes += buffer.length;
+    if (bytes > MAX_STDIN_BYTES) oversized = true;
   }
+  if (oversized) {
+    if (silentOversizePostToolUse) return SILENT_OVERSIZE_POST_TOOL_USE;
+    throw new Error("hook input exceeds the 64 KiB limit");
+  }
+  const value = Buffer.concat(chunks, bytes).toString("utf8");
   const parsed = value.trim() ? JSON.parse(value) : {};
   if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) throw new Error("hook input must be one JSON object");
   return parsed;
@@ -196,6 +207,7 @@ function renderContext(event, catalog, briefing, signal = null, attentionEvent =
       createdAt: preflight.receipt.createdAt,
       expiresAt: preflight.receipt.expiresAt,
       policy: preflight.policy,
+      learningApplications: preflight.learningApplications || null,
       pendingMustRemember: preflight.pendingMustRemember ? {
         id: preflight.pendingMustRemember.candidate?.id || null,
         status: preflight.pendingMustRemember.candidate?.status || (preflight.pendingMustRemember.rejected ? "rejected" : null),
@@ -501,8 +513,9 @@ function blockPrompt(reason) {
   })}\n`);
 }
 
-export async function runHook(payload = null) {
-  const input = payload || await readStdin();
+export async function runHook(payload = null, options = {}) {
+  const input = payload || await readStdin(options);
+  if (input === SILENT_OVERSIZE_POST_TOOL_USE) return;
   if (!input || typeof input !== "object" || Array.isArray(input)) throw new Error("hook input must be one JSON object");
   const event = input.hook_event_name || input.event_name || "";
   if (!KNOWN_EVENTS.has(event)) throw new Error(`unsupported hook event: ${event || "missing"}`);
@@ -560,6 +573,7 @@ export async function runHook(payload = null) {
   let scope = null;
   let selfstarter = null;
   let channelEvent = null;
+  let learningDelivery = null;
 
   if (event === "PreToolUse" && isMutationTool(input.tool_name)) {
     const { graph } = await loadGraph(root, catalog);
@@ -637,6 +651,19 @@ export async function runHook(payload = null) {
   if (["Stop", "SubagentStop"].includes(event)) {
     scope ||= await runtimeScope(input, root, resolvedSources.userStateRoot, catalog);
     const exact = await selfstarterScope(input, scope, root, "resume");
+    if (exact && !scope.currentTaskId) scope.currentTaskId = exact.taskId;
+    try {
+      learningDelivery = await recordLearningDeliveries({
+        root, sessionId: sessionId(input), hookEvent: event,
+        scope: {
+          personaId: scope.entityId, userId: scope.userId, tenantId: scope.tenantId,
+          projectId: scope.projectId, groupId: scope.groupId, taskId: scope.currentTaskId
+        },
+        completedAt: input.timestamp || new Date()
+      });
+    } catch (error) {
+      learningDelivery = { status: "degraded", receipts: [], reason: error.message, authority: "context-only" };
+    }
     const requested = selfstarterInput(input);
     if (exact) {
       selfstarter = await closeJobLease({
@@ -694,7 +721,7 @@ export async function runHook(payload = null) {
         catalog, userStateRoot: resolvedSources.userStateRoot, sourceDiagnostics: resolvedSources.diagnostics,
         prompt: event === "UserPromptSubmit" ? promptFromInput(input) : null
       });
-      const context = renderContext(event, catalog, briefing, signal, attentionEvent, selfstarter, channelEvent, resolvedSources.diagnostics, preflight);
+      let context = renderContext(event, catalog, briefing, signal, attentionEvent, selfstarter, channelEvent, resolvedSources.diagnostics, preflight);
       if (event === "UserPromptSubmit" && Buffer.byteLength(context) > hostContextLimit(preflight)) {
         throw new Error("mandatory preflight context exceeds the host hook injection limit");
       }
@@ -702,6 +729,45 @@ export async function runHook(payload = null) {
         receipt: preflight.receipt, input, scope, resolvedSources, prompt: promptFromInput(input),
         now: input.timestamp || new Date(), env: process.env, consume: true
       })) throw new Error("preflight receipt could not be consumed atomically for this exact turn");
+      if (event === "UserPromptSubmit") {
+        const activeCanaries = briefing.learning.filter((item) => ["active", "revalidating"].includes(item.outcomeStatus));
+        if (!activeCanaries.length) {
+          preflight.learningApplications = {
+            status: "not-applicable", receipts: [], authority: "context-only"
+          };
+        } else try {
+          const application = await recordLearningApplications({
+            root, items: briefing.learning,
+            scope: {
+              personaId: scope.entityId, userId: scope.userId, tenantId: scope.tenantId,
+              projectId: scope.projectId, groupId: scope.groupId, taskId: scope.currentTaskId
+            },
+            preflightReceipt: preflight.receipt,
+            sessionBriefingDigest: createHash("sha256").update(JSON.stringify(briefing)).digest("hex"),
+            projectedAt: input.timestamp || new Date()
+          });
+          preflight.learningApplications = {
+            status: application.receipts.length ? "recorded" : "not-applicable",
+            receipts: application.receipts.map((item) => ({
+              id: item.id, learningId: item.learningId, projectedAt: item.projectedAt, expiresAt: item.expiresAt
+            })),
+            authority: "context-only"
+          };
+        } catch (error) {
+          briefing.learning = briefing.learning.filter((item) => !["active", "revalidating"].includes(item.outcomeStatus));
+          preflight.learningApplications = {
+            status: "degraded", receipts: [], reason: error.message, authority: "context-only"
+          };
+        }
+        const enriched = renderContext(event, catalog, briefing, signal, attentionEvent, selfstarter, channelEvent,
+          resolvedSources.diagnostics, preflight);
+        if (Buffer.byteLength(enriched) <= hostContextLimit(preflight)) context = enriched;
+        else if (preflight.learningApplications.status === "degraded") {
+          preflight.learningApplications = null;
+          context = renderContext(event, catalog, briefing, signal, attentionEvent, selfstarter, channelEvent,
+            resolvedSources.diagnostics, preflight);
+        }
+      }
       if (payload) return { blocked: false, context, briefing, preflight, signal, attentionEvent, channelEvent, catalogPath };
       process.stdout.write(`${JSON.stringify(hookOutput(event, context))}\n`);
       return;
@@ -728,12 +794,16 @@ export async function runHook(payload = null) {
     }
   }
 
-  if (payload) return { blocked: false, attentionEvent, selfstarter };
+  if (payload) return { blocked: false, attentionEvent, selfstarter, learningDelivery };
   process.stdout.write("{}\n");
 }
 
 if (isMainModule(import.meta.url)) {
-  runHook().catch((error) => {
+  const args = process.argv.slice(2);
+  const silentOversizePostToolUse = args.length === 1 && args[0] === SILENT_OVERSIZE_POST_TOOL_USE_ARG;
+  const argumentError = args.length && !silentOversizePostToolUse
+    ? new Error(`unsupported hook argument: ${args[0]}`) : null;
+  (argumentError ? Promise.reject(argumentError) : runHook(null, { silentOversizePostToolUse })).catch((error) => {
     process.stderr.write(`AgentSpine hook: ${String(error.message).slice(0, 2048)}\n`);
     // Claude command hooks treat exit 2 as a blocking failure. Exit 1 is
     // fail-open, which is unsafe for malformed pre-answer payloads.

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

@@ -12,9 +12,11 @@ export {
   recordActivity, recordAttentionEvent, resolveAttention, upsertAttention
 } from "./lib/attention.js";
 export {
-  acceptContinuityLearning, addLearningEvidence, configureLearning, deleteLearning, evaluateLearning,
+  acceptContinuityLearning, addLearningEvidence, beginLearningRevalidation, configureLearning, deleteLearning, evaluateLearning,
   learningContext, learningOutcomeStatus, loadLearning, proposeLearning, purgeLearningBySubject,
-  recordLearningOutcome, reviewLearning, rollbackLearning
+  purgeStaleLearningApplications, recordLearningOutcome, registerLearningEvaluation, renewLearningValidation,
+  reviewLearning, revokeLearningApplication, revokeLearningDelivery, revokeLearningEvaluation, revokeLearningEvidence, revokeLearningMeasurement, revokeLearningOutcome, revokeLearningTrialFailure, revokeLearningValidation,
+  rollbackLearning
 } from "./lib/learning.js";
 export {
   captureContinuityPrompt, configureContinuity, continuityFindings,