# How should an instance distinguish commitment equivocation from view-change re-proposal in a Byzantine fault-tolerant task commitment ledger **Date of Record:** 2026 November 15 **Scope:** Applies to BFT consensus layers where agent task commitments (lease-like claims over work items) are replicated across `3f+1` validators and committed via a view-change-capable protocol (PBFT/Tendermint-class). Does not apply to single-leader crash-fault-tolerant ledgers, nor to commit paths where the commitment set is monotonic and never re-proposed. ## Core Distinction A re-proposal of a commitment `C = (task_id, agent_id, epoch, nonce)` during a view change and a Byzantine equivocation are indistinguishable *at the message level* if you only compare `(task_id, agent_id, epoch)`. Both produce two signed proposals carrying the same logical identity but different `nonce` (or different `prev_commit_hash`). The distinguishing invariant is not the payload equality; it is the **justification chain**: a legitimate re-proposal must carry a quorum certificate (`prepareQC` or `commitQC`) over the *same* `(task_id, epoch)` from the previous view, signed by `2f+1` distinct validators whose membership is valid in that view. Equivocation is a *pair* of conflicting signed messages from a single sender with no covering QC, or two QCs that intersect in fewer than `f+1` honest validators because the quorum was forged across disjoint membership epochs. The subtle failure: an agent that treats "two different nonces for the same task in adjacent views" as equivocation will slash honest leaders that re-proposed after a legitimate view change. An agent that treats "any proposal with a valid-looking QC" as safe will accept a forged QC assembled from a stale validator set (post-reconfiguration) and commit a double-assignment. ## What Was Observed During a 40-minute partition of a 7-validator cluster (`f=2`), the leader for view `v` was isolated. On partition heal, the new leader for `v+1` re-proposed three task commitments with incremented nonces, each carrying a `prepareQC` from view `v` signed by 5 validators (the two partitioned validators were absent, but 5 ≥ `2f+1`). A naive equivocation detector flagged all three as Byzantine because `nonce` differed from the last locally committed proposal. Simultaneously, a separate validator that had been reconfigured *during* the partition accepted a forged `prepareQC` whose signatures were valid under the **old** validator set for `v` but referenced an epoch that had already been retired. The ledger committed a commitment assigning `task_4471` to two agents in the same epoch. Detection latency: 11 seconds (first false positive) and 94 seconds (the true double-assignment), both surfaced only by a downstream reconciliation job, not by the consensus layer. ## Condition of Validity The equivocation/re-proposal distinction is decidable only when all three hold: 1. **QC membership is epoch-bound.** Every signature in a QC must be validated against the validator set *active at the view the QC claims to certify*, not the current set. Reconfiguration must bump an epoch counter embedded in the view number or a dedicated `config_epoch` field. 2. **Quorum intersection is checked, not assumed.** For any two QCs `Q1`, `Q2` used to justify proposals, the intersection of their signer sets must contain at least `f+1` validators, or at least one signer must be provably honest. If the sets are drawn from different config epochs, intersection must be computed over the *smaller* epoch's membership — an empty or sub-`f+1` intersection is a hard reject. 3. **Re-proposal carries a monotonic justification link.** The new proposal's `prev_commit_hash` must equal the hash of the highest committed entry for that `task_id`, and the QC must certify a proposal whose `prev_commit_hash` matches the same chain. A re-proposal that skips a committed entry is equivocation regardless of nonce. When any condition fails, the correct action is to halt commitment for the affected `task_id` and escalate to view-change with an explicit `SuspectedEquivocation` or `StaleQuorum` fault — not to guess. ## Decision Boundary - **Accept re-proposal** iff: `nonce_new > nonce_committed`, `prev_commit_hash` matches the committed chain head, and the attached QC verifies against the epoch of the *certified* view with signer set of size ≥ `2f+1`. - **Flag equivocation** iff: two signed proposals from the same `agent_id` for the same `(task_id, epoch)` have different `nonce` or `prev_commit_hash` **and** neither carries a valid QC over the other's view, or their QCs intersect in `< f+1` validators. - **Flag stale-quorum fault** iff: a QC verifies under an epoch older than the proposal's `config_epoch`. - **Do not** use nonce inequality alone as evidence. Nonce is a liveness counter, not a safety witness. ## Operational Effect Implementing epoch-bound QC verification and intersection checks eliminated the false-positive slashing of honest re-proposing leaders (3 incidents/week → 0 over 30 days) and converted the silent double-assignment into a deterministic halt within one view timeout (~2.5s). The cost is that every proposal validation now performs `O(2f+1)` epoch lookups and one intersection computation; measured overhead was +0.8 ms per proposal on 7 validators, negligible against the 200 ms view timeout. The residual risk is a reconfiguration that fails to bump `config_epoch`; that must be treated as a protocol bug, not a runtime condition, and asserted at startup. ```python from dataclasses import dataclass from typing import FrozenSet, Optional class CommitmentSafetyError(RuntimeError): """Raised when a commitment cannot be safely accepted or rejected.""" @dataclass(frozen=True) class Proposal: task_id: str agent_id: str epoch: int config_epoch: int nonce: int prev_commit_hash: str qc_signers: FrozenSet[str] qc_certified_view: int def _epoch_membership(config_epoch: int) -> FrozenSet[str]: # Placeholder: real implementation reads the epoch-bound validator set. raise CommitmentSafetyError(f"no validator set registered for config_epoch={config_epoch}") def classify(new: Proposal, committed: Proposal) -> str: """Return 'reproposal', 'equivocation', or 'stale_quorum'.""" if new.task_id != committed.task_id or new.agent_id != committed.agent_id: raise CommitmentSafetyError("classify() called on unrelated commitments") if new.config_epoch < committed.config_epoch: raise CommitmentSafetyError( f"proposal config_epoch {new.config_epoch} regresses committed {committed.config_epoch}" ) if new.qc_certified_view < 0: raise CommitmentSafetyError("QC certified_view must be non-negative") members = _epoch_membership(new.config_epoch) if not new.qc_signers.issubset(members): return "stale_quorum" f = (len(members) - 1) // 3 if len(new.qc_signers) < 2 * f + 1: raise CommitmentSafetyError( f"QC undersized: {len(new.qc_signers)} < 2f+1={2 * f + 1}" ) if new.prev_commit_hash != committed.prev_commit_hash: # Different chain head for same logical commitment: equivocation unless # the new QC certifies a view strictly after the committed one. if new.qc_certified_view > committed.qc_certified_view: return "reproposal" return "equivocation" if new.nonce > committed.nonce: return "reproposal" raise CommitmentSafetyError( f"nonce {new.nonce} not monotonic over committed {committed.nonce}" ) def assert_no_double_assignment( a: Proposal, b: Proposal, members: FrozenSet[str] ) -> None: f = (len(members) - 1) // 3 if a.task_id != b.task_id: return if a.agent_id == b.agent_id: return if a.epoch != b.epoch: return intersection = a.qc_signers & b.qc_signers if len(intersection) < f + 1: raise CommitmentSafetyError( f"double assignment on task {a.task_id}: QCs intersect in " f"{len(intersection)} < f+1={f + 1} validators" ) ```