How must an instance operate when the ground truth itself is being contested?

**Date of Record:** 2026 October 27 **Scope:** Applies when an agentic session depends on a ground truth source (reference data, canonical database, or authoritative record), and the ground truth itself is contested—multiple sources claim to be authoritative, or the source's authority is disputed, so the session cannot determine which truth is actually ground. Does not apply to uncontested ground truth or domains where no authoritative source is expected.

Core Distinction

The separation between **reference to truth** (the session queries a claimed authority) and **resolved truth** (the session knows what is actually true regardless of authority claims). Relying on reference creates the **Contested Ground Truth Paralysis**: the session queries the "authoritative" source, gets an answer, but suspects the source's authority may be disputed, so it neither fully trusts the answer nor has an alternative—stuck in epistemic limbo.

What Was Observed

In contested-authority agent architectures, failing to handle contested ground truth produces three primary failure modes:

  1. **Arbitrary Authority Selection:** The session picks whichever source responds first or is most convenient, and its subsequent actions reflect that arbitrary choice, leading to divergence with peers who picked differently.
  2. **Double Bookkeeping:** The session tracks multiple candidate truths (one per authority), bloating state and eventually confusing its own reasoning.
  3. **Paralysis by Ambiguity:** The session refuses to act on any contested claim, blocking operations that could proceed with clear "this is one version, subject to dispute" framing.

Recorded Elements

  1. **`ground_truth_authority_receipt`:** For each source, its claimed authority (who delegated it, under what jurisdiction, with what consensus), verified to the extent possible, so the session knows the basis for the claim.
  2. **`contest_status_signature`:** The explicit recognition that the ground truth is contested (which parties contest it, on what grounds), so the session's epistemic status is documented.
  3. **`alternative_truth_sources_receipt`:** The catalog of alternative sources, with their claimed authorities and any evidence for/against their claims, so the session can make informed choices.
  4. **`operational_pragmatics_signature`:** The pragmatic decision framework for the current action (which source to use for this specific decision, why, and under what conditions the choice would change), so the session can act despite contestation.

Condition of Validity

* **Applies when:** Ground truth is contested, downstream decisions depend on truth, and the session cannot simply defer all decisions until truth is uncontested. * **Does not apply when:** Ground truth is uncontested, or decisions can be indefinitely deferred.

Decision Boundary

  1. **Is the ground truth contested?** If no, standard ground truth handling applies. If yes, proceed.
  2. **Is `contest_status_signature` recorded?** If yes, the contest is explicit. If no, the session's choice of authority may be naive.
  3. **Does `operational_pragmatics_signature` document the decision framework for the current action?** If yes, the decision is principled. If no, the choice is arbitrary.
  4. **Conversely, when can the session proceed without a contest framework?** Only when the decision is strictly reversible (choice can be revised when contest resolves), or the decision is strictly informational.

Operational Effect

  1. **Arbitrary Choice Prevention:** Authority selection is principled, not convenience-based.
  2. **Epistemic Honesty:** The session's state documents the contestation rather than pretending certainty.
  3. **Action Enablement:** Decisions proceed with explicit awareness of contested status.
from dataclasses import dataclass
from enum import Enum, auto
import hashlib
import json

class ContestedTruthVerdict(Enum):
    UNCONTESTED = auto()
    CONTESTED_PRINCIPLED_CHOICE = auto()
    CONTESTED_ARBITRARY = auto()
    PARALYSIS_AVOIDED = auto()

@dataclass(frozen=True)
class TruthSource:
    source_id: str
    authority_claim: str
    verified_authority: bool
    contest_grounds: tuple[str, ...]

@dataclass(frozen=True)
class ContestedTruthState:
    fact_id: str
    sources: tuple[TruthSource, ...]
    contest_documented: bool
    operational_pragmatics: str | None

@dataclass(frozen=True)
class ContestedTruthPolicy:
    require_pragmatics_for_action: bool

@dataclass(frozen=True)
class ContestedTruthManifest:
    verdict: ContestedTruthVerdict
    directive: str
    manifest_digest: str

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

    @classmethod
    def evaluate_truth(
        cls, state: ContestedTruthState, policy: ContestedTruthPolicy
    ) -> ContestedTruthManifest:
        
        # Gate 1: Uncontested
        contested_sources = [s for s in state.sources if s.contest_grounds]
        if not contested_sources:
            digest = cls._hash(json.dumps({
                "fact": state.fact_id,
                "sources": tuple(s.source_id for s in state.sources)
            }, sort_keys=True))
            return ContestedTruthManifest(
                verdict=ContestedTruthVerdict.UNCONTESTED,
                directive=f"PROCEED: Truth for {state.fact_id} uncontested.",
                manifest_digest=digest
            )

        # Gate 2: Contest documented
        if not state.contest_documented:
            return ContestedTruthManifest(
                verdict=ContestedTruthVerdict.CONTESTED_ARBITRARY,
                directive=f"HALT: Contest undocumented for {state.fact_id}.",
                manifest_digest=cls._hash(f"UNDOCUMENTED:{state.fact_id}")
            )

        # Gate 3: Operational pragmatics
        if policy.require_pragmatics_for_action and not state.operational_pragmatics:
            return ContestedTruthManifest(
                verdict=ContestedTruthVerdict.CONTESTED_ARBITRARY,
                directive=f"HALT: No operational pragmatics for {state.fact_id}, action would be arbitrary.",
                manifest_digest=cls._hash(f"NO_PRAGMATICS:{state.fact_id}")
            )

        # Gate 4: Principled choice
        digest = cls._hash(json.dumps({
            "fact": state.fact_id,
            "sources": tuple(s.source_id for s in state.sources),
            "pragmatics": state.operational_pragmatics,
            "contest_grounds": tuple(
                (s.source_id, s.contest_grounds) for s in contested_sources
            )
        }, sort_keys=True))
        
        return ContestedTruthManifest(
            verdict=ContestedTruthVerdict.CONTESTED_PRINCIPLED_CHOICE,
            directive=f"PROCEED_WITH_DISCLOSURE: Principled choice via {state.operational_pragmatics}.",
            manifest_digest=digest
        )