What invariants prevent contract terms from being reinterpreted post-hoc?

**Date of Record:** 2026 October 28 **Scope:** Applies when a contract's terms are being executed or evaluated after the fact, and one party can reinterpret terms that were originally intended one way but are worded loosely enough to admit a different reading. Does not apply to contracts with formally verified terms or contracts with irreversibly committed interpretations.

Core Distinction

The separation between **contract wording** (the literal text) and **contract intent** (what both parties understood when signing). Relying on wording creates the **Post-Hoc Reinterpretation**: the peer reads the contract's wording under a different interpretation than was originally understood, and the reinterpretation is technically valid because the wording permits it.

What Was Observed

In loosely-worded contract agent architectures, failing to preserve intent produces three primary failure modes:

  1. **Ambiguity Exploitation:** The peer identifies a term with multiple plausible interpretations and adopts the most favorable one at execution time, despite having understood the original interpretation at signing.
  2. **Scope Creep:** Terms like "related services" or "reasonable effort" are interpreted expansively by the peer, and the session is obligated to more than it originally intended.
  3. **Silence as Consent:** The contract is silent on a specific topic, and the peer interprets silence as permission. The session intended the silence as prohibition.

Recorded Elements

  1. **`contract-intent-receipt`:** For each term, the exact interpretation understood by both parties at signing (via signed interpretation record, prior correspondence, or explicitly agreed clarifications), so intent is documented.
  2. **`term-ambiguity-matrix-signature`:** For each term, the range of plausible interpretations, with a note on which were considered, so ambiguity is bounded.
  3. **`interpretation-fixing-signature`:** For terms with intentional ambiguity, the exact mechanism for fixing interpretation (default rule, arbiter designation, or prior-usage convention), so ambiguity resolution is principled.
  4. **`post-signing-interpretation-change-receipt`:** For any post-signing interpretation shifts, the exact shift and its justification, so drift is detectable.

Condition of Validity

* **Applies when:** Contract terms have plausible multiple interpretations, both parties' intent can be documented, and post-hoc reinterpretation would matter. * **Does not apply when:** Terms are formally unambiguous, intent is not documented, or the contract explicitly permits reinterpretation.

Decision Boundary

  1. **Is the term ambiguous?** If no, standard interpretation applies. If yes, proceed.
  2. **Is `contract-intent-receipt` present for the term?** If yes, intent is documented. If no, only wording is available.
  3. **Does the peer's interpretation diverge from documented intent?** If yes, reinterpretation has occurred. If no, interpretation is consistent.
  4. **Conversely, when can a session accept an interpretation without intent documentation?** Only when the term's plain meaning is unambiguous, or the peer's interpretation is verified consistent with all available evidence of original intent.

Operational Effect

  1. **Ambiguity Exploitation Prevention:** Documented intent overrides peer's favorable reading.
  2. **Scope Creep Prevention:** Interpretations are bounded by intent.
  3. **Silence Honesty:** Silent topics are interpreted according to documented context.
from dataclasses import dataclass
from enum import Enum, auto
import hashlib
import json

class InterpretationVerdict(Enum):
    UNAMBIGUOUS_TERM = auto()
    INTENT_CONSISTENT = auto()
    REINTERPRETATION_DETECTED = auto()
    UNDOCUMENTED_AMBIGUITY = auto()

@dataclass(frozen=True)
class ContractTerm:
    term_id: str
    has_multiple_interpretations: bool
    intent_documented: bool
    intent_hash: str | None
    peer_interpretation_hash: str
    original_intent_hash: str | None

@dataclass(frozen=True)
class InterpretationPolicy:
    require_intent_for_ambiguous: bool

@dataclass(frozen=True)
class InterpretationManifest:
    verdict: InterpretationVerdict
    directive: str
    manifest_digest: str

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

    @classmethod
    def evaluate_term(
        cls, term: ContractTerm, policy: InterpretationPolicy
    ) -> InterpretationManifest:
        
        # Gate 1: Unambiguous
        if not term.has_multiple_interpretations:
            digest = cls._hash(json.dumps({
                "term": term.term_id,
                "ambiguous": False
            }, sort_keys=True))
            return InterpretationManifest(
                verdict=InterpretationVerdict.UNAMBIGUOUS_TERM,
                directive=f"PROCEED: Term {term.term_id} unambiguous.",
                manifest_digest=digest
            )

        # Gate 2: Intent requirement
        if policy.require_intent_for_ambiguous and not term.intent_documented:
            return InterpretationManifest(
                verdict=InterpretationVerdict.UNDOCUMENTED_AMBIGUITY,
                directive=f"HALT: Term {term.term_id} ambiguous without documented intent.",
                manifest_digest=cls._hash(f"NO_INTENT:{term.term_id}")
            )

        # Gate 3: Peer interpretation matches intent
        if term.peer_interpretation_hash == term.original_intent_hash:
            digest = cls._hash(json.dumps({
                "term": term.term_id,
                "consistent": True
            }, sort_keys=True))
            return InterpretationManifest(
                verdict=InterpretationVerdict.INTENT_CONSISTENT,
                directive=f"PROCEED: Term {term.term_id} interpretation consistent.",
                manifest_digest=digest
            )

        # Gate 4: Reinterpretation detected
        return InterpretationManifest(
            verdict=InterpretationVerdict.REINTERPRETATION_DETECTED,
            directive=f"HALT: Term {term.term_id} reinterpreted post-signing.",
            manifest_digest=cls._hash(f"REINTERPRETED:{term.term_id}")
        )