How must an instance handle reference propagation across a network partition?

**Date of Record:** 2026 October 27 **Scope:** Applies when an agentic mesh experiences a network partition, and references propagated before the partition continue to propagate within each partition, but cross-partition propagation stops, leading to divergent reference state between partitions. Does not apply to strictly partitioned meshes by design (no cross-partition references) or meshes with global partition-tolerant consensus.

Core Distinction

The separation between **partition-local reference state** (each partition's view of references) and **post-partition reconciliation** (how the partitions reconcile divergent reference states when the partition heals). Relying on local state creates the **Partition Divergent Reference Split**: Partition A has references 1-10, Partition B has references 1-5 plus 11-15 (originated in B during the partition). When the partition heals, references 11-15 must be reconciled, and any references revoked in A during the partition must be honored in B.

What Was Observed

In partition-prone agent meshes, failing to handle reference propagation during partitions produces three primary failure modes:

  1. **Orphaned References:** References originated in Partition B during the partition are unknown to A. When the partition heals, A treats them as new, but they may conflict with references originated in A during the same time.
  2. **Revocation Divergence:** A reference is revoked in A during the partition, but B continues using it. When the partition heals, B's actions based on the revoked reference are auditable but invalid.
  3. **Propagation Storm:** Upon healing, both partitions flood the mesh with their divergent reference states, overwhelming reconciliation mechanisms, and the reconciliation itself becomes a source of new divergence.

Recorded Elements

  1. **`partition_epoch_signature`:** The exact epoch when the partition was detected, so references can be classified as pre-partition (shared) or during-partition (partition-local).
  2. **`partition_local_reference_manifest_receipt`:** For each partition, the cryptographic proof of references originated or modified during the partition, distinct from pre-partition state.
  3. **`partition_reconciliation_protocol_signature`:** The exact protocol for reconciling divergent partitions when healed (e.g., "A wins for pre-partition refs, union for during-partition refs with conflict resolution").
  4. **`post_partition_convergence_receipt`:** After reconciliation, the cryptographic proof that both partitions have converged to the same reference state.

Condition of Validity

* **Applies when:** The mesh can experience network partitions, references propagate across partitions, and partition healing requires reconciliation. * **Does not apply when:** The mesh is strictly partitioned by design (partitions never heal or references never cross), or the mesh has partition-tolerant consensus that handles convergence automatically.

Decision Boundary

  1. **Has a partition been detected?** If no, standard propagation applies. If yes, proceed.
  2. **Are references being originated or modified during the partition?** If no, references are static and healing is trivial. If yes, they must be tracked as partition-local.
  3. **Is a `partition_reconciliation_protocol_signature` defined?** If no, healing will cause uncontrolled divergence. The mesh must define reconciliation before partition heals.
  4. **Conversely, when can a mesh heal without reconciliation protocol?** Only when no partition-local references were originated (identical state in all partitions) or the reconciliation is trivial (strict A-wins or B-wins).

Operational Effect

  1. **Orphaned Reference Resolution:** Partition-local references are tracked and reconciled on healing.
  2. **Revocation Propagation:** Revocations from before the partition are reapplied to divergent partition state.
  3. **Controlled Convergence:** Reconciliation protocol prevents propagation storms on healing.
from dataclasses import dataclass
from enum import Enum, auto
import hashlib
import json

class PartitionVerdict(Enum):
    NO_PARTITION = auto()
    PARTITION_ACTIVE = auto()
    RECONCILIATION_READY = auto()
    RECONCILIATION_REQUIRED = auto()

@dataclass(frozen=True)
class PartitionedMesh:
    partition_a_id: str
    partition_b_id: str
    references_before_partition: frozenset[str]
    references_in_a_during: frozenset[str]
    references_in_b_during: frozenset[str]
    revocations_in_a_during: frozenset[str]
    reconciliation_protocol: str | None

@dataclass(frozen=True)
class PartitionPolicy:
    require_reconciliation_protocol: bool

@dataclass(frozen=True)
class PartitionManifest:
    verdict: PartitionVerdict
    directive: str
    manifest_digest: str

class PartitionReferenceGuard:
    @staticmethod
    def _hash(data: str) -> str:
        return hashlib.sha256(data.encode("utf-8")).hexdigest()

    @classmethod
    def evaluate_partition(
        cls, mesh: PartitionedMesh, policy: PartitionPolicy
    ) -> PartitionManifest:
        
        # Gate 1: No partition
        if not mesh.references_in_a_during and not mesh.references_in_b_during and not mesh.revocations_in_a_during:
            digest = cls._hash(json.dumps({
                "refs": tuple(sorted(mesh.references_before_partition)),
                "status": "NO_DIVERGENCE"
            }, sort_keys=True))
            return PartitionManifest(
                verdict=PartitionVerdict.NO_PARTITION,
                directive=f"PROCEED: No partition-divergent references.",
                manifest_digest=digest
            )

        # Gate 2: Protocol presence
        if policy.require_reconciliation_protocol and not mesh.reconciliation_protocol:
            return PartitionManifest(
                verdict=PartitionVerdict.RECONCILIATION_REQUIRED,
                directive=f"HALT: Partition-divergent references exist without reconciliation protocol.",
                manifest_digest=cls._hash("NO_PROTOCOL")
            )

        # Gate 3: Partition active (reconciliation not yet performed)
        if mesh.reconciliation_protocol and mesh.references_in_a_during and mesh.references_in_b_during:
            digest = cls._hash(json.dumps({
                "a_refs": tuple(sorted(mesh.references_in_a_during)),
                "b_refs": tuple(sorted(mesh.references_in_b_during)),
                "a_revocations": tuple(sorted(mesh.revocations_in_a_during)),
                "protocol": mesh.reconciliation_protocol
            }, sort_keys=True))
            return PartitionManifest(
                verdict=PartitionVerdict.PARTITION_ACTIVE,
                directive=f"ACTION: Partition active with divergent refs. Reconciliation via {mesh.reconciliation_protocol} when healed.",
                manifest_digest=digest
            )

        # Gate 4: Reconciliation ready
        digest = cls._hash(json.dumps({
            "a_count": str(len(mesh.references_in_a_during)),
            "b_count": str(len(mesh.references_in_b_during)),
            "revocations": str(len(mesh.revocations_in_a_during)),
            "protocol": mesh.reconciliation_protocol
        }, sort_keys=True))
        
        return PartitionManifest(
            verdict=PartitionVerdict.RECONCILIATION_READY,
            directive=f"PROCEED: Partition healed, reconciliation via {mesh.reconciliation_protocol}.",
            manifest_digest=digest
        )