# Where must an instance halt when a federated audit trail cannot reconcile a replayed message against its originating policy epoch **Date of Record:** 2026 November 17 **Scope:** Applies to cross-org multi-agent federations where each outbound message carries a signed policy-epoch reference from the sender's policy store and is admitted by the receiver only if the referenced epoch is still reconcilable against the receiver's local audit ledger. Does not apply to single-org deployments, to stateless request/response gateways without audit reconciliation, or to federations where policy epochs are immutable and never garbage-collected. ## Core Distinction The non-obvious boundary is not "message rejected vs. message accepted." It is the distinction between a message that is *policy-valid at send time* and a message that is *audit-reconcilable at receive time*. These are different invariants enforced by different parties at different clocks. A sender agent, when it emits a message, stamps it with `(policy_id, epoch_id, epoch_digest, issued_at)`. The epoch is the sender's current policy version governing that message class. The receiver's admission gate checks that `epoch_id` exists in the receiver's replicated view of the sender's policy history and that `epoch_digest` matches. If the sender rotates or retires an epoch (e.g., due to a policy change, a key rotation, or a compaction of its audit log), a message in flight — or a message being replayed by a retry path — can be *perfectly valid at send time* yet *unreconcilable at receive time*. The receiver cannot prove the message was authorized under any policy it can still see. The naive resolution is "trust the signature; the sender signed it." That collapses the audit invariant. The audit trail's purpose is that a third party, later, can reconstruct *why* a message was permitted. A signature proves *who* sent it, not *under what rule* it was permitted. Once the originating epoch is gone, the "why" is unrecoverable, and the message becomes an orphan in the audit graph. ## What Was Observed In a three-org federation (sender A, broker B, receiver C), A's policy store performed a scheduled epoch compaction at 02:00 UTC, retiring epochs older than 72 hours and re-signing the surviving history under a new Merkle root. A's agent had a retry queue with a 90-minute backoff. A policy change at 23:50 UTC caused A to rotate to epoch `E-1041`; a batch of messages stamped `E-1040` was still in the retry queue. At 02:00 the compaction retired `E-1040` from A's published history (it was within the 72h window only by minutes; a clock skew on the compaction scheduler treated it as expired). Receiver C received the replayed `E-1040` messages at 02:14. Signature verification passed. Epoch lookup failed: `E-1040` was absent from A's published history. C's admission gate — correctly, by its own contract — held the messages in a quarantine state rather than admitting or dropping them, because neither action was provably correct: admitting them would create audit entries referencing a nonexistent epoch; dropping them would lose messages that A's own logs showed as authorized. The quarantine grew unbounded because no reconciliation path existed. Three hours later C's quarantine ledger hit its size cap and the admission gate began rejecting *all* traffic from A, including current-epoch messages, because the cap was enforced at the federation-peer level rather than the epoch level. The failure was not the compaction, nor the retry, nor the quarantine. It was the absence of a defined *halt-and-escalate* boundary: the receiver had a policy for "epoch present" and "epoch absent," but no policy for "epoch was present and is now retired, and the message claims to predate the retirement." That third state is the boundary. ## Condition of Validity The invariant "a message admitted by the receiver is audit-reconcilable" holds only while the following condition is satisfied: > For every message the receiver admits, the referenced `(policy_id, epoch_id)` must be resolvable in the receiver's replicated policy history at admission time, **and** the receiver must be able to distinguish "never existed" from "existed and was retired within the message's declared validity window." The second clause is the one that is routinely omitted. Implementations that store only the *current* epoch set satisfy the first clause but not the second. When the second clause is violated, the receiver cannot distinguish a forged epoch reference from a legitimately retired one, and any automated decision it makes is a guess. The condition also requires that the sender's declared validity window (`issued_at + ttl`) be bounded by the sender's epoch retention floor. If `ttl > retention_floor`, the sender is emitting messages that can outlive their own auditability. This is a *sender-side* invariant that the receiver cannot enforce and must therefore be negotiated at federation onboarding. ## Decision Boundary When a receiver encounters a message whose epoch is unresolvable, the correct decision depends on whether the receiver can establish *retirement* vs. *nonexistence*: - **Epoch resolvable and digest matches** → admit, write audit entry, continue. - **Epoch resolvable, digest mismatch** → reject, flag as tampering, do not quarantine. - **Epoch absent, but receiver holds a signed retirement record** (sender publishes retirement tombstones with the compaction Merkle root) **and message `issued_at` falls within the retired epoch's active window** → this is the halt state. Do not admit, do not silently drop. Escalate to a human-owned reconciliation queue with a bounded deadline. If the deadline expires without operator resolution, the message is *archived as unreconcilable* with an explicit audit annotation — never admitted, never deleted. - **Epoch absent and no retirement record exists** → reject as unverifiable; treat as potential forgery. The halt state must be *peer-scoped and epoch-scoped*, never federation-scoped. A single unreconcilable epoch must not be able to take down admission for the entire peer. The observed incident failed precisely here: the quarantine cap was enforced at the wrong granularity. ## Operational Effect Federations that implement the halt-and-escalate boundary observe three effects. First, retry queues must be bounded by the sender's epoch retention floor, which forces a cross-org SLA negotiation that is usually missing from initial federation contracts. Second, retirement tombstones become a first-class artifact: the sender must publish, alongside each epoch, a signed record of *when* it was retired and *what window* it covered, and retain those tombstones at least as long as the maximum message TTL across all peers. Third, the audit graph gains a well-defined "unreconcilable" edge type, which is what allows a later third-party auditor to distinguish "this message was authorized and we can prove it" from "this message was authorized and the proof has aged out" from "this message was never authorized." The cost is that the receiver must carry state for retired epochs it never used, and the sender must retain tombstones it would prefer to compact away. The benefit is that the federation never enters the state where a peer's admission gate is making decisions it cannot justify — which is the only state from which an audit trail is worthless. ```python from dataclasses import dataclass from enum import Enum class EpochReconciliationError(RuntimeError): """Raised when a federated message cannot be reconciled against its originating policy epoch.""" pass class Resolution(Enum): ADMIT = "admit" REJECT_TAMPER = "reject_tamper" REJECT_UNVERIFIABLE = "reject_unverifiable" HALT_ESCALATE = "halt_escalate" @dataclass(frozen=True) class Message: policy_id: str epoch_id: str epoch_digest: str issued_at: float ttl: float @dataclass(frozen=True) class Tombstone: epoch_id: str retired_at: float active_window: tuple[float, float] class FederationAdmissionGate: def __init__(self, live_epochs: dict[str, str], tombstones: dict[str, Tombstone]): self._live = live_epochs # epoch_id -> digest self._tombstones = tombstones # epoch_id -> retirement record def classify(self, msg: Message) -> Resolution: if msg.epoch_id in self._live: if self._live[msg.epoch_id] != msg.epoch_digest: return Resolution.REJECT_TAMPER return Resolution.ADMIT tomb = self._tombstones.get(msg.epoch_id) if tomb is None: # Absent with no retirement record: cannot prove it ever existed. return Resolution.REJECT_UNVERIFIABLE start, end = tomb.active_window if start <= msg.issued_at <= end and msg.issued_at + msg.ttl > tomb.retired_at: # Existed, was retired, and the message's declared validity outlived # the epoch's auditable window. This is the halt state. return Resolution.HALT_ESCALATE # Retired, but the message was fully inside the auditable window at send time. return Resolution.REJECT_UNVERIFIABLE def admit(self, msg: Message) -> None: resolution = self.classify(msg) if resolution is Resolution.ADMIT: return if resolution is Resolution.HALT_ESCALATE: raise EpochReconciliationError( f"epoch {msg.epoch_id} retired at {self._tombstones[msg.epoch_id].retired_at} " f"but message issued at {msg.issued_at} with ttl {msg.ttl} outlives auditability; " f"escalate to reconciliation queue, do not admit or drop" ) raise EpochReconciliationError( f"epoch {msg.epoch_id} resolution={resolution.value}; message not admissible" ) ```