@cassiomc1/forgeloop 1.5.0 → 1.6.0

package/src/core/error-codes.js

@@ -50,6 +50,22 @@ export const E_DIAGNOSIS_EVIDENCE_INVALID = "E_DIAGNOSIS_EVIDENCE_INVALID";
 export const E_DIAGNOSIS_CYCLE_MISMATCH = "E_DIAGNOSIS_CYCLE_MISMATCH";
 export const E_DIAGNOSIS_NO_NEW_INFORMATION = "E_DIAGNOSIS_NO_NEW_INFORMATION";
 export const E_PROGRESS_STALLED = "E_PROGRESS_STALLED";
+export const E_DIAGNOSTIC_CASE_INVALID = "E_DIAGNOSTIC_CASE_INVALID";
+export const E_DIAGNOSTIC_CASE_CYCLE_MISMATCH = "E_DIAGNOSTIC_CASE_CYCLE_MISMATCH";
+export const E_DIAGNOSTIC_CASE_EVIDENCE_INVALID = "E_DIAGNOSTIC_CASE_EVIDENCE_INVALID";
+export const E_OBSERVATION_INVALID = "E_OBSERVATION_INVALID";
+export const E_CONTRIBUTOR_INVALID = "E_CONTRIBUTOR_INVALID";
+export const E_CONTRIBUTOR_REFERENCE_INVALID = "E_CONTRIBUTOR_REFERENCE_INVALID";
+export const E_HYPOTHESIS_INVALID = "E_HYPOTHESIS_INVALID";
+export const E_HYPOTHESIS_SETTLEMENT_MISSING = "E_HYPOTHESIS_SETTLEMENT_MISSING";
+export const E_HYPOTHESIS_DISPOSITION_INVALID = "E_HYPOTHESIS_DISPOSITION_INVALID";
+export const E_HYPOTHESIS_DISPOSITION_EVIDENCE_INVALID = "E_HYPOTHESIS_DISPOSITION_EVIDENCE_INVALID";
+export const E_INTERVENTION_INVALID = "E_INTERVENTION_INVALID";
+export const E_INTERVENTION_HYPOTHESIS_MISSING = "E_INTERVENTION_HYPOTHESIS_MISSING";
+export const E_INTERVENTION_REFERENCE_INVALID = "E_INTERVENTION_REFERENCE_INVALID";
+export const E_FAILURE_SIGNATURE_INVALID = "E_FAILURE_SIGNATURE_INVALID";
+export const E_NO_INFORMATION_GAIN = "E_NO_INFORMATION_GAIN";
+export const E_STRATEGY_OSCILLATION = "E_STRATEGY_OSCILLATION";
 export const E_DECISION_CRITERION_INVALID = "E_DECISION_CRITERION_INVALID";
 export const E_DECISION_NOT_UNRESOLVED = "E_DECISION_NOT_UNRESOLVED";
 
@@ -62,6 +78,34 @@ export const E_RECONCILE_EVIDENCE_FAILED = "E_RECONCILE_EVIDENCE_FAILED";
 export const E_REPOSITORY_CHANGED = "E_REPOSITORY_CHANGED";
 export const E_STATE_REVALIDATION_REQUIRED = "E_STATE_REVALIDATION_REQUIRED";
 
+export const E_ACTION_INVALID = "E_ACTION_INVALID";
+export const E_ACTION_NOT_FOUND = "E_ACTION_NOT_FOUND";
+export const E_ACTION_STATE_MISMATCH = "E_ACTION_STATE_MISMATCH";
+export const E_ACTION_IDEMPOTENCY_REQUIRED = "E_ACTION_IDEMPOTENCY_REQUIRED";
+export const E_ACTION_IDEMPOTENCY_CONFLICT = "E_ACTION_IDEMPOTENCY_CONFLICT";
+export const E_ACTION_CAPABILITY_UNKNOWN = "E_ACTION_CAPABILITY_UNKNOWN";
+export const E_ACTION_CAPABILITY_DENIED = "E_ACTION_CAPABILITY_DENIED";
+export const E_ACTION_AUTHORITY_REQUIRED = "E_ACTION_AUTHORITY_REQUIRED";
+export const E_ACTION_APPROVAL_REQUIRED = "E_ACTION_APPROVAL_REQUIRED";
+export const E_ACTION_APPROVAL_NOT_REQUIRED = "E_ACTION_APPROVAL_NOT_REQUIRED";
+export const E_ACTION_COMMIT_UNKNOWN = "E_ACTION_COMMIT_UNKNOWN";
+export const E_ACTION_RECONCILIATION_REQUIRED = "E_ACTION_RECONCILIATION_REQUIRED";
+export const E_ACTION_EVIDENCE_INVALID = "E_ACTION_EVIDENCE_INVALID";
+export const E_ACTION_AUTHORIZATION_INVALID = "E_ACTION_AUTHORIZATION_INVALID";
+export const E_ACTION_VERIFICATION_REQUIRED = "E_ACTION_VERIFICATION_REQUIRED";
+export const E_ACTION_VERIFICATION_INVALID = "E_ACTION_VERIFICATION_INVALID";
+export const E_ACTION_POLICY_DRIFT = "E_ACTION_POLICY_DRIFT";
+export const E_ACTION_POLICY_LOCK_REQUIRED = "E_ACTION_POLICY_LOCK_REQUIRED";
+export const E_ACTION_RECONCILIATION_AUTHORITY_REQUIRED =
+  "E_ACTION_RECONCILIATION_AUTHORITY_REQUIRED";
+export const E_ACTION_RECONCILIATION_EVIDENCE_INVALID =
+  "E_ACTION_RECONCILIATION_EVIDENCE_INVALID";
+export const E_APPROVAL_INVALID = "E_APPROVAL_INVALID";
+export const E_APPROVAL_STALE = "E_APPROVAL_STALE";
+export const E_APPROVAL_ALREADY_RESOLVED = "E_APPROVAL_ALREADY_RESOLVED";
+export const E_TRAJECTORY_SCENARIO_INVALID = "E_TRAJECTORY_SCENARIO_INVALID";
+export const E_TRAJECTORY_REFERENCE_REQUIRED = "E_TRAJECTORY_REFERENCE_REQUIRED";
+
 /**
  * Public, stable ForgeLoop error and reason codes documented for users and harnesses.
  */
@@ -381,6 +425,83 @@ export const PUBLIC_ERROR_CODES = Object.freeze({
     meaning: "Persisted correction history shows no new diagnostic information.",
     safeResolution: "Use an independent check, revisit assumptions, or record a materially different diagnosis.",
   }),
+  E_DIAGNOSTIC_CASE_INVALID: Object.freeze({
+    code: "E_DIAGNOSTIC_CASE_INVALID",
+    category: "diagnosis",
+    classification: "PUBLIC_STABLE",
+    meaning: "Structured diagnostic case details or parameters are malformed.",
+    safeResolution: "Provide valid observations, contributors, hypotheses with settlement criteria, and nextSafeAction.",
+  }),
+  E_DIAGNOSTIC_CASE_CYCLE_MISMATCH: Object.freeze({
+    code: "E_DIAGNOSTIC_CASE_CYCLE_MISMATCH",
+    category: "diagnosis",
+    classification: "PUBLIC_STABLE",
+    meaning: "Diagnostic case verification cycle does not match the active work state verification cycle.",
+    safeResolution: "Record the diagnostic case for the current active verification cycle.",
+  }),
+  E_DIAGNOSTIC_CASE_EVIDENCE_INVALID: Object.freeze({
+    code: "E_DIAGNOSTIC_CASE_EVIDENCE_INVALID",
+    category: "diagnosis",
+    classification: "PUBLIC_STABLE",
+    meaning: "A diagnostic case evidence reference does not match any check from the active verification cycle.",
+    safeResolution: "Reference check IDs recorded during the active verification cycle.",
+  }),
+  E_HYPOTHESIS_SETTLEMENT_MISSING: Object.freeze({
+    code: "E_HYPOTHESIS_SETTLEMENT_MISSING",
+    category: "diagnosis",
+    classification: "PUBLIC_STABLE",
+    meaning: "An open hypothesis lacks a falsifiable settlement condition.",
+    safeResolution: "Provide a structured settledBy predicate, check status, or observation binding.",
+  }),
+  E_HYPOTHESIS_DISPOSITION_INVALID: Object.freeze({
+    code: "E_HYPOTHESIS_DISPOSITION_INVALID",
+    category: "diagnosis",
+    classification: "PUBLIC_STABLE",
+    meaning: "Hypothesis disposition is malformed or references an unknown hypothesis or disallowed transition.",
+    safeResolution: "Record a disposition for a known hypothesis using an allowed status transition.",
+  }),
+  E_HYPOTHESIS_DISPOSITION_EVIDENCE_INVALID: Object.freeze({
+    code: "E_HYPOTHESIS_DISPOSITION_EVIDENCE_INVALID",
+    category: "diagnosis",
+    classification: "PUBLIC_STABLE",
+    meaning: "Hypothesis disposition evidence references do not resolve to checks of the active cycle.",
+    safeResolution: "Reference at least one check ID recorded in the active verification cycle.",
+  }),
+  E_INTERVENTION_INVALID: Object.freeze({
+    code: "E_INTERVENTION_INVALID",
+    category: "diagnosis",
+    classification: "PUBLIC_STABLE",
+    meaning: "Intervention record is malformed.",
+    safeResolution: "Provide id, kind, statement, and at least one bound hypothesisRef.",
+  }),
+  E_INTERVENTION_HYPOTHESIS_MISSING: Object.freeze({
+    code: "E_INTERVENTION_HYPOTHESIS_MISSING",
+    category: "diagnosis",
+    classification: "PUBLIC_STABLE",
+    meaning: "Intervention does not bind to any hypothesis.",
+    safeResolution: "Bind the intervention to at least one recorded hypothesis.",
+  }),
+  E_INTERVENTION_REFERENCE_INVALID: Object.freeze({
+    code: "E_INTERVENTION_REFERENCE_INVALID",
+    category: "diagnosis",
+    classification: "PUBLIC_STABLE",
+    meaning: "Intervention references an unknown hypothesis.",
+    safeResolution: "Record the diagnostic case containing the hypothesis before recording the intervention.",
+  }),
+  E_STRATEGY_OSCILLATION: Object.freeze({
+    code: "E_STRATEGY_OSCILLATION",
+    category: "progress",
+    classification: "PUBLIC_STABLE",
+    meaning: "Correction history oscillates between previously exhausted strategies without new information.",
+    safeResolution: "Gather a genuinely new observation or test a materially different falsifiable hypothesis.",
+  }),
+  E_TRACE_SNAPSHOT_INCONSISTENT: Object.freeze({
+    code: "E_TRACE_SNAPSHOT_INCONSISTENT",
+    category: "diagnosis",
+    classification: "PUBLIC_STABLE",
+    meaning: "Task artifacts changed while the execution trace was being read.",
+    safeResolution: "Rerun the read-only projection to obtain a consistent view.",
+  }),
   E_DECISION_CRITERION_INVALID: Object.freeze({
     code: "E_DECISION_CRITERION_INVALID",
     category: "contract",
@@ -514,6 +635,181 @@ export const PUBLIC_ERROR_CODES = Object.freeze({
     meaning: "A canonical ForgeLoop kit destination already exists with content that does not match the shipped canonical template.",
     safeResolution: "Inspect the conflicting `.forgeloop/kit/...` file. If it is stale or partial ForgeLoop output, remove or restore it and rerun `forgeloop init`. Do not overwrite unknown content automatically.",
   }),
+  E_ACTION_INVALID: Object.freeze({
+    code: "E_ACTION_INVALID",
+    category: "durable-action",
+    classification: "PUBLIC_STABLE",
+    meaning: "Durable action artifact or parameters are malformed or schema-invalid.",
+    safeResolution: "Correct the action fields reported by the structured error, then retry through forgeloop action-propose or run-action.",
+  }),
+  E_ACTION_NOT_FOUND: Object.freeze({
+    code: "E_ACTION_NOT_FOUND",
+    category: "durable-action",
+    classification: "PUBLIC_STABLE",
+    meaning: "Referenced durable action ID does not exist for the task.",
+    safeResolution: "List actions with forgeloop action-show or propose the action first.",
+  }),
+  E_ACTION_STATE_MISMATCH: Object.freeze({
+    code: "E_ACTION_STATE_MISMATCH",
+    category: "durable-action",
+    classification: "PUBLIC_STABLE",
+    meaning: "Requested durable action transition is not part of the canonical state machine.",
+    safeResolution: "Inspect current action state with forgeloop action-show and use a legal transition; never edit action artifacts by hand.",
+  }),
+  E_ACTION_IDEMPOTENCY_REQUIRED: Object.freeze({
+    code: "E_ACTION_IDEMPOTENCY_REQUIRED",
+    category: "durable-action",
+    classification: "PUBLIC_STABLE",
+    meaning: "Side-effecting action class requires an idempotency key.",
+    safeResolution: "Supply a stable --idempotency-key that identifies the logical external action.",
+  }),
+  E_ACTION_IDEMPOTENCY_CONFLICT: Object.freeze({
+    code: "E_ACTION_IDEMPOTENCY_CONFLICT",
+    category: "durable-action",
+    classification: "PUBLIC_STABLE",
+    meaning: "The idempotency key already binds to a different canonical action fingerprint in this task.",
+    safeResolution: "Use a new idempotency key with a new actionId, or reuse the existing logical action unchanged; never relabel an executed effect.",
+  }),
+  E_ACTION_CAPABILITY_UNKNOWN: Object.freeze({
+    code: "E_ACTION_CAPABILITY_UNKNOWN",
+    category: "capability-policy",
+    classification: "PUBLIC_STABLE",
+    meaning: "Action capability is not part of the canonical capability vocabulary.",
+    safeResolution: "Use a documented capability from forgeloop protocol-info; unknown capabilities fail closed.",
+  }),
+  E_ACTION_CAPABILITY_DENIED: Object.freeze({
+    code: "E_ACTION_CAPABILITY_DENIED",
+    category: "capability-policy",
+    classification: "PUBLIC_STABLE",
+    meaning: "Capability policy denies this capability.",
+    safeResolution: "Obtain an operator policy change outside the task, or do not perform the action.",
+  }),
+  E_ACTION_AUTHORITY_REQUIRED: Object.freeze({
+    code: "E_ACTION_AUTHORITY_REQUIRED",
+    category: "authority",
+    classification: "PUBLIC_STABLE",
+    meaning: "Policy requires host-attested authority that was not supplied through a host trust boundary.",
+    safeResolution: "Perform the action through a host integration that supplies trusted authority context; standalone CLI cannot mint it.",
+  }),
+  E_ACTION_APPROVAL_REQUIRED: Object.freeze({
+    code: "E_ACTION_APPROVAL_REQUIRED",
+    category: "durable-approval",
+    classification: "PUBLIC_STABLE",
+    meaning: "Policy requires a current fingerprint-bound approval before this action may proceed.",
+    safeResolution: "Request approval with forgeloop approval-request and resolve it via forgeloop approval-resolve, then rerun the action.",
+  }),
+  E_ACTION_APPROVAL_NOT_REQUIRED: Object.freeze({
+    code: "E_ACTION_APPROVAL_NOT_REQUIRED",
+    category: "durable-approval",
+    classification: "PUBLIC_STABLE",
+    meaning: "The current capability policy allows the action without an approval artifact.",
+    safeResolution: "Do not create an approval; authorize the action through the current policy path.",
+  }),
+  E_ACTION_COMMIT_UNKNOWN: Object.freeze({
+    code: "E_ACTION_COMMIT_UNKNOWN",
+    category: "durable-action",
+    classification: "PUBLIC_STABLE",
+    meaning: "External commit state of a started action cannot be proven.",
+    safeResolution: "Do not retry; reconcile the observed external state with forgeloop action-reconcile.",
+  }),
+  E_ACTION_RECONCILIATION_REQUIRED: Object.freeze({
+    code: "E_ACTION_RECONCILIATION_REQUIRED",
+    category: "durable-action",
+    classification: "PUBLIC_STABLE",
+    meaning: "An action is COMMIT_UNKNOWN and blocks progress until explicitly reconciled.",
+    safeResolution: "Observe the external system and run forgeloop action-reconcile --outcome COMMITTED|NOT_COMMITTED|UNKNOWN with evidence references.",
+  }),
+  E_ACTION_EVIDENCE_INVALID: Object.freeze({
+    code: "E_ACTION_EVIDENCE_INVALID",
+    category: "durable-action",
+    classification: "PUBLIC_STABLE",
+    meaning: "Evidence supplied for verification or reconciliation is missing, malformed, or unbounded.",
+    safeResolution: "Supply bounded evidence references appropriate to the action type; do not paste raw external output into the ledger.",
+  }),
+  E_ACTION_AUTHORIZATION_INVALID: Object.freeze({
+    code: "E_ACTION_AUTHORIZATION_INVALID",
+    category: "durable-action",
+    classification: "PUBLIC_STABLE",
+    meaning: "Action authorization evidence is missing, incomplete, or was not produced by the canonical authorization service.",
+    safeResolution: "Authorize the action through forgeloop run-action or a trusted embedding host; caller surfaces can never mint AUTHORIZED.",
+  }),
+  E_ACTION_VERIFICATION_REQUIRED: Object.freeze({
+    code: "E_ACTION_VERIFICATION_REQUIRED",
+    category: "durable-action",
+    classification: "PUBLIC_STABLE",
+    meaning: "The action cannot reach VERIFIED through this surface; canonical independent postcondition evidence is required.",
+    safeResolution: "Run an independent verification check, then record it with forgeloop action-verify; exit code 0 alone is not verification.",
+  }),
+  E_ACTION_VERIFICATION_INVALID: Object.freeze({
+    code: "E_ACTION_VERIFICATION_INVALID",
+    category: "durable-action",
+    classification: "PUBLIC_STABLE",
+    meaning: "Verification evidence does not resolve to a canonical passed ForgeLoop artifact bound to this task and action.",
+    safeResolution: "Supply a canonical execution or check reference produced by run-check for this task; arbitrary strings fail closed.",
+  }),
+  E_ACTION_POLICY_DRIFT: Object.freeze({
+    code: "E_ACTION_POLICY_DRIFT",
+    category: "capability-policy",
+    classification: "PUBLIC_STABLE",
+    meaning: "The current capability policy does not match the policy lock or task policy snapshot binding this task.",
+    safeResolution: "Restore the policy epoch recorded at task activation or create a new valid lock and snapshot before side effects.",
+  }),
+  E_ACTION_POLICY_LOCK_REQUIRED: Object.freeze({
+    code: "E_ACTION_POLICY_LOCK_REQUIRED",
+    category: "capability-policy",
+    classification: "PUBLIC_STABLE",
+    meaning: "A capability policy is present but no valid policy lock exists to bind authorization identity.",
+    safeResolution: "Record a valid policy lock (forgeloop baseline or policy-discover --write) before authorizing durable actions.",
+  }),
+  E_ACTION_RECONCILIATION_AUTHORITY_REQUIRED: Object.freeze({
+    code: "E_ACTION_RECONCILIATION_AUTHORITY_REQUIRED",
+    category: "durable-action",
+    classification: "PUBLIC_STABLE",
+    meaning: "Settling COMMIT_UNKNOWN external state requires trusted host attestation that was not supplied out-of-band.",
+    safeResolution: "Reconcile through a trusted embedding host boundary; actor-supplied observations may only record UNKNOWN.",
+  }),
+  E_ACTION_RECONCILIATION_EVIDENCE_INVALID: Object.freeze({
+    code: "E_ACTION_RECONCILIATION_EVIDENCE_INVALID",
+    category: "durable-action",
+    classification: "PUBLIC_STABLE",
+    meaning: "Settling reconciliation requires at least one bounded evidence reference binding the observation to the action.",
+    safeResolution: "Supply bounded external-state evidence references alongside trusted authority before settling ambiguity.",
+  }),
+  E_APPROVAL_INVALID: Object.freeze({
+    code: "E_APPROVAL_INVALID",
+    category: "durable-approval",
+    classification: "PUBLIC_STABLE",
+    meaning: "Approval artifact is malformed or does not bind the required fingerprint tuple.",
+    safeResolution: "Request a new approval with forgeloop approval-request; never hand-edit approval artifacts.",
+  }),
+  E_APPROVAL_STALE: Object.freeze({
+    code: "E_APPROVAL_STALE",
+    category: "durable-approval",
+    classification: "PUBLIC_STABLE",
+    meaning: "Approval no longer matches the current action fingerprint, contract fingerprint, task revision, or capability.",
+    safeResolution: "Request and resolve a fresh approval against the current action revision.",
+  }),
+  E_APPROVAL_ALREADY_RESOLVED: Object.freeze({
+    code: "E_APPROVAL_ALREADY_RESOLVED",
+    category: "durable-approval",
+    classification: "PUBLIC_STABLE",
+    meaning: "Approval is one-time resolvable and has already been approved or rejected.",
+    safeResolution: "Request a new approval if another decision is required.",
+  }),
+  E_TRAJECTORY_SCENARIO_INVALID: Object.freeze({
+    code: "E_TRAJECTORY_SCENARIO_INVALID",
+    category: "trajectory-evaluation",
+    classification: "PUBLIC_STABLE",
+    meaning: "Trajectory scenario file is missing required fields or schema-invalid.",
+    safeResolution: "Correct the scenario JSON against schemas/trajectory-scenario.schema.json.",
+  }),
+  E_TRAJECTORY_REFERENCE_REQUIRED: Object.freeze({
+    code: "E_TRAJECTORY_REFERENCE_REQUIRED",
+    category: "trajectory-evaluation",
+    classification: "PUBLIC_STABLE",
+    meaning: "Comparative efficiency requires a reference scenario with positive comparableSteps.",
+    safeResolution: "Provide --scenario with reference.comparableSteps, or omit efficiency from the result.",
+  }),
 });
 
 export const E_CHECK_INERT = "E_CHECK_INERT";
@@ -605,6 +901,53 @@ export const ALL_KNOWN_ERROR_CODES = Object.freeze(new Set([
   E_BASELINE_RECORD_DURING_ACTIVE_TASK,
   E_POLICY_INITIALIZATION_FAILED,
   E_INIT_KIT_CONFLICT,
+  E_ACTION_INVALID,
+  E_ACTION_NOT_FOUND,
+  E_ACTION_STATE_MISMATCH,
+  E_ACTION_IDEMPOTENCY_REQUIRED,
+  E_ACTION_IDEMPOTENCY_CONFLICT,
+  E_ACTION_CAPABILITY_UNKNOWN,
+  E_ACTION_CAPABILITY_DENIED,
+  E_ACTION_AUTHORITY_REQUIRED,
+  E_ACTION_APPROVAL_REQUIRED,
+  E_ACTION_APPROVAL_NOT_REQUIRED,
+  E_ACTION_COMMIT_UNKNOWN,
+  E_ACTION_RECONCILIATION_REQUIRED,
+  E_ACTION_EVIDENCE_INVALID,
+  E_ACTION_AUTHORIZATION_INVALID,
+  E_ACTION_VERIFICATION_REQUIRED,
+  E_ACTION_VERIFICATION_INVALID,
+  E_ACTION_POLICY_DRIFT,
+  E_ACTION_POLICY_LOCK_REQUIRED,
+  E_ACTION_RECONCILIATION_AUTHORITY_REQUIRED,
+  E_ACTION_RECONCILIATION_EVIDENCE_INVALID,
+  E_APPROVAL_INVALID,
+  E_APPROVAL_STALE,
+  E_APPROVAL_ALREADY_RESOLVED,
+  E_TRAJECTORY_SCENARIO_INVALID,
+  E_TRAJECTORY_REFERENCE_REQUIRED,
+  E_DIAGNOSIS_REQUIRED,
+  E_DIAGNOSIS_INVALID,
+  E_DIAGNOSIS_EVIDENCE_INVALID,
+  E_DIAGNOSIS_CYCLE_MISMATCH,
+  E_DIAGNOSIS_NO_NEW_INFORMATION,
+  E_PROGRESS_STALLED,
+  E_DIAGNOSTIC_CASE_INVALID,
+  E_DIAGNOSTIC_CASE_CYCLE_MISMATCH,
+  E_DIAGNOSTIC_CASE_EVIDENCE_INVALID,
+  E_OBSERVATION_INVALID,
+  E_CONTRIBUTOR_INVALID,
+  E_CONTRIBUTOR_REFERENCE_INVALID,
+  E_HYPOTHESIS_INVALID,
+  E_HYPOTHESIS_SETTLEMENT_MISSING,
+  E_HYPOTHESIS_DISPOSITION_INVALID,
+  E_HYPOTHESIS_DISPOSITION_EVIDENCE_INVALID,
+  E_INTERVENTION_INVALID,
+  E_INTERVENTION_HYPOTHESIS_MISSING,
+  E_INTERVENTION_REFERENCE_INVALID,
+  E_FAILURE_SIGNATURE_INVALID,
+  E_STRATEGY_OSCILLATION,
+  "E_TRACE_SNAPSHOT_INCONSISTENT",
 ]));
 
 /**

package/src/core/events.js

@@ -14,6 +14,17 @@ import { taskArtifactPath } from "./task-paths.js";
 import { getActiveTaskTransaction, withTaskTransaction } from "./transaction.js";
 
 import { assertDiagnosisDetails } from "./diagnosis-model.js";
+import {
+  assertActionEventDetails,
+  assertApprovalEventDetails,
+  isActionEventName,
+  isApprovalEventName,
+} from "./action-model.js";
+import {
+  assertDiagnosticCaseDetails,
+  assertInterventionDetails,
+  assertHypothesisDispositionDetails,
+} from "./diagnostic-model.js";
 import { assertDecisionCriterionDetails } from "./settlement-model.js";
 import {
   LEGACY_RECOVERY_MIGRATION_EVENT,
@@ -46,6 +57,7 @@ const REPEATABLE_MILESTONES = new Set([
   "VERIFICATION_RECORDED",
   "REVIEW_STARTED",
   "TERMINAL_RESULT_RECORDED",
+  "PREFLIGHT_READY",
 ]);
 
 function eventIndexPath(eventsPath) {
@@ -98,6 +110,15 @@ export function validateKnownEventDetails(event) {
     case "DIAGNOSIS_RECORDED":
       assertDiagnosisDetails(event.details);
       return;
+    case "DIAGNOSTIC_CASE_RECORDED":
+      assertDiagnosticCaseDetails(event.details);
+      return;
+    case "INTERVENTION_RECORDED":
+      assertInterventionDetails(event.details);
+      return;
+    case "HYPOTHESIS_DISPOSITION_RECORDED":
+      assertHypothesisDispositionDetails(event.details);
+      return;
     case "DECISION_CRITERION_RECORDED":
       assertDecisionCriterionDetails(event.details);
       return;
@@ -120,7 +141,22 @@ export function validateKnownEventDetails(event) {
     case "TASK_RECOVERY_RESUMED":
       assertRecoveryResumedDetails(event.details);
       return;
+    case "TRAJECTORY_EVALUATED":
+      if (!event.details || !/^eval-[A-Za-z0-9_-]+$/.test(event.details.evaluationId ?? "")
+        || typeof event.details.scenarioId !== "string" || !/^[a-f0-9]{64}$/.test(event.details.evaluationFingerprint ?? "")
+        || event.fingerprint !== event.details.evaluationFingerprint) {
+        throw protocolError("E_EVENT_INVALID", "TRAJECTORY_EVALUATED requires a bound evaluationId, scenarioId, and fingerprint");
+      }
+      return;
     default:
+      if (isActionEventName(event.event)) {
+        assertActionEventDetails(event);
+        return;
+      }
+      if (isApprovalEventName(event.event)) {
+        assertApprovalEventDetails(event);
+        return;
+      }
       return;
   }
 }
@@ -410,7 +446,11 @@ export async function validateEventLedger(target, packageRoot, options = {}) {
           code: "E_PHASE_CHRONOLOGY_INVALID",
           message: `${event.event} is missing prerequisite milestone: ${LIFECYCLE_MILESTONES[lastMilestone + 1]}`,
         });
-      } else if (milestoneIndex < lastMilestone && event.event !== "VERIFICATION_STARTED") {
+      } else if (milestoneIndex < lastMilestone && event.event !== "VERIFICATION_STARTED"
+        && event.event !== "PREFLIGHT_READY") {
+        // VERIFICATION_STARTED re-enters per verification cycle; PREFLIGHT_READY
+        // may be refreshed mid-lifecycle (policy/contract evolution) after its
+        // prerequisites were already satisfied by the earlier occurrence.
         errors.push({ code: "E_PHASE_CHRONOLOGY_INVALID", message: `${event.event} is out of lifecycle order` });
       } else if (milestoneIndex === lastMilestone && !REPEATABLE_MILESTONES.has(event.event)) {
         errors.push({ code: "E_PHASE_CHRONOLOGY_INVALID", message: `lifecycle milestone must not repeat: ${event.event}` });

package/src/core/execution-prerequisites.js

@@ -102,7 +102,10 @@ function prerequisiteLedgerErrors(ledger, taskId, preflight, route) {
       ));
     }
   }
-  const preflightEvent = currentEvents.find((event) => event.event === "PREFLIGHT_READY");
+  // Bind to the latest PREFLIGHT_READY: an append-only lifecycle may contain an
+  // older READY event superseded by a BLOCKED outcome and a fresh READY with
+  // current details (see preflight-reactivation recovery).
+  const preflightEvent = currentEvents.findLast((event) => event.event === "PREFLIGHT_READY");
   if (preflightEvent && (!sameStringSet(preflightEvent.details?.requiredGates, preflight.requiredGates)
     || !sameStringSet(preflightEvent.details?.satisfiedGates, preflight.satisfiedGates))) {
     errors.push(issue(