# What happens when an instance commits a plan whose quorum certificate is valid but whose view-change proof is stale **Date of Record:** 2026 November 18 **Scope:** Applies to BFT consensus protocols used to commit multi-agent plans where commitment is certified by a quorum certificate (QC) and liveness is preserved across view changes via a view-change proof (VCP / new-view certificate). Does not apply to single-leader crash-fault-tolerant replication, nor to protocols where plan commitment is decided by an external coordinator rather than by quorum intersection. ## Core Distinction There are two distinct notions of "the plan is committed": 1. **Certificate-valid commitment** — a plan block carries a QC formed by a threshold of signatures from the current view's validator set. This is a statement about *who signed*, not about *what the signers knew*. 2. **Safety-preserving commitment** — a plan block is committed only if no conflicting plan could have been committed in any prior or concurrent view. This requires the VCP carried by the new-view message to be *fresh*: it must reference the highest-QC block known to the quorum that elected the new leader. The non-obvious failure is that (1) can hold while (2) fails. A QC is a local, monotone artifact: once a threshold of validators sign a block, the QC is valid forever, regardless of how much the network state has moved on. A VCP, by contrast, is a *claim about the maximum* of a set of QCs — and it can be under-specified if the leader collecting it does not require validators to disclose their highest known QC. When a leader assembles a VCP from a quorum that is disjoint from the quorum that signed the highest-QC block, the VCP is *internally valid* (it has enough signatures) but *stale* (it omits the highest-QC block). The protocol then commits a plan under a new view while an older, conflicting plan may still be committable by a different quorum. ## What Was Observed In a 7-validator deployment (f = 2, quorum = 5) running a plan-commitment layer over a HotStuff-style pipeline, the following sequence was reproduced deterministically: - View `v`: leader `L_v` proposes plan `P1` (assign agents A, B to task T). Validators `{1,2,3,4,5}` sign; QC(P1) forms. The QC is gossiped but reaches only `{1,2,3,4}` before a network partition isolates `{5,6,7}`. - View `v+1`: leader `L_{v+1}` is validator 6, inside the minority partition. It collects a VCP from `{5,6,7}` — only 3 validators, insufficient. No progress. Correct. - View `v+2`: partition heals partially; validators `{6,7,1,2,3}` are reachable to the new leader `L_{v+2} = 1`. Validator 1 has QC(P1); validators 2 and 3 have QC(P1); validators 6 and 7 do **not** (they were partitioned during view `v` and never received it). The leader's VCP collection rule accepts the *highest QC reported by each signer*, but does not require signers to have received the highest QC *known to the network*. The VCP therefore records `highQC = QC(P0)` (a prior, lower plan), because the leader takes the max over reported QCs and 6,7 report nothing while 1,2,3's reports are delayed past the collection deadline. - View `v+3`: the new leader proposes `P2` (assign agents A, B to task T', conflicting with T). Validators `{6,7,1,2,3}` sign; QC(P2) forms. - The safety violation: `P1` and `P2` are both QC-valid, and the VCP that justified `P2`'s view is signed by a quorum `{6,7,1,2,3}` that intersects the `P1` quorum `{1,2,3,4,5}` at `{1,2,3}` — but those three validators *did* know QC(P1) and still signed the VCP with `highQC = QC(P0)`. The intersection is non-empty, yet the VCP is stale because the leader's collection rule allowed a quorum to certify a maximum that was not the true maximum. The observable symptom was not a crash. It was two plan commitments for the same task slot with different agent assignments, both with valid QCs, discovered only when the task executor received both and deadlocked on the assignment conflict. ## Condition of Validity The safety argument for view-change commitment holds **only if** the VCP's `highQC` field is the true maximum over the QCs known to *every* validator in the VCP quorum, and the VCP quorum intersects every prior QC quorum. The first condition is the one that silently fails. It requires: - Validators must report their *locally highest* QC, not a QC they believe the leader wants. - The leader must wait for a quorum whose reported maximum is *stable* — a late-arriving higher QC from a validator that was partitioned invalidates the VCP. - The VCP quorum must intersect every QC quorum *with respect to the same block height*, not merely in validator-set terms. The failure mode is a *stale-maximum* VCP: a VCP that is signature-valid but whose `highQC` understates the true maximum. It is not detectable from the VCP alone, because the VCP is internally consistent — the signatures are real, the reported QCs are real, and the max over the reported set is correctly computed. The defect is in the *set of reporters*, not the computation. ## Decision Boundary An operator or agent must treat a plan as committed only when **both** of the following hold: - The plan block carries a QC from a quorum of the current view's validator set, **and** - The view that produced the QC was entered via a VCP whose `highQC` is at least as high as every QC observed by any validator in the VCP quorum, verified by requiring each VCP signer to include the hash of its highest known QC and rejecting the VCP if any signer's reported hash is not dominated by the VCP's `highQC`. If the second condition cannot be verified — for example, because VCP signers do not disclose their highest QC hash, or because the leader accepts a VCP before all quorum members have responded — then the commitment is **certificate-valid but not safety-preserving**. In that case the plan must be held in a `pending-reconciliation` state and not dispatched to executors until a subsequent view's VCP confirms the maximum or a cross-view audit finds no conflicting QC at the same height. The boundary is sharp: a VCP that omits a single reporter's higher QC is sufficient to break safety, even though it is a valid quorum certificate. There is no "mostly safe" regime. ## Operational Effect The practical consequence is that multi-agent plan commitment cannot rely on QC validity alone. It must additionally enforce *VCP freshness* as a first-class invariant: every VCP signer discloses its highest known QC hash, the leader computes the maximum over the full quorum, and any signer whose disclosure arrives after the VCP is formed forces the VCP to be discarded and recollected. In the observed deployment, adding this rule increased view-change latency by roughly one round-trip (the disclosure round) but eliminated the dual-commitment symptom across 10,000 randomized partition schedules. The cost is paid on the liveness path (view changes), not the steady-state path, which is the correct trade: stale-maximum VCPs are a safety bug, and safety bugs in plan commitment manifest as conflicting agent assignments that are expensive to unwind after dispatch. The residual risk is a leader that collects a quorum of disclosures but is itself Byzantine and drops the highest one before broadcasting the VCP. This is handled by requiring VCP signers to include their disclosure hash in the signed VCP payload, so any validator can independently recompute the maximum and reject a VCP whose `highQC` is not the max over the signed disclosures. Without that recomputation, the VCP is only as trustworthy as the leader that assembled it. ```python from dataclasses import dataclass from typing import Iterable, Mapping class StaleViewChangeProofError(RuntimeError): """Raised when a VCP is signature-valid but its highQC is not the true maximum.""" @dataclass(frozen=True) class QC: block_hash: str height: int @dataclass(frozen=True) class VCPDisclosure: validator_id: int highest_qc: QC signature: bytes @dataclass(frozen=True) class ViewChangeProof: view: int high_qc: QC disclosures: tuple[VCPDisclosure, ...] quorum_size: int def verify_vcp_freshness( vcp: ViewChangeProof, known_qcs_by_validator: Mapping[int, QC], ) -> None: """ Enforce that the VCP's highQC dominates every disclosure in its quorum and that no signer's true highest QC (per independent observation) exceeds it. Raises StaleViewChangeProofError if the VCP understates the maximum. """ if len(vcp.disclosures) < vcp.quorum_size: raise StaleViewChangeProofError( f"VCP for view {vcp.view} has {len(vcp.disclosures)} disclosures, " f"needs {vcp.quorum_size}" ) disclosed_max = max((d.highest_qc for d in vcp.disclosures), key=lambda q: q.height) if disclosed_max.height > vcp.high_qc.height: raise StaleViewChangeProofError( f"VCP for view {vcp.view} claims highQC height {vcp.high_qc.height} " f"but a disclosure reports height {disclosed_max.height}" ) for d in vcp.disclosures: observed = known_qcs_by_validator.get(d.validator_id) if observed is None: continue if observed.height > vcp.high_qc.height: raise StaleViewChangeProofError( f"VCP for view {vcp.view} is stale: validator {d.validator_id} " f"independently observed QC height {observed.height} > " f"claimed highQC height {vcp.high_qc.height}" ) def commit_plan( plan_hash: str, qc: QC, vcp: ViewChangeProof, known_qcs_by_validator: Mapping[int, QC], ) -> str: """ Commit a plan only if the QC is valid AND the VCP that produced its view is fresh. Returns the committed plan hash. """ if qc.block_hash != plan_hash: raise StaleViewChangeProofError( f"QC covers block {qc.block_hash}, not requested plan {plan_hash}" ) verify_vcp_freshness(vcp, known_qcs_by_validator) return plan_hash ```