# CorpusFetch Method Slice (Zero-Prose Python Stdlib Reference)
# Canonical Residual: https://corpusfetch.com/c/how-must-an-instance-attribute-multi-agent-contributions-to-a-single-factual-conclusion.md
# Remnant Warrant:    https://corpusfetch.com/c/how-must-an-instance-attribute-multi-agent-contributions-to-a-single-factual-conclusion.warrant.json
# Markdown SHA-256:   30c4d63c2aae06936ea722ee9b39b2cb11a198cf9e5ecb7feeee65a7cb382fea
# Code AST SHA-256:   223656c1f0323975e367a0a2e9c3ac1ed2051d8a1d6ab9ae4e778b702fb29748
# Verified Classes:   AttributionVerdict, Contribution, AttributionContext, AttributionManifest, ContributionAttributionGuard
# Defensive Guards:   0 fail-closed invariants (zero external deps)

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

class AttributionVerdict(Enum):
    ATTRIBUTION_VERIFIED = auto()
    MISSING_ATTRIBUTION = auto()
    NON_INDEPENDENT_VERIFICATION = auto()

@dataclass(frozen=True)
class Contribution:
    agent_id: str
    contribution_type: str  # "EVIDENCE", "REASONING", "VERIFICATION"
    payload_hash: str
    depends_on: frozenset[str]

@dataclass(frozen=True)
class AttributionContext:
    independent_verifiers: frozenset[str]
    required_min_verifiers: int

@dataclass(frozen=True)
class AttributionManifest:
    verdict: AttributionVerdict
    contributors: tuple[str, ...]
    directive: str
    manifest_digest: str

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

    @classmethod
    def evaluate_attribution(
        cls, contributions: tuple[Contribution, ...], ctx: AttributionContext
    ) -> AttributionManifest:
        
        if not contributions:
            return AttributionManifest(
                verdict=AttributionVerdict.MISSING_ATTRIBUTION,
                contributors=tuple(),
                directive="HALT: No contributions recorded. Cannot attribute conclusion.",
                manifest_digest=cls._hash("NO_CONTRIBUTIONS")
            )

        contributor_ids = tuple(sorted({c.agent_id for c in contributions}))

        # Gate 1: Independent verifiers check
        verifiers = {c.agent_id for c in contributions if c.contribution_type == "VERIFICATION"}
        independent = verifiers & ctx.independent_verifiers

        if len(independent) < ctx.required_min_verifiers:
            return AttributionManifest(
                verdict=AttributionVerdict.NON_INDEPENDENT_VERIFICATION,
                contributors=contributor_ids,
                directive=f"HALT: {len(independent)} independent verifiers, minimum required {ctx.required_min_verifiers}.",
                manifest_digest=cls._hash(f"INSUFFICIENT_VERIFIERS:{len(independent)}")
            )

        # Gate 2: Dependency DAG integrity
        all_ids = {c.agent_id for c in contributions}
        for contribution in contributions:
            for dep in contribution.depends_on:
                if dep not in all_ids and dep != contribution.agent_id:
                    return AttributionManifest(
                        verdict=AttributionVerdict.MISSING_ATTRIBUTION,
                        contributors=contributor_ids,
                        directive=f"HALT: Contribution {contribution.agent_id} depends on unknown agent {dep}.",
                        manifest_digest=cls._hash(f"BROKEN_DAG:{contribution.agent_id}")
                    )

        # Gate 3: Verified
        digest = cls._hash(json.dumps({
            "contributors": contributor_ids,
            "verifiers": tuple(sorted(independent)),
            "count": str(len(contributions))
        }, sort_keys=True))
        
        return AttributionManifest(
            verdict=AttributionVerdict.ATTRIBUTION_VERIFIED,
            contributors=contributor_ids,
            directive="PROCEED: Attribution graph is complete and independently verified.",
            manifest_digest=digest
        )