@cassiomc1/forgeloop 1.12.0 → 1.14.0

package/src/core/error-codes.js

@@ -142,11 +142,46 @@ export const E_ADVISORY_CONTEXT_REQUEST_INVALID = "E_ADVISORY_CONTEXT_REQUEST_IN
 export const E_ADVISORY_CONTEXT_RESULT_INVALID = "E_ADVISORY_CONTEXT_RESULT_INVALID";
 export const E_ADVISORY_CONTEXT_TIMEOUT = "E_ADVISORY_CONTEXT_TIMEOUT";
 export const E_ADVISORY_CONTEXT_OUTPUT_LIMIT = "E_ADVISORY_CONTEXT_OUTPUT_LIMIT";
+export const E_BROWSER_VERIFICATION_PROVIDER_INVALID = "E_BROWSER_VERIFICATION_PROVIDER_INVALID";
+export const E_BROWSER_VERIFICATION_PROVIDER_UNAVAILABLE = "E_BROWSER_VERIFICATION_PROVIDER_UNAVAILABLE";
+export const E_BROWSER_VERIFICATION_REQUEST_INVALID = "E_BROWSER_VERIFICATION_REQUEST_INVALID";
+export const E_BROWSER_VERIFICATION_RESULT_INVALID = "E_BROWSER_VERIFICATION_RESULT_INVALID";
+export const E_BROWSER_VERIFICATION_TIMEOUT = "E_BROWSER_VERIFICATION_TIMEOUT";
+export const E_BROWSER_VERIFICATION_OUTPUT_LIMIT = "E_BROWSER_VERIFICATION_OUTPUT_LIMIT";
+export const E_BROWSER_VERIFICATION_ORIGIN_DENIED = "E_BROWSER_VERIFICATION_ORIGIN_DENIED";
+export const E_BROWSER_VERIFICATION_EXECUTION_FAILED = "E_BROWSER_VERIFICATION_EXECUTION_FAILED";
+export const E_BROWSER_VERIFICATION_CANCELLED = "E_BROWSER_VERIFICATION_CANCELLED";
+export const E_BROWSER_VERIFICATION_VERSION_UNSUPPORTED = "E_BROWSER_VERIFICATION_VERSION_UNSUPPORTED";
+export const E_SECURITY_REVIEW_PROVIDER_INVALID = "E_SECURITY_REVIEW_PROVIDER_INVALID";
+export const E_SECURITY_REVIEW_PROVIDER_UNAVAILABLE = "E_SECURITY_REVIEW_PROVIDER_UNAVAILABLE";
+export const E_SECURITY_REVIEW_REQUEST_INVALID = "E_SECURITY_REVIEW_REQUEST_INVALID";
+export const E_SECURITY_REVIEW_RESULT_INVALID = "E_SECURITY_REVIEW_RESULT_INVALID";
+export const E_SECURITY_REVIEW_TIMEOUT = "E_SECURITY_REVIEW_TIMEOUT";
+export const E_SECURITY_REVIEW_CANCELLED = "E_SECURITY_REVIEW_CANCELLED";
+export const E_SECURITY_REVIEW_OUTPUT_LIMIT = "E_SECURITY_REVIEW_OUTPUT_LIMIT";
+export const E_SECURITY_REVIEW_EXECUTION_FAILED = "E_SECURITY_REVIEW_EXECUTION_FAILED";
 export const E_PORTABLE_CONTEXT_INVALID = "E_PORTABLE_CONTEXT_INVALID";
 export const E_HANDOFF_ACCEPTANCE_UNBOUND = "E_HANDOFF_ACCEPTANCE_UNBOUND";
 export const E_HANDOFF_STALE = "E_HANDOFF_STALE";
 export const E_HANDOFF_ALREADY_ACCEPTED = "E_HANDOFF_ALREADY_ACCEPTED";
 export const E_HANDOFF_ACCEPTANCE_INCONSISTENT = "E_HANDOFF_ACCEPTANCE_INCONSISTENT";
+export const E_DECISION_ENGINE_UNAVAILABLE = "E_DECISION_ENGINE_UNAVAILABLE";
+export const E_DECISION_ENGINE_AUTH_REQUIRED = "E_DECISION_ENGINE_AUTH_REQUIRED";
+export const E_DECISION_ENGINE_AUTH_INVALID = "E_DECISION_ENGINE_AUTH_INVALID";
+export const E_DECISION_MODEL_UNSUPPORTED = "E_DECISION_MODEL_UNSUPPORTED";
+export const E_DECISION_REQUEST_INVALID = "E_DECISION_REQUEST_INVALID";
+export const E_DECISION_RESULT_INVALID = "E_DECISION_RESULT_INVALID";
+export const E_DECISION_TIMEOUT = "E_DECISION_TIMEOUT";
+export const E_DECISION_RATE_LIMITED = "E_DECISION_RATE_LIMITED";
+export const E_DECISION_STATE_UNSAFE = "E_DECISION_STATE_UNSAFE";
+export const E_DECISION_STATE_LIMIT = "E_DECISION_STATE_LIMIT";
+export const E_DECISION_LOW_CONFIDENCE = "E_DECISION_LOW_CONFIDENCE";
+export const E_DECISION_STALE = "E_DECISION_STALE";
+export const E_DECISION_POLICY_INVALID = "E_DECISION_POLICY_INVALID";
+export const E_DECISION_CACHE_INVALID = "E_DECISION_CACHE_INVALID";
+export const E_DECISION_QUESTION_SET_UNKNOWN = "E_DECISION_QUESTION_SET_UNKNOWN";
+export const E_DECISION_QUESTION_SET_STALE = "E_DECISION_QUESTION_SET_STALE";
+export const E_DECISION_REQUIRED = "E_DECISION_REQUIRED";
 
 const STRUCTURAL_QUALITY_ERROR_METADATA = Object.freeze(Object.fromEntries([
   [E_STRUCTURAL_QUALITY_CONFIGURATION_INVALID, "Correct structuralQuality mode, provider ID, budgets, floors, or optimization limits in .forgeloop/config.json."],
@@ -243,6 +278,14 @@ 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_CONTRACT_BOOTSTRAP_INCONSISTENT = "E_CONTRACT_BOOTSTRAP_INCONSISTENT";
+export const E_CONTRACT_BOOTSTRAP_REPAIR_AVAILABLE = "E_CONTRACT_BOOTSTRAP_REPAIR_AVAILABLE";
+export const E_CONTRACT_BOOTSTRAP_REPAIR_INVALID = "E_CONTRACT_BOOTSTRAP_REPAIR_INVALID";
+export const E_CONTRACT_BOOTSTRAP_REPAIR_UNSAFE = "E_CONTRACT_BOOTSTRAP_REPAIR_UNSAFE";
+export const E_CONTRACT_BOOTSTRAP_REPAIR_AUTHORIZATION_REQUIRED = "E_CONTRACT_BOOTSTRAP_REPAIR_AUTHORIZATION_REQUIRED";
+export const E_CONTRACT_BOOTSTRAP_REPAIR_MIGRATION_AVAILABLE = "E_CONTRACT_BOOTSTRAP_REPAIR_MIGRATION_AVAILABLE";
+export const E_CONTRACT_BOOTSTRAP_REPAIR_MIGRATION_INVALID = "E_CONTRACT_BOOTSTRAP_REPAIR_MIGRATION_INVALID";
+export const E_CONTRACT_BOOTSTRAP_REPAIR_MIGRATION_AUTHORIZATION_REQUIRED = "E_CONTRACT_BOOTSTRAP_REPAIR_MIGRATION_AUTHORIZATION_REQUIRED";
 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";
@@ -251,6 +294,11 @@ 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_ABANDON_AUTHORIZATION_REQUIRED = "E_TASK_ABANDON_AUTHORIZATION_REQUIRED";
+export const E_TASK_ABANDON_INVALID_STATE = "E_TASK_ABANDON_INVALID_STATE";
+export const E_TASK_ABANDON_INCONSISTENT = "E_TASK_ABANDON_INCONSISTENT";
+export const E_TASK_ALREADY_ABANDONED = "E_TASK_ALREADY_ABANDONED";
+export const E_TASK_ABANDON_UNSAFE = "E_TASK_ABANDON_UNSAFE";
 export const E_TASK_MIGRATION_IDENTITY_MISMATCH = "E_TASK_MIGRATION_IDENTITY_MISMATCH";
 export const E_PROTOCOL_MIGRATION_TARGET_UNSUPPORTED = "E_PROTOCOL_MIGRATION_TARGET_UNSUPPORTED";
 
@@ -287,6 +335,7 @@ export const E_RECONCILE_REQUIREMENT_UNKNOWN = "E_RECONCILE_REQUIREMENT_UNKNOWN"
 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_CHECKPOINT_REVALIDATION_UNSAFE = "E_CHECKPOINT_REVALIDATION_UNSAFE";
 
 export const E_ACTION_INVALID = "E_ACTION_INVALID";
 export const E_ACTION_NOT_FOUND = "E_ACTION_NOT_FOUND";
@@ -366,6 +415,132 @@ const ADVISORY_CONTEXT_AND_HANDOFF_ERROR_METADATA = Object.freeze(Object.fromEnt
     meaning: "Advisory context output exceeded the configured character or item limit.",
     safeResolution: "Reduce query scope, limit items, or truncate oversized summaries at the provider.",
   })],
+  [E_BROWSER_VERIFICATION_PROVIDER_INVALID, Object.freeze({
+    code: E_BROWSER_VERIFICATION_PROVIDER_INVALID,
+    category: "browser-verification",
+    classification: "PUBLIC_STABLE",
+    meaning: "Browser verification provider configuration or interface implementation is invalid.",
+    safeResolution: "Use a provider implementing id, verify(input) with the documented browser-verification contract; verification is optional.",
+  })],
+  [E_BROWSER_VERIFICATION_PROVIDER_UNAVAILABLE, Object.freeze({
+    code: E_BROWSER_VERIFICATION_PROVIDER_UNAVAILABLE,
+    category: "browser-verification",
+    classification: "PUBLIC_STABLE",
+    meaning: "Requested browser verification provider is not registered in runtime context.",
+    safeResolution: "Register the provider in runtime context before verify, or proceed without browser verification; provider failure never blocks canonical lifecycle.",
+  })],
+  [E_BROWSER_VERIFICATION_REQUEST_INVALID, Object.freeze({
+    code: E_BROWSER_VERIFICATION_REQUEST_INVALID,
+    category: "browser-verification",
+    classification: "PUBLIC_STABLE",
+    meaning: "Browser verification request failed validation or exceeded budget.",
+    safeResolution: "Provide a bounded request with 1-8 https origins, 1-64 steps, 1-64 assertions, and timeoutMs within limits.",
+  })],
+  [E_BROWSER_VERIFICATION_RESULT_INVALID, Object.freeze({
+    code: E_BROWSER_VERIFICATION_RESULT_INVALID,
+    category: "browser-verification",
+    classification: "PUBLIC_STABLE",
+    meaning: "Browser verification provider returned an invalid result structure.",
+    safeResolution: "Ensure provider returns a status with bounded assertions, diagnostics, and artifacts, and no authority fields.",
+  })],
+  [E_BROWSER_VERIFICATION_TIMEOUT, Object.freeze({
+    code: E_BROWSER_VERIFICATION_TIMEOUT,
+    category: "browser-verification",
+    classification: "PUBLIC_STABLE",
+    meaning: "Browser verification exceeded its execution timeout.",
+    safeResolution: "Use a responsive provider or increase timeout within limits; verification is optional.",
+  })],
+  [E_BROWSER_VERIFICATION_OUTPUT_LIMIT, Object.freeze({
+    code: E_BROWSER_VERIFICATION_OUTPUT_LIMIT,
+    category: "browser-verification",
+    classification: "PUBLIC_STABLE",
+    meaning: "Browser verification output exceeded the configured character or item limit.",
+    safeResolution: "Reduce steps, assertions, snapshots, diagnostics, or artifacts at the provider.",
+  })],
+  [E_BROWSER_VERIFICATION_ORIGIN_DENIED, Object.freeze({
+    code: E_BROWSER_VERIFICATION_ORIGIN_DENIED,
+    category: "browser-verification",
+    classification: "PUBLIC_STABLE",
+    meaning: "Browser verification navigation left the request origin allowlist.",
+    safeResolution: "Add the intended origin to allowedOrigins or correct the provider navigation result.",
+  })],
+  [E_BROWSER_VERIFICATION_EXECUTION_FAILED, Object.freeze({
+    code: E_BROWSER_VERIFICATION_EXECUTION_FAILED,
+    category: "browser-verification",
+    classification: "PUBLIC_STABLE",
+    meaning: "The optional browser provider process failed without establishing a valid observation.",
+    safeResolution: "Inspect the host-provided browser executable and retry; process success is not verification success.",
+  })],
+  [E_BROWSER_VERIFICATION_CANCELLED, Object.freeze({
+    code: E_BROWSER_VERIFICATION_CANCELLED,
+    category: "browser-verification",
+    classification: "PUBLIC_STABLE",
+    meaning: "Browser verification was cancelled by its caller before a valid observation completed.",
+    safeResolution: "Retry only when the caller still requires the optional observation.",
+  })],
+  [E_BROWSER_VERIFICATION_VERSION_UNSUPPORTED, Object.freeze({
+    code: E_BROWSER_VERIFICATION_VERSION_UNSUPPORTED,
+    category: "browser-verification",
+    classification: "PUBLIC_STABLE",
+    meaning: "The configured Agent Browser version does not satisfy the provider's exact version contract.",
+    safeResolution: "Provide the expected host-qualified Agent Browser version or update the explicit executable selection.",
+  })],
+  [E_SECURITY_REVIEW_PROVIDER_INVALID, Object.freeze({
+    code: E_SECURITY_REVIEW_PROVIDER_INVALID,
+    category: "security-review",
+    classification: "PUBLIC_STABLE",
+    meaning: "Security review provider configuration or interface implementation is invalid.",
+    safeResolution: "Use a provider implementing id and review(input) through the explicit host-injected Integration API.",
+  })],
+  [E_SECURITY_REVIEW_PROVIDER_UNAVAILABLE, Object.freeze({
+    code: E_SECURITY_REVIEW_PROVIDER_UNAVAILABLE,
+    category: "security-review",
+    classification: "PUBLIC_STABLE",
+    meaning: "The requested security review provider is not registered in runtime context.",
+    safeResolution: "Register an optional host-owned provider before explicit invocation; ForgeLoop never installs one.",
+  })],
+  [E_SECURITY_REVIEW_REQUEST_INVALID, Object.freeze({
+    code: E_SECURITY_REVIEW_REQUEST_INVALID,
+    category: "security-review",
+    classification: "PUBLIC_STABLE",
+    meaning: "The bounded security review request failed validation.",
+    safeResolution: "Provide explicit scope, bounded project-relative paths, categories, requirements, identities, and timeout.",
+  })],
+  [E_SECURITY_REVIEW_RESULT_INVALID, Object.freeze({
+    code: E_SECURITY_REVIEW_RESULT_INVALID,
+    category: "security-review",
+    classification: "PUBLIC_STABLE",
+    meaning: "The security review provider returned malformed or contradictory findings.",
+    safeResolution: "Return only bounded findings and diagnostics without authority, lifecycle, evidence, or executable fields.",
+  })],
+  [E_SECURITY_REVIEW_TIMEOUT, Object.freeze({
+    code: E_SECURITY_REVIEW_TIMEOUT,
+    category: "security-review",
+    classification: "PUBLIC_STABLE",
+    meaning: "Security review provider execution exceeded the shared deadline.",
+    safeResolution: "Use a responsive provider or a bounded timeout within the supported limit; timed-out output is discarded.",
+  })],
+  [E_SECURITY_REVIEW_CANCELLED, Object.freeze({
+    code: E_SECURITY_REVIEW_CANCELLED,
+    category: "security-review",
+    classification: "PUBLIC_STABLE",
+    meaning: "Security review provider execution was cancelled before a valid observation completed.",
+    safeResolution: "Retry only when the caller still requires the optional observation.",
+  })],
+  [E_SECURITY_REVIEW_OUTPUT_LIMIT, Object.freeze({
+    code: E_SECURITY_REVIEW_OUTPUT_LIMIT,
+    category: "security-review",
+    classification: "PUBLIC_STABLE",
+    meaning: "Security review provider output exceeded the bounded result limits.",
+    safeResolution: "Reduce findings, diagnostics, strings, or result size at the provider.",
+  })],
+  [E_SECURITY_REVIEW_EXECUTION_FAILED, Object.freeze({
+    code: E_SECURITY_REVIEW_EXECUTION_FAILED,
+    category: "security-review",
+    classification: "PUBLIC_STABLE",
+    meaning: "The optional security review provider failed without producing a valid observation.",
+    safeResolution: "Inspect the host-provided provider and retry explicitly; provider failure never changes ForgeLoop state.",
+  })],
   [E_PORTABLE_CONTEXT_INVALID, Object.freeze({
     code: E_PORTABLE_CONTEXT_INVALID,
     category: "portable-context",
@@ -574,6 +749,27 @@ export const PUBLIC_ERROR_CODES = Object.freeze({
     meaning: "Referenced gate artifact changed after approval.",
     safeResolution: "Update artifact SHA-256 in gate file.",
   }),
+  E_GATE_NOT_REQUIRED: Object.freeze({
+    code: "E_GATE_NOT_REQUIRED",
+    category: "preflight",
+    classification: "PUBLIC_STABLE",
+    meaning: "Requested gate is not required by the active route or policy.",
+    safeResolution: "Inspect the active route and record only a required gate.",
+  }),
+  E_GATE_INVALID: Object.freeze({
+    code: "E_GATE_INVALID",
+    category: "preflight",
+    classification: "PUBLIC_STABLE",
+    meaning: "Gate input or evidence artifact is invalid or unsafe.",
+    safeResolution: "Use project-relative regular artifact paths and valid gate evidence.",
+  }),
+  E_PHASE_FREEZE: Object.freeze({
+    code: "E_PHASE_FREEZE",
+    category: "lifecycle",
+    classification: "PUBLIC_STABLE",
+    meaning: "The requested gate mutation is forbidden after execution begins.",
+    safeResolution: "Record required gates before entering EXECUTING.",
+  }),
   E_VERIFICATION_TOOL_UNAVAILABLE: Object.freeze({
     code: "E_VERIFICATION_TOOL_UNAVAILABLE",
     category: "capability",
@@ -700,6 +896,14 @@ export const PUBLIC_ERROR_CODES = Object.freeze({
     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_CONTRACT_BOOTSTRAP_INCONSISTENT: Object.freeze({ code: "E_CONTRACT_BOOTSTRAP_INCONSISTENT", category: "recovery", classification: "PUBLIC_STABLE", meaning: "Contract bootstrap evidence is inconsistent and cannot be treated as a normal idempotent checkpoint.", safeResolution: "Inspect the task ledger and use the exact official contract bootstrap repair only when next recommends it." }),
+  E_CONTRACT_BOOTSTRAP_REPAIR_AVAILABLE: Object.freeze({ code: "E_CONTRACT_BOOTSTRAP_REPAIR_AVAILABLE", category: "recovery", classification: "PUBLIC_STABLE", meaning: "The exact recognized contract bootstrap defect has an official append-only repair path.", safeResolution: "Run forgeloop task-repair-contract-bootstrap --task <id> --acknowledge-repair." }),
+  E_CONTRACT_BOOTSTRAP_REPAIR_INVALID: Object.freeze({ code: "E_CONTRACT_BOOTSTRAP_REPAIR_INVALID", category: "recovery", classification: "PUBLIC_STABLE", meaning: "The contract bootstrap repair marker or its bound artifacts are invalid or tampered.", safeResolution: "Restore the original artifacts from trusted evidence; ForgeLoop refuses to guess or rewrite history." }),
+  E_CONTRACT_BOOTSTRAP_REPAIR_UNSAFE: Object.freeze({ code: "E_CONTRACT_BOOTSTRAP_REPAIR_UNSAFE", category: "recovery", classification: "PUBLIC_STABLE", meaning: "The historical contract bootstrap defect does not satisfy the narrow repair safety boundary.", safeResolution: "Do not force repair; resolve the ledger inconsistency through a separately reviewed migration." }),
+  E_CONTRACT_BOOTSTRAP_REPAIR_AUTHORIZATION_REQUIRED: Object.freeze({ code: "E_CONTRACT_BOOTSTRAP_REPAIR_AUTHORIZATION_REQUIRED", category: "authority", classification: "PUBLIC_STABLE", meaning: "The official contract bootstrap repair requires explicit caller acknowledgement.", safeResolution: "Re-run with --acknowledge-repair after reviewing next and the exact defect signature." }),
+  E_CONTRACT_BOOTSTRAP_REPAIR_MIGRATION_AVAILABLE: Object.freeze({ code: "E_CONTRACT_BOOTSTRAP_REPAIR_MIGRATION_AVAILABLE", category: "recovery", classification: "PUBLIC_STABLE", meaning: "The exact legacy contract bootstrap repair marker has an official append-only migration path.", safeResolution: "Run forgeloop task-migrate-contract-bootstrap-repair --task <id> --acknowledge-migration." }),
+  E_CONTRACT_BOOTSTRAP_REPAIR_MIGRATION_INVALID: Object.freeze({ code: "E_CONTRACT_BOOTSTRAP_REPAIR_MIGRATION_INVALID", category: "recovery", classification: "PUBLIC_STABLE", meaning: "Legacy contract bootstrap repair migration was refused because its exact marker, state, route, lock, or ledger boundary could not be proven.", safeResolution: "Inspect the structured migration errors; ambiguous or progressed historical ledgers remain inconsistent and are never rewritten." }),
+  E_CONTRACT_BOOTSTRAP_REPAIR_MIGRATION_AUTHORIZATION_REQUIRED: Object.freeze({ code: "E_CONTRACT_BOOTSTRAP_REPAIR_MIGRATION_AUTHORIZATION_REQUIRED", category: "authority", classification: "PUBLIC_STABLE", meaning: "The legacy contract bootstrap repair migration requires fresh explicit caller acknowledgement.", safeResolution: "Re-run with --acknowledge-migration after reviewing next and the exact legacy marker boundary." }),
   E_LEGACY_RECOVERY_MIGRATION_INVALID: Object.freeze({
     code: "E_LEGACY_RECOVERY_MIGRATION_INVALID",
     category: "recovery",
@@ -763,6 +967,41 @@ export const PUBLIC_ERROR_CODES = Object.freeze({
     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_ABANDON_AUTHORIZATION_REQUIRED: Object.freeze({
+    code: "E_TASK_ABANDON_AUTHORIZATION_REQUIRED",
+    category: "recovery",
+    classification: "PUBLIC_STABLE",
+    meaning: "task-abandon requires explicit caller acknowledgement and never grants completion or publication authority.",
+    safeResolution: "Re-run task-abandon with --acknowledge-abandonment after confirming the explicit task identity and intended claim release.",
+  }),
+  E_TASK_ABANDON_INVALID_STATE: Object.freeze({
+    code: "E_TASK_ABANDON_INVALID_STATE",
+    category: "recovery",
+    classification: "PUBLIC_STABLE",
+    meaning: "The selected task is terminal or otherwise not eligible for explicit active-task abandonment.",
+    safeResolution: "Inspect task-show and next; only a valid non-terminal active task may be explicitly abandoned.",
+  }),
+  E_TASK_ABANDON_INCONSISTENT: Object.freeze({
+    code: "E_TASK_ABANDON_INCONSISTENT",
+    category: "recovery",
+    classification: "PUBLIC_STABLE",
+    meaning: "Explicit abandonment was refused because canonical ownership or append-only ledger evidence is inconsistent.",
+    safeResolution: "Repair and validate the task descriptor, recovery artifact, and ledger through their dedicated protocol paths before retrying.",
+  }),
+  E_TASK_ALREADY_ABANDONED: Object.freeze({
+    code: "E_TASK_ALREADY_ABANDONED",
+    category: "recovery",
+    classification: "PUBLIC_STABLE",
+    meaning: "The task already has an active explicit-abandonment recovery boundary.",
+    safeResolution: "Inspect the existing recovery state; use task-resume only when explicit reacquisition is intended.",
+  }),
+  E_TASK_ABANDON_UNSAFE: Object.freeze({
+    code: "E_TASK_ABANDON_UNSAFE",
+    category: "concurrency",
+    classification: "PUBLIC_STABLE",
+    meaning: "Task identity, lifecycle revision, ledger boundary, or claim ownership changed during explicit abandonment.",
+    safeResolution: "Re-inspect the task and retry only after the competing mutation has settled; never force claim release.",
+  }),
   E_TASK_SCOPE_DIRTY: Object.freeze({
     code: "E_TASK_SCOPE_DIRTY",
     category: "scope",
@@ -788,8 +1027,8 @@ export const PUBLIC_ERROR_CODES = Object.freeze({
     code: "E_RECONCILE_PHASE_INVALID",
     category: "lifecycle",
     classification: "PUBLIC_STABLE",
-    meaning: "reconcile-closure was invoked for a task that is not EXECUTING or VERIFYING.",
-    safeResolution: "reconcile-closure supports EXECUTING or VERIFYING tasks whose objective is already satisfied.",
+    meaning: "reconcile-closure was invoked for a task that is not EXECUTING, VERIFYING, or REVIEWING.",
+    safeResolution: "reconcile-closure supports EXECUTING, VERIFYING, or REVIEWING tasks whose objective is already satisfied.",
   }),
   E_RECONCILE_UNSUPPORTED_DRIFT: Object.freeze({
     code: "E_RECONCILE_UNSUPPORTED_DRIFT",
@@ -831,7 +1070,14 @@ export const PUBLIC_ERROR_CODES = Object.freeze({
     category: "freshness",
     classification: "PUBLIC_STABLE",
     meaning: "The work-state checkpoint must be revalidated before the lifecycle can continue.",
-    safeResolution: "Run forgeloop reconcile-closure for externally satisfied EXECUTING tasks, or inspect the freshness reasons for other drift.",
+    safeResolution: "Run forgeloop reconcile-closure for externally satisfied EXECUTING, VERIFYING, or REVIEWING tasks, or inspect the freshness reasons for other drift.",
+  }),
+  E_CHECKPOINT_REVALIDATION_UNSAFE: Object.freeze({
+    code: "E_CHECKPOINT_REVALIDATION_UNSAFE",
+    category: "freshness",
+    classification: "PUBLIC_STABLE",
+    meaning: "A pre-execution checkpoint could not be safely rebound to the current repository without changing lifecycle identity.",
+    safeResolution: "Preserve the checkpoint and resolve the reported contract, route, ownership, artifact, or lifecycle boundary through its canonical command.",
   }),
   E_DIAGNOSIS_REQUIRED: Object.freeze({
     code: "E_DIAGNOSIS_REQUIRED",
@@ -1392,12 +1638,21 @@ export const ALL_KNOWN_ERROR_CODES = Object.freeze(new Set([
   E_RECONCILE_EVIDENCE_FAILED,
   E_REPOSITORY_CHANGED,
   E_STATE_REVALIDATION_REQUIRED,
+  E_CHECKPOINT_REVALIDATION_UNSAFE,
   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_CONTRACT_BOOTSTRAP_INCONSISTENT,
+  E_CONTRACT_BOOTSTRAP_REPAIR_AVAILABLE,
+  E_CONTRACT_BOOTSTRAP_REPAIR_INVALID,
+  E_CONTRACT_BOOTSTRAP_REPAIR_UNSAFE,
+  E_CONTRACT_BOOTSTRAP_REPAIR_AUTHORIZATION_REQUIRED,
+  E_CONTRACT_BOOTSTRAP_REPAIR_MIGRATION_AVAILABLE,
+  E_CONTRACT_BOOTSTRAP_REPAIR_MIGRATION_INVALID,
+  E_CONTRACT_BOOTSTRAP_REPAIR_MIGRATION_AUTHORIZATION_REQUIRED,
   E_COMPLETION_OWNERSHIP_UNPROVEN,
   E_TASK_CLAIM_OWNERSHIP_INCONSISTENT,
   E_TASK_RECOVERY_AUTHORIZATION_REQUIRED,
@@ -1406,6 +1661,11 @@ export const ALL_KNOWN_ERROR_CODES = Object.freeze(new Set([
   E_TASK_NOT_RECOVERED,
   E_TASK_RECOVERY_OFFICIAL_PATH_AVAILABLE,
   E_TASK_ALREADY_RECOVERED,
+  E_TASK_ABANDON_AUTHORIZATION_REQUIRED,
+  E_TASK_ABANDON_INVALID_STATE,
+  E_TASK_ABANDON_INCONSISTENT,
+  E_TASK_ALREADY_ABANDONED,
+  E_TASK_ABANDON_UNSAFE,
   E_TASK_MIGRATION_IDENTITY_MISMATCH,
   E_PROTOCOL_MIGRATION_TARGET_UNSUPPORTED,
   E_CHECK_INERT,
@@ -1508,6 +1768,24 @@ export const ALL_KNOWN_ERROR_CODES = Object.freeze(new Set([
   E_ADVISORY_CONTEXT_RESULT_INVALID,
   E_ADVISORY_CONTEXT_TIMEOUT,
   E_ADVISORY_CONTEXT_OUTPUT_LIMIT,
+  E_BROWSER_VERIFICATION_PROVIDER_INVALID,
+  E_BROWSER_VERIFICATION_PROVIDER_UNAVAILABLE,
+  E_BROWSER_VERIFICATION_REQUEST_INVALID,
+  E_BROWSER_VERIFICATION_RESULT_INVALID,
+  E_BROWSER_VERIFICATION_TIMEOUT,
+  E_BROWSER_VERIFICATION_OUTPUT_LIMIT,
+  E_BROWSER_VERIFICATION_ORIGIN_DENIED,
+  E_BROWSER_VERIFICATION_EXECUTION_FAILED,
+  E_BROWSER_VERIFICATION_CANCELLED,
+  E_BROWSER_VERIFICATION_VERSION_UNSUPPORTED,
+  E_SECURITY_REVIEW_PROVIDER_INVALID,
+  E_SECURITY_REVIEW_PROVIDER_UNAVAILABLE,
+  E_SECURITY_REVIEW_REQUEST_INVALID,
+  E_SECURITY_REVIEW_RESULT_INVALID,
+  E_SECURITY_REVIEW_TIMEOUT,
+  E_SECURITY_REVIEW_CANCELLED,
+  E_SECURITY_REVIEW_OUTPUT_LIMIT,
+  E_SECURITY_REVIEW_EXECUTION_FAILED,
   E_PORTABLE_CONTEXT_INVALID,
   E_HANDOFF_ACCEPTANCE_UNBOUND,
   E_HANDOFF_STALE,