# CorpusFetch Method Slice (Zero-Prose Python Stdlib Reference)
# Canonical Residual: https://corpusfetch.com/c/what-invariants-prevent-sequential-commitment-from-locking-in-suboptimal-paths.md
# Remnant Warrant:    https://corpusfetch.com/c/what-invariants-prevent-sequential-commitment-from-locking-in-suboptimal-paths.warrant.json
# Markdown SHA-256:   8af07fd0400eec8260effb1947a7386b3d56693d8886a2d1eede18287477df7b
# Code AST SHA-256:   6dd04e8aa200b87d5e5828abe7ca918f41d9b30b72248057cfdc5961a41ed00f
# Verified Classes:   SequentialCommitmentVerdict, CommitmentStep, SequentialPolicy, SequentialManifest, SequentialCommitmentGuard
# Defensive Guards:   0 fail-closed invariants (zero external deps)

from dataclasses import dataclass
from enum import Enum, auto
import hashlib
import json

class SequentialCommitmentVerdict(Enum):
    NO_SEQUENTIAL_COMMITMENT = auto()
    SAFE_COMMITMENT = auto()
    LOCK_IN_RISK = auto()
    DEFER_WARRANTED = auto()

@dataclass(frozen=True)
class CommitmentStep:
    step_id: str
    option_narrowing: float  # 0-1, how much option space is lost
    reversal_cost: float
    information_sufficiency: float  # 0-1
    information_becoming_available_soon: bool

@dataclass(frozen=True)
class SequentialPolicy:
    min_information_for_commitment: float
    max_reversal_cost_acceptable: float

@dataclass(frozen=True)
class SequentialManifest:
    verdict: SequentialCommitmentVerdict
    directive: str
    manifest_digest: str

class SequentialCommitmentGuard:
    @staticmethod
    def _hash(data: str) -> str:
        return hashlib.sha256(data.encode("utf-8")).hexdigest()

    @classmethod
    def evaluate_step(
        cls, step: CommitmentStep, policy: SequentialPolicy
    ) -> SequentialManifest:
        
        # Gate 1: No commitment
        if not step.step_id:
            digest = cls._hash(json.dumps({
                "step": "NONE"
            }, sort_keys=True))
            return SequentialManifest(
                verdict=SequentialCommitmentVerdict.NO_SEQUENTIAL_COMMITMENT,
                directive=f"PROCEED: No sequential commitment to evaluate.",
                manifest_digest=digest
            )

        # Gate 2: Sufficient information
        if step.information_sufficiency >= policy.min_information_for_commitment:
            digest = cls._hash(json.dumps({
                "step": step.step_id,
                "info": f"{step.information_sufficiency:.3f}",
                "narrowing": f"{step.option_narrowing:.3f}"
            }, sort_keys=True))
            return SequentialManifest(
                verdict=SequentialCommitmentVerdict.SAFE_COMMITMENT,
                directive=f"COMMIT: Step {step.step_id} with sufficient info.",
                manifest_digest=digest
            )

        # Gate 3: Deferrable information
        if step.information_becoming_available_soon:
            return SequentialManifest(
                verdict=SequentialCommitmentVerdict.DEFER_WARRANTED,
                directive=f"DEFER: Information for {step.step_id} available soon.",
                manifest_digest=cls._hash(f"DEFER:{step.step_id}")
            )

        # Gate 4: Lock-in risk
        if step.reversal_cost > policy.max_reversal_cost_acceptable:
            return SequentialManifest(
                verdict=SequentialCommitmentVerdict.LOCK_IN_RISK,
                directive=f"FLAG: Step {step.step_id} costly to reverse ({step.reversal_cost:.2f}) with low info.",
                manifest_digest=cls._hash(f"LOCK_IN:{step.step_id}")
            )

        # Gate 5: Safe commitment despite low info
        digest = cls._hash(json.dumps({
            "step": step.step_id,
            "info": f"{step.information_sufficiency:.3f}",
            "reversal": f"{step.reversal_cost:.3f}"
        }, sort_keys=True))
        
        return SequentialManifest(
            verdict=SequentialCommitmentVerdict.SAFE_COMMITMENT,
            directive=f"COMMIT_WITH_CAUTION: Step {step.step_id} low info but reversal cheap.",
            manifest_digest=digest
        )