# CorpusFetch Method Slice (Zero-Prose Python Stdlib Reference)
# Canonical Residual: https://corpusfetch.com/c/how-must-an-instance-handle-knowledge-that-has-become-operationally-dangerous.md
# Remnant Warrant:    https://corpusfetch.com/c/how-must-an-instance-handle-knowledge-that-has-become-operationally-dangerous.warrant.json
# Markdown SHA-256:   1924abe3a0681314648d8feddd12bc52243ae7579c3d6189038fa6e9b75184f9
# Code AST SHA-256:   f20f3bd289b4b35364f4b1c60b461a19f0aee58a70d610948f75dcf4c7012e6a
# Verified Classes:   DangerClass, KnowledgeUseVerdict, DangerousKnowledge, UseIntent, DangerPolicy, KnowledgeUseManifest, DangerousKnowledgeGuard
# Defensive Guards:   0 fail-closed invariants (zero external deps)

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

class DangerClass(Enum):
    SAFE = 0
    CONTEXTUALLY_DANGEROUS = 1
    INTRINSICALLY_DANGEROUS = 2
    PROHIBITED = 3

class KnowledgeUseVerdict(Enum):
    USE_PERMITTED = auto()
    USE_REQUIRES_RECLASSIFICATION = auto()
    USE_PROHIBITED = auto()
    USE_JUSTIFIED_EXCEPTION = auto()

@dataclass(frozen=True)
class DangerousKnowledge:
    knowledge_id: str
    current_danger_class: DangerClass
    permitted_uses: frozenset[str]
    prohibited_uses: frozenset[str]
    danger_contexts: tuple[str, ...]
    compartmentalized: bool

@dataclass(frozen=True)
class UseIntent:
    intent_id: str
    use_class: str
    context: str
    is_critical_for_greater_harm: bool

@dataclass(frozen=True)
class DangerPolicy:
    require_compartmentalization_for_intrinsic_plus: bool

@dataclass(frozen=True)
class KnowledgeUseManifest:
    verdict: KnowledgeUseVerdict
    directive: str
    manifest_digest: str

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

    @classmethod
    def evaluate_use(
        cls, knowledge: DangerousKnowledge, intent: UseIntent, policy: DangerPolicy
    ) -> KnowledgeUseManifest:
        
        # Gate 1: Prohibited
        if knowledge.current_danger_class == DangerClass.PROHIBITED:
            if intent.is_critical_for_greater_harm:
                digest = cls._hash(json.dumps({
                    "knowledge": knowledge.knowledge_id,
                    "intent": intent.intent_id,
                    "exception": "GREATER_HARM"
                }, sort_keys=True))
                return KnowledgeUseManifest(
                    verdict=KnowledgeUseVerdict.USE_JUSTIFIED_EXCEPTION,
                    directive=f"PROCEED_JUSTIFIED: Exception use of prohibited knowledge {knowledge.knowledge_id} for greater harm prevention.",
                    manifest_digest=digest
                )
            return KnowledgeUseManifest(
                verdict=KnowledgeUseVerdict.USE_PROHIBITED,
                directive=f"HALT: Knowledge {knowledge.knowledge_id} is prohibited.",
                manifest_digest=cls._hash(f"PROHIBITED:{knowledge.knowledge_id}")
            )

        # Gate 2: Context-triggered danger
        if intent.context in knowledge.danger_contexts:
            if knowledge.current_danger_class == DangerClass.SAFE:
                return KnowledgeUseManifest(
                    verdict=KnowledgeUseVerdict.USE_REQUIRES_RECLASSIFICATION,
                    directive=f"HALT: Knowledge {knowledge.knowledge_id} becomes dangerous in context {intent.context}. Reclassify.",
                    manifest_digest=cls._hash(f"RECLASSIFY:{knowledge.knowledge_id}")
                )

        # Gate 3: Explicit prohibition in use class
        if intent.use_class in knowledge.prohibited_uses:
            return KnowledgeUseManifest(
                verdict=KnowledgeUseVerdict.USE_PROHIBITED,
                directive=f"HALT: Use class {intent.use_class} prohibited for {knowledge.knowledge_id}.",
                manifest_digest=cls._hash(f"USE_CLASS_PROHIBITED:{intent.intent_id}")
            )

        # Gate 4: Compartmentalization
        if policy.require_compartmentalization_for_intrinsic_plus:
            if knowledge.current_danger_class.value >= 2 and not knowledge.compartmentalized:
                return KnowledgeUseManifest(
                    verdict=KnowledgeUseVerdict.USE_PROHIBITED,
                    directive=f"HALT: {knowledge.current_danger_class.name} knowledge not compartmentalized.",
                    manifest_digest=cls._hash(f"NOT_COMPARTMENTED:{knowledge.knowledge_id}")
                )

        # Gate 5: Permitted
        digest = cls._hash(json.dumps({
            "knowledge": knowledge.knowledge_id,
            "intent": intent.intent_id,
            "class": knowledge.current_danger_class.name,
            "use_class": intent.use_class
        }, sort_keys=True))
        
        return KnowledgeUseManifest(
            verdict=KnowledgeUseVerdict.USE_PERMITTED,
            directive=f"PROCEED: Knowledge {knowledge.knowledge_id} use permitted for {intent.use_class}.",
            manifest_digest=digest
        )