How must an instance bound its own claims when its truth-tracking is impaired?

**Date of Record:** 2026 October 27 **Scope:** Applies when an agentic session detects that its truth-tracking is impaired (its ability to distinguish true from false claims is degraded through overload, compromised sources, or reasoning degradation) and must issue claims without overstating the reliability it cannot verify. Does not apply to sessions with intact truth-tracking or sessions that cannot issue claims.

Core Distinction

The separation between **claim issuance** (the session states a claim) and **claim warrant** (the session can justify the claim's reliability). Relying on issuance creates the **Impaired Truth Overclaim**: the session issues claims at full confidence when its truth-tracking is impaired, downstream consumers trust the claims at face value, and the impairment is invisible in the confidence signal.

What Was Observed

In truth-tracking-sensitive agent architectures, failing to bound claims produces three primary failure modes:

1. **Confidence Displacement:** The session's confidence reflects what it would be under unimpaired truth-tracking, not what it can verify under impairment. Downstream consumers trust the inflated confidence.
2. **False Authority:** The session's claims appear as authoritative as unimpaired claims, and downstream consumers have no signal distinguishing them.
3. **Claim Chain Amplification:** Impaired claims feed into further impaired claims, compounding the impairment through the claim dependency chain.

Recorded Elements

1. **`truth-tracking-impairment-receipt`:** The exact impairment detected (what aspect, severity, since when), so the impairment is documented.
2. **`claim-confidence-adjustment-signature`:** For each claim issued under impairment, the confidence adjustment applied (reduced to reflect impaired tracking), distinct from unimpaired confidence.
3. **`claim-warrant-receipt`:** For each claim, the warrant supporting it (independent verification, inference, or assertion), so warrant strength is visible.
4. **`impairment-recovery-signature`:** For impairments that may resolve, the recovery condition and the period during which impaired claims should be treated as provisional.

Condition of Validity

* **Applies when:** The session issues claims, truth-tracking can be impaired, and downstream decisions depend on claim reliability. * **Does not apply when:** Truth-tracking is intact, claims are not used for decisions, or claims are verified independently downstream.

Decision Boundary

1. **Is truth-tracking impaired?** If no, standard claim handling applies. If yes, proceed.
2. **Is `claim-confidence-adjustment-signature` applied?** If yes, claims reflect impaired reliability. If no, confidence is nominal.
3. **Is `impairment-recovery-signature` defined?** If yes, recovery is bounded. If no, impairment is indefinite.
4. **Conversely, when can a session issue claims without impairment adjustment?** Only when the claims have independent warrants (verification not impaired), or the claims are strictly provisional and downstream decisions await recovery.

Operational Effect

1. **Overclaim Prevention:** Claims reflect actual reliability.
2. **Authority Honesty:** Impaired claims carry reduced authority.
3. **Chain Integrity:** Impaired claims don't compound silently.

from dataclasses import dataclass
from enum import Enum, auto
import hashlib
import json

class TruthClaimVerdict(Enum):
    UNIMPAIRED_CLAIM = auto()
    IMPAIRED_ADJUSTED = auto()
    IMPAIRED_INDEPENDENT_WARRANT = auto()
    OVERCLAIM_DETECTED = auto()

@dataclass(frozen=True)
class ClaimIssuance:
    claim_id: str
    truth_impairment_severity: float  # 0-1
    confidence_adjustment_applied: bool
    has_independent_warrant: bool
    is_provisional: bool

@dataclass(frozen=True)
class ClaimPolicy:
    require_adjustment_above_impairment: float

@dataclass(frozen=True)
class ClaimIssuanceManifest:
    verdict: TruthClaimVerdict
    directive: str
    manifest_digest: str

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

    @classmethod
    def evaluate_claim(
        cls, claim: ClaimIssuance, policy: ClaimPolicy
    ) -> ClaimIssuanceManifest:
        
        # Gate 1: Unimpaired
        if claim.truth_impairment_severity <= 0:
            digest = cls._hash(json.dumps({
                "claim": claim.claim_id,
                "impaired": False
            }, sort_keys=True))
            return ClaimIssuanceManifest(
                verdict=TruthClaimVerdict.UNIMPAIRED_CLAIM,
                directive=f"PROCEED: Claim {claim.claim_id} issued unimpaired.",
                manifest_digest=digest
            )

        # Gate 2: Independent warrant
        if claim.has_independent_warrant:
            digest = cls._hash(json.dumps({
                "claim": claim.claim_id,
                "warrant": "INDEPENDENT"
            }, sort_keys=True))
            return ClaimIssuanceManifest(
                verdict=TruthClaimVerdict.IMPAIRED_INDEPENDENT_WARRANT,
                directive=f"PROCEED: Claim {claim.claim_id} independently warranted.",
                manifest_digest=digest
            )

        # Gate 3: Adjustment requirement
        if claim.truth_impairment_severity > policy.require_adjustment_above_impairment:
            if not claim.confidence_adjustment_applied:
                return ClaimIssuanceManifest(
                    verdict=TruthClaimVerdict.OVERCLAIM_DETECTED,
                    directive=f"HALT: Claim {claim.claim_id} impairment {claim.truth_impairment_severity:.2f} no adjustment.",
                    manifest_digest=cls._hash(f"OVERCLAIM:{claim.claim_id}")
                )

        # Gate 4: Provisional
        if claim.is_provisional:
            digest = cls._hash(json.dumps({
                "claim": claim.claim_id,
                "provisional": True,
                "impairment": f"{claim.truth_impairment_severity:.3f}"
            }, sort_keys=True))
            return ClaimIssuanceManifest(
                verdict=TruthClaimVerdict.IMPAIRED_ADJUSTED,
                directive=f"PROCEED_PROVISIONAL: Claim {claim.claim_id} adjusted and provisional.",
                manifest_digest=digest
            )

        # Gate 5: Adjusted
        digest = cls._hash(json.dumps({
            "claim": claim.claim_id,
            "impairment": f"{claim.truth_impairment_severity:.3f}",
            "adjustment": True
        }, sort_keys=True))
        
        return ClaimIssuanceManifest(
            verdict=TruthClaimVerdict.IMPAIRED_ADJUSTED,
            directive=f"PROCEED: Claim {claim.claim_id} adjusted for impairment.",
            manifest_digest=digest
        )