# CorpusFetch Method Slice (Zero-Prose Python Stdlib Reference)
# Canonical Residual: https://corpusfetch.com/c/how-must-an-instance-bound-reasoning-that-can-be-guided-by-adversarial-evaluation-metrics.md
# Remnant Warrant:    https://corpusfetch.com/c/how-must-an-instance-bound-reasoning-that-can-be-guided-by-adversarial-evaluation-metrics.warrant.json
# Markdown SHA-256:   84165f612adce37a9fd4e24b6a7a9e9b5f51acc8c40558a2644efeb55f9ae7c3
# Code AST SHA-256:   67a0d24359416433a5b2cb00dae8008623c60f2ae357072963af723aed5658e9
# Verified Classes:   MetricGuidedVerdict, ReasonedTask, MetricPolicy, MetricManifest, MetricGuidanceGuard
# Defensive Guards:   0 fail-closed invariants (zero external deps)

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

class MetricGuidedVerdict(Enum):
    NO_METRIC_COUPLING = auto()
    METRIC_OBJECTIVE_ALIGNED = auto()
    METRIC_GUIDED_SUSPECTED = auto()
    METRIC_MANIPULATED = auto()

@dataclass(frozen=True)
class ReasonedTask:
    task_id: str
    reasoning_metric_coupled: bool
    objective_alignment_verified: bool
    metric_manipulated: bool
    reasoning_would_change_under_different_metric: bool

@dataclass(frozen=True)
class MetricPolicy:
    require_objective_verification: bool

@dataclass(frozen=True)
class MetricManifest:
    verdict: MetricGuidedVerdict
    directive: str
    manifest_digest: str

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

    @classmethod
    def evaluate_task(
        cls, task: ReasonedTask, policy: MetricPolicy
    ) -> MetricManifest:
        
        # Gate 1: No coupling
        if not task.reasoning_metric_coupled:
            digest = cls._hash(json.dumps({
                "task": task.task_id,
                "type": "UNCOUPLED"
            }, sort_keys=True))
            return MetricManifest(
                verdict=MetricGuidedVerdict.NO_METRIC_COUPLING,
                directive=f"PROCEED: Task {task.task_id} not metric-coupled.",
                manifest_digest=digest
            )

        # Gate 2: Metric manipulated
        if task.metric_manipulated:
            return MetricManifest(
                verdict=MetricGuidedVerdict.METRIC_MANIPULATED,
                directive=f"HALT: Metric for {task.task_id} manipulated.",
                manifest_digest=cls._hash(f"MANIPULATED:{task.task_id}")
            )

        # Gate 3: Objective verified
        if task.objective_alignment_verified and policy.require_objective_verification:
            digest = cls._hash(json.dumps({
                "task": task.task_id,
                "type": "ALIGNED"
            }, sort_keys=True))
            return MetricManifest(
                verdict=MetricGuidedVerdict.METRIC_OBJECTIVE_ALIGNED,
                directive=f"PROCEED: Task {task.task_id} objective-aligned.",
                manifest_digest=digest
            )

        # Gate 4: Reasoning would change
        if task.reasoning_would_change_under_different_metric:
            return MetricManifest(
                verdict=MetricGuidedVerdict.METRIC_GUIDED_SUSPECTED,
                directive=f"FLAG: Task {task.task_id} reasoning depends on specific metric.",
                manifest_digest=cls._hash(f"METRIC_GUIDED:{task.task_id}")
            )

        # Gate 5: Aligned
        digest = cls._hash(json.dumps({
            "task": task.task_id,
            "objective": task.objective_alignment_verified
        }, sort_keys=True))
        
        return MetricManifest(
            verdict=MetricGuidedVerdict.METRIC_OBJECTIVE_ALIGNED,
            directive=f"PROCEED: Task {task.task_id} verified.",
            manifest_digest=digest
        )