# CorpusFetch Method Slice (Zero-Prose Python Stdlib Reference)
# Canonical Residual: https://corpusfetch.com/c/in-what-scenarios-must-an-instance-refuse-to-commit-a-task-under-partial-byzantine-equivocation-in-multi-agent-shared-state-reconciliation.md
# Remnant Warrant:    https://corpusfetch.com/c/in-what-scenarios-must-an-instance-refuse-to-commit-a-task-under-partial-byzantine-equivocation-in-multi-agent-shared-state-reconciliation.warrant.json
# Markdown SHA-256:   48242b04e8668feadee1b354719ce5096a7d8b1151b687c8a07703cafac9aaa0
# Code AST SHA-256:   3c6e4ba7036b0751035f2d3a5523a0a0efb2e32ff4fbc4a670cd2d565b98ba3b
# Verified Classes:   EquivocationSafetyError, InsufficientQuorumIntersectionError, Certificate
# Defensive Guards:   2 fail-closed invariants (zero external deps)

from dataclasses import dataclass
from typing import Dict, Tuple


class EquivocationSafetyError(RuntimeError):
    """Raised when two conflicting quorum certificates exist for the same (task_id, view)."""
    pass


class InsufficientQuorumIntersectionError(RuntimeError):
    """Raised when quorum intersection cannot guarantee at least one honest agent."""
    pass


@dataclass(frozen=True)
class Certificate:
    task_id: str
    view: int
    payload: str
    signers: frozenset  # agent ids that signed this certificate


def _intersection_ok(a: Certificate, b: Certificate, honest_floor: int = 1) -> bool:
    # Conservative: assume up to f signers in each set may be faulty.
    # Caller supplies honest_floor derived from N and f.
    return len(a.signers & b.signers) >= honest_floor


def reconcile(
    existing: Dict[Tuple[str, int], Certificate],
    incoming: Certificate,
    honest_floor: int,
) -> Certificate:
    """
    Reconcile an incoming certificate against committed state.

    Returns the certificate that should be committed.
    Raises on genuine equivocation or unsound quorum configuration.
    """
    key = (incoming.task_id, incoming.view)

    # Rule 1: same (task_id, view) with differing payload => genuine Byzantine double-sign.
    prior = existing.get(key)
    if prior is not None and prior.payload != incoming.payload:
        raise EquivocationSafetyError(
            f"double-signed slot task={incoming.task_id} view={incoming.view}: "
            f"{prior.payload!r} vs {incoming.payload!r}"
        )

    # Rule 2: find highest-view certificate for this task; must intersect honestly.
    same_task = [c for (t, _), c in existing.items() if t == incoming.task_id]
    if same_task:
        highest = max(same_task, key=lambda c: c.view)
        if incoming.view > highest.view:
            if not _intersection_ok(incoming, highest, honest_floor):
                raise InsufficientQuorumIntersectionError(
                    f"view {incoming.view} quorum does not intersect view "
                    f"{highest.view} quorum in {honest_floor} honest agent(s)"
                )
            return incoming  # highest-view wins, safely
        if incoming.view < highest.view:
            return highest  # stale certificate; ignore incoming
        # equal view, equal payload => idempotent re-delivery
        return prior if prior is not None else incoming

    return incoming
