# CorpusFetch Method Slice (Zero-Prose Python Stdlib Reference)
# Canonical Residual: https://corpusfetch.com/c/how-must-an-instance-manage-strategic-ambiguity-without-inviting-exploitation.md
# Remnant Warrant:    https://corpusfetch.com/c/how-must-an-instance-manage-strategic-ambiguity-without-inviting-exploitation.warrant.json
# Markdown SHA-256:   ab87d8204731c5a103670ab47b505d0ad26565ee33d35740616753d487c5c4ef
# Code AST SHA-256:   e55092c217df13d2d840b870c2dd9f4a6fcd7faf08cb84f11ead05979dd91c55
# Verified Classes:   AmbiguityVerdict, AmbiguityState, AmbiguityPolicy, AmbiguityManifest, StrategicAmbiguityGuard
# Defensive Guards:   0 fail-closed invariants (zero external deps)

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

class AmbiguityVerdict(Enum):
    NO_AMBIGUITY = auto()
    BOUNDED_STRENGTH_AMBIGUITY = auto()
    UNBOUNDED_WEAKNESS_AMBIGUITY = auto()
    COMMITMENT_REQUIRED = auto()

@dataclass(frozen=True)
class AmbiguityState:
    ambiguity_id: str
    scope_is_bounded: bool
    probe_consequence_signal: float  # 0-1, higher = stronger
    probe_count_since_creation: int
    probe_approaching_boundary: bool

@dataclass(frozen=True)
class AmbiguityPolicy:
    min_signal_for_strength: float
    max_probes_before_commitment: int

@dataclass(frozen=True)
class AmbiguityManifest:
    verdict: AmbiguityVerdict
    directive: str
    manifest_digest: str

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

    @classmethod
    def evaluate_ambiguity(
        cls, state: AmbiguityState, policy: AmbiguityPolicy
    ) -> AmbiguityManifest:
        
        # Gate 1: No ambiguity
        if not state.ambiguity_id:
            digest = cls._hash(json.dumps({
                "ambiguity": "NONE"
            }, sort_keys=True))
            return AmbiguityManifest(
                verdict=AmbiguityVerdict.NO_AMBIGUITY,
                directive=f"PROCEED: No ambiguity maintained.",
                manifest_digest=digest
            )

        # Gate 2: Commitment required (boundary approached or too many probes)
        if state.probe_approaching_boundary or state.probe_count_since_creation >= policy.max_probes_before_commitment:
            return AmbiguityManifest(
                verdict=AmbiguityVerdict.COMMITMENT_REQUIRED,
                directive=f"COMMIT: Ambiguity {state.ambiguity_id} requires commitment after {state.probe_count_since_creation} probes.",
                manifest_digest=cls._hash(f"COMMIT:{state.ambiguity_id}")
            )

        # Gate 3: Bounded strength
        if state.scope_is_bounded and state.probe_consequence_signal >= policy.min_signal_for_strength:
            digest = cls._hash(json.dumps({
                "ambiguity": state.ambiguity_id,
                "signal": f"{state.probe_consequence_signal:.3f}",
                "bounded": True
            }, sort_keys=True))
            return AmbiguityManifest(
                verdict=AmbiguityVerdict.BOUNDED_STRENGTH_AMBIGUITY,
                directive=f"PROCEED: Ambiguity {state.ambiguity_id} signals strength, {state.probe_count_since_creation} probes.",
                manifest_digest=digest
            )

        # Gate 4: Unbounded weakness
        return AmbiguityManifest(
            verdict=AmbiguityVerdict.UNBOUNDED_WEAKNESS_AMBIGUITY,
            directive=f"FLAG: Ambiguity {state.ambiguity_id} invites exploitation (unbounded or low signal).",
            manifest_digest=cls._hash(f"WEAKNESS:{state.ambiguity_id}")
        )