@cassiomc1/forgeloop 1.3.0 → 1.6.0

package/src/core/error-codes.js

@@ -10,6 +10,7 @@ import {
 export const E_TASK_REQUIRED = "E_TASK_REQUIRED";
 export const E_TASK_NOT_FOUND = "E_TASK_NOT_FOUND";
 export const E_TASK_ALREADY_EXISTS = "E_TASK_ALREADY_EXISTS";
+export const E_TASK_COMPLETE = "E_TASK_COMPLETE";
 export const E_TASK_AMBIGUOUS = "E_TASK_AMBIGUOUS";
 export const E_TASK_SELECTOR_CONFLICT = "E_TASK_SELECTOR_CONFLICT";
 export const E_TASK_DESCRIPTOR_INVALID = "E_TASK_DESCRIPTOR_INVALID";
@@ -18,6 +19,7 @@ export const E_TASK_CONTEXT_MISMATCH = "E_TASK_CONTEXT_MISMATCH";
 
 export const E_TASK_LOCKED = "E_TASK_LOCKED";
 export const E_TASK_LOCK_INVALID = "E_TASK_LOCK_INVALID";
+export const E_PROJECT_CLAIMS_LOCK_INCONSISTENT = "E_PROJECT_CLAIMS_LOCK_INCONSISTENT";
 
 export const E_TASK_SCOPE_REQUIRED = "E_TASK_SCOPE_REQUIRED";
 export const E_TASK_SCOPE_CONFLICT = "E_TASK_SCOPE_CONFLICT";
@@ -28,6 +30,17 @@ export const E_TASK_CHANGE_ATTRIBUTION_UNAVAILABLE = "E_TASK_CHANGE_ATTRIBUTION_
 
 export const E_TASK_LAYOUT_LEGACY = "E_TASK_LAYOUT_LEGACY";
 export const E_TASK_MIGRATION_INVALID = "E_TASK_MIGRATION_INVALID";
+export const E_TASK_RECOVERY_UNSAFE = "E_TASK_RECOVERY_UNSAFE";
+export const E_TASK_RECOVERY_INCONSISTENT = "E_TASK_RECOVERY_INCONSISTENT";
+export const E_LEGACY_RECOVERY_MIGRATION_INVALID = "E_LEGACY_RECOVERY_MIGRATION_INVALID";
+export const E_COMPLETION_OWNERSHIP_UNPROVEN = "E_COMPLETION_OWNERSHIP_UNPROVEN";
+export const E_TASK_CLAIM_OWNERSHIP_INCONSISTENT = "E_TASK_CLAIM_OWNERSHIP_INCONSISTENT";
+export const E_TASK_RECOVERY_AUTHORIZATION_REQUIRED = "E_TASK_RECOVERY_AUTHORIZATION_REQUIRED";
+export const E_TASK_RECOVERY_AUTHORITY_INVALID = "E_TASK_RECOVERY_AUTHORITY_INVALID";
+export const E_TASK_RECOVERED = "E_TASK_RECOVERED";
+export const E_TASK_NOT_RECOVERED = "E_TASK_NOT_RECOVERED";
+export const E_TASK_RECOVERY_OFFICIAL_PATH_AVAILABLE = "E_TASK_RECOVERY_OFFICIAL_PATH_AVAILABLE";
+export const E_TASK_ALREADY_RECOVERED = "E_TASK_ALREADY_RECOVERED";
 export const E_TASK_MIGRATION_IDENTITY_MISMATCH = "E_TASK_MIGRATION_IDENTITY_MISMATCH";
 export const E_PROTOCOL_MIGRATION_TARGET_UNSUPPORTED = "E_PROTOCOL_MIGRATION_TARGET_UNSUPPORTED";
 
@@ -37,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";
 
@@ -49,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.
  */
@@ -151,6 +208,13 @@ export const PUBLIC_ERROR_CODES = Object.freeze({
     meaning: "Multiple tasks exist in the project but no task selector was provided.",
     safeResolution: "Select a task explicitly using --task <id> or FORGELOOP_TASK=<id>.",
   }),
+  E_TASK_COMPLETE: Object.freeze({
+    code: "E_TASK_COMPLETE",
+    category: "task-resolution",
+    classification: "PUBLIC_STABLE",
+    meaning: "A validator-backed COMPLETE task is terminal and cannot be mutated.",
+    safeResolution: "Create or select a non-terminal task for further work; do not modify terminal task state.",
+  }),
   E_TASK_LOCKED: Object.freeze({
     code: "E_TASK_LOCKED",
     category: "concurrency",
@@ -158,12 +222,96 @@ export const PUBLIC_ERROR_CODES = Object.freeze({
     meaning: "Task mutation is currently locked by another concurrent process or run-check.",
     safeResolution: "Wait for the active mutation to complete or inspect the lock with forgeloop task-show.",
   }),
+  E_PROJECT_CLAIMS_LOCK_INCONSISTENT: Object.freeze({
+    code: "E_PROJECT_CLAIMS_LOCK_INCONSISTENT",
+    category: "concurrency",
+    classification: "PUBLIC_STABLE",
+    meaning: "The project-wide claim reservation lock has unknown, corrupt, or concurrently changed ownership metadata.",
+    safeResolution: "Inspect .forgeloop/.claims.lock and retry only after its lease and owner identity can be validated; never force-delete unknown ownership.",
+  }),
   E_TASK_SCOPE_CONFLICT: Object.freeze({
     code: "E_TASK_SCOPE_CONFLICT",
     category: "scope",
     classification: "PUBLIC_STABLE",
     meaning: "Task write claims overlap with another non-complete task in the same checkout.",
-    safeResolution: "Adjust write claims to non-overlapping paths or run tasks in separate worktrees.",
+    safeResolution: "Inspect the conflicting task classification reported in error.conflicts, then reconcile or recover it through its reported official recovery commands before retrying task creation.",
+  }),
+  E_TASK_RECOVERY_UNSAFE: Object.freeze({
+    code: "E_TASK_RECOVERY_UNSAFE",
+    category: "recovery",
+    classification: "PUBLIC_STABLE",
+    meaning: "Claim-release recovery was refused because the conflicting task is active, inconsistent, already complete, or holds a live lease.",
+    safeResolution: "Resolve the reported classification first; live leases must expire or be released by their owner before recovery.",
+  }),
+  E_TASK_RECOVERY_INCONSISTENT: Object.freeze({
+    code: "E_TASK_RECOVERY_INCONSISTENT",
+    category: "recovery",
+    classification: "PUBLIC_STABLE",
+    meaning: "Claim-release recovery was refused because the task state, recovery artifact, lock, or event ledger is inconsistent.",
+    safeResolution: "Repair the underlying artifact through its dedicated recovery surface; do not force-complete an unreadable task.",
+  }),
+  E_LEGACY_RECOVERY_MIGRATION_INVALID: Object.freeze({
+    code: "E_LEGACY_RECOVERY_MIGRATION_INVALID",
+    category: "recovery",
+    classification: "PUBLIC_STABLE",
+    meaning: "The legacy recovery-event repair was refused because the ledger does not match the exact known legacy defect signature, has incompatible later activity, holds a live lock, or is otherwise ambiguous.",
+    safeResolution: "Inspect the structured plan/errors; ambiguous or tampered ledgers stay INCONSISTENT and are never migrated.",
+  }),
+  E_COMPLETION_OWNERSHIP_UNPROVEN: Object.freeze({
+    code: "E_COMPLETION_OWNERSHIP_UNPROVEN",
+    category: "recovery",
+    classification: "PUBLIC_STABLE",
+    meaning: "Work-state claims COMPLETE but the canonical lifecycle/ledger completion proof is missing or invalid, so historical claims stay reserved.",
+    safeResolution: "Restore the canonical completion event and a valid ledger, or re-run the official completion pipeline; phase=COMPLETE alone never releases claims.",
+  }),
+  E_TASK_CLAIM_OWNERSHIP_INCONSISTENT: Object.freeze({
+    code: "E_TASK_CLAIM_OWNERSHIP_INCONSISTENT",
+    category: "recovery",
+    classification: "PUBLIC_STABLE",
+    meaning: "ForgeLoop cannot prove whether a task still owns its historical write claims.",
+    safeResolution: "Repair and validate the task descriptor, recovery artifact, and complete event ledger before acquiring overlapping claims or mutating the task.",
+  }),
+  E_TASK_RECOVERY_AUTHORIZATION_REQUIRED: Object.freeze({
+    code: "E_TASK_RECOVERY_AUTHORIZATION_REQUIRED",
+    category: "recovery",
+    classification: "PUBLIC_STABLE",
+    meaning: "task-recover requires explicit caller acknowledgement; this is not host-attested authority.",
+    safeResolution: "Re-run with --acknowledge-recovery only when evidence shows the task is STALE or ABANDONED; --operator-authorized remains a deprecated alias.",
+  }),
+  E_TASK_RECOVERY_AUTHORITY_INVALID: Object.freeze({
+    code: "E_TASK_RECOVERY_AUTHORITY_INVALID",
+    category: "authority",
+    classification: "PUBLIC_STABLE",
+    meaning: "Recovery authority metadata is invalid or claims host attestation without a host-owned grant reference.",
+    safeResolution: "Use caller acknowledgement, or provide a host-attested recovery grant through a trusted host integration.",
+  }),
+  E_TASK_RECOVERED: Object.freeze({
+    code: "E_TASK_RECOVERED",
+    category: "recovery",
+    classification: "PUBLIC_STABLE",
+    meaning: "The task released its write claims through recovery and ordinary mutation is suspended.",
+    safeResolution: "Run forgeloop task-resume --task <id> to reacquire the released claims before mutating the task.",
+  }),
+  E_TASK_NOT_RECOVERED: Object.freeze({
+    code: "E_TASK_NOT_RECOVERED",
+    category: "recovery",
+    classification: "PUBLIC_STABLE",
+    meaning: "task-resume was requested for a task without active recovered state.",
+    safeResolution: "Inspect the task with forgeloop task-show; task-resume is only valid while recovery.json is active.",
+  }),
+  E_TASK_RECOVERY_OFFICIAL_PATH_AVAILABLE: Object.freeze({
+    code: "E_TASK_RECOVERY_OFFICIAL_PATH_AVAILABLE",
+    category: "recovery",
+    classification: "PUBLIC_STABLE",
+    meaning: "Claim-release recovery was refused because canonical lifecycle reconciliation is available.",
+    safeResolution: "Use forgeloop reconcile-closure and the normal verification/completion pipeline instead of task-recover.",
+  }),
+  E_TASK_ALREADY_RECOVERED: Object.freeze({
+    code: "E_TASK_ALREADY_RECOVERED",
+    category: "recovery",
+    classification: "PUBLIC_STABLE",
+    meaning: "The task already has active durable recovered state.",
+    safeResolution: "Inspect the existing recovery metadata; use task-resume to reacquire claims or leave the task recovered.",
   }),
   E_TASK_SCOPE_DIRTY: Object.freeze({
     code: "E_TASK_SCOPE_DIRTY",
@@ -277,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",
@@ -410,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";
@@ -446,6 +846,7 @@ export const ALL_KNOWN_ERROR_CODES = Object.freeze(new Set([
   E_TASK_REQUIRED,
   E_TASK_NOT_FOUND,
   E_TASK_ALREADY_EXISTS,
+  E_TASK_COMPLETE,
   E_TASK_AMBIGUOUS,
   E_TASK_SELECTOR_CONFLICT,
   E_TASK_DESCRIPTOR_INVALID,
@@ -453,6 +854,7 @@ export const ALL_KNOWN_ERROR_CODES = Object.freeze(new Set([
   E_TASK_CONTEXT_MISMATCH,
   E_TASK_LOCKED,
   E_TASK_LOCK_INVALID,
+  E_PROJECT_CLAIMS_LOCK_INCONSISTENT,
   E_TASK_SCOPE_REQUIRED,
   E_TASK_SCOPE_CONFLICT,
   E_TASK_SCOPE_DIRTY,
@@ -469,6 +871,17 @@ export const ALL_KNOWN_ERROR_CODES = Object.freeze(new Set([
   E_TASK_CHANGE_ATTRIBUTION_UNAVAILABLE,
   E_TASK_LAYOUT_LEGACY,
   E_TASK_MIGRATION_INVALID,
+  E_TASK_RECOVERY_UNSAFE,
+  E_TASK_RECOVERY_INCONSISTENT,
+  E_LEGACY_RECOVERY_MIGRATION_INVALID,
+  E_COMPLETION_OWNERSHIP_UNPROVEN,
+  E_TASK_CLAIM_OWNERSHIP_INCONSISTENT,
+  E_TASK_RECOVERY_AUTHORIZATION_REQUIRED,
+  E_TASK_RECOVERY_AUTHORITY_INVALID,
+  E_TASK_RECOVERED,
+  E_TASK_NOT_RECOVERED,
+  E_TASK_RECOVERY_OFFICIAL_PATH_AVAILABLE,
+  E_TASK_ALREADY_RECOVERED,
   E_TASK_MIGRATION_IDENTITY_MISMATCH,
   E_PROTOCOL_MIGRATION_TARGET_UNSUPPORTED,
   E_CHECK_INERT,
@@ -488,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",
 ]));
 
 /**