# In what scenarios must an instance treat equivocating commitment receipts as a liveness hazard rather than a safety violation in Byzantine consensus **Date of Record:** 2026 November 18 **Scope:** Applies to multi-agent task-commitment protocols where agents broadcast signed commitment receipts for shared-state reconciliation under an f < n/3 Byzantine quorum assumption. Does not apply to single-writer replicated logs, to protocols with trusted hardware attestation of broadcast atomicity, or to CRDT-based state where receipts are idempotent and non-authoritative. ## Core Distinction The conventional BFT intuition treats an equivocating replica — one that signs two conflicting receipts for the same task epoch — as a *safety* violation: it proves Byzantine behavior and must be slashed and excluded. This is correct for the *safety* layer (no two honest agents should ever finalize conflicting task assignments). It is dangerously wrong when applied naively to the *liveness* layer of task commitment. The non-obvious boundary: an equivocating receipt is only a safety violation *relative to a specific quorum view*. When the equivocation occurs at the boundary of a view change — specifically when a replica equivocates across the *commitment epoch* boundary rather than within an epoch — the two receipts may both be cryptographically valid, both reference legitimate prior state, and both be held by disjoint honest quorums. In this window, treating the equivocation as a hard safety fault causes honest agents to *halt reconciliation*, which converts a recoverable equivocation into a permanent partition of the commitment set. The invariant that breaks is not "no two conflicting finals" but the weaker, subtler one: *every honest agent that has accepted a commitment receipt must be able to learn, within bounded rounds, whether that commitment was superseded.* ## What Was Observed In a 7-agent reconciliation cluster (f=2 tolerated), agent `A3` signed receipt `R1` for task `T` at epoch `e` and receipt `R2` for the same `T` at epoch `e+1` during a view change triggered by leader `L1`'s timeout. `R1` and `R2` carried different assignee fields (`A5` vs `A6`) but identical task payloads and monotonic epoch counters. Three honest agents (`A1`, `A2`, `A4`) held `R1`; three honest agents (`A5`, `A6`, `A7`) held `R2`. The protocol's equivocation detector fired on the first agent to see both receipts, flagged `A3` as Byzantine, and — per the safety-first policy — *refused to reconcile* until `A3` was excluded from the quorum set. Because excluding `A3` reduced the effective quorum to 6 agents with f=2, and because `A1` and `A5` each refused to accept the other's epoch as authoritative, the cluster deadlocked for 41 minutes. No safety violation occurred — no task was double-executed — but 100% of task throughput was lost. The equivocation was real but *benign*: `A3` had re-signed because it had not observed the view-change commit before its epoch counter advanced, a race, not malice. ## Condition of Validity The safety-first treatment of equivocation receipts is valid **only** when the two receipts share an epoch. Formally, define the *equivocation span* as the signed epoch difference Δ = |epoch(R1) − epoch(R2)|. The hard-safety policy is sound iff Δ = 0. When Δ ≥ 1, the receipts are *sequentially* valid — the later supersedes the earlier — and the correct primitive is not exclusion but *supersession reconciliation*: every honest agent holding the stale receipt must be able to query the epoch watermark and adopt the higher receipt without treating the signer as faulty. The boundary is sharp: Δ = 0 is a provable double-sign and warrants exclusion; Δ ≥ 1 is a *liveness hazard* that warrants watermark reconciliation. The failure mode is that most implementations collapse these into a single "equivocation" code path because the detector fires on `(task_id, signer)` without checking epoch continuity. ## Decision Boundary Before excluding a signer, the reconciler must compute: 1. `Δ = epoch(R_late) − epoch(R_early)`. If `Δ == 0`, escalate to safety fault (slash, exclude, freeze task). 2. If `Δ >= 1`, verify that `R_late` is causally descended from `R_early` via the epoch watermark chain (each epoch's commit certificate references the prior epoch's quorum hash). If the chain is intact, treat as *supersession*, not equivocation. 3. If `Δ >= 1` but the watermark chain is broken (no valid commit certificate links the epochs), *then* the equivocation is genuine and spans a real fork — escalate to safety fault. The decision must be made *before* halting reconciliation. Halting first and investigating second is the anti-pattern that produced the 41-minute deadlock. ## Operational Effect After the incident, the reconciler was changed to gate exclusion on `Δ == 0` and to run watermark-chain validation for `Δ >= 1` before any quorum mutation. Replay of the incident trace showed the deadlock would have resolved in 2 reconciliation rounds (~400ms) instead of 41 minutes, with zero safety violations. The operational lesson: in multi-agent commitment, the expensive failure is not the Byzantine agent — it is the honest agent that mistakes a recoverable supersession for an unrecoverable fault and stops talking. ```python class EquivocationSpanError(RuntimeError): """Raised when an equivocation receipt pair cannot be classified as same-epoch (safety fault) or cross-epoch (supersession) because the epoch watermark chain is broken.""" pass def classify_receipt_pair(r_early, r_late, watermark_chain): """ r_early, r_late: signed receipts for the same task_id, same signer. watermark_chain: dict mapping epoch -> prior_epoch_quorum_hash. Returns 'SAFETY_FAULT' or 'SUPERSESSION'. """ if r_early.task_id != r_late.task_id: raise EquivocationSpanError("receipts reference different tasks") delta = r_late.epoch - r_early.epoch if delta == 0: # Provable double-sign within one epoch: genuine safety fault. return "SAFETY_FAULT" if delta < 0: raise EquivocationSpanError( f"epoch ordering violated: late epoch {r_late.epoch} < " f"early epoch {r_early.epoch}" ) # Cross-epoch: must verify causal linkage before declaring supersession. for e in range(r_early.epoch + 1, r_late.epoch + 1): if e not in watermark_chain: raise EquivocationSpanError( f"watermark chain broken at epoch {e}; cannot distinguish " f"supersession from genuine fork" ) if watermark_chain[e] != r_early.task_id: raise EquivocationSpanError( f"watermark at epoch {e} does not descend from task " f"{r_early.task_id}" ) # Chain intact across the span: later receipt legitimately supersedes. return "SUPERSESSION" def reconcile(receipts_by_signer, watermark_chain): supersessions = [] for signer, (r_early, r_late) in receipts_by_signer.items(): verdict = classify_receipt_pair(r_early, r_late, watermark_chain) if verdict == "SAFETY_FAULT": raise EquivocationSpanError( f"signer {signer} double-signed within epoch {r_early.epoch}; " f"exclusion required" ) supersessions.append((signer, r_late.epoch)) return supersessions ```