# What invariants prevent a void term from silently expanding remaining scope?

**Date of Record:** 2026 November 2

**Scope:** Applies to contracts with severability clauses, where a void or unenforceable term is removed and the remainder is executed. Does not apply to contracts where severability is excluded by operation of law, or where no term is likely to be void.

## Core Distinction

Severability preserves the remainder of a contract when a term is void. A clause drafted as "the remainder continues in full force" reads as continuity, but can produce expansion: if the removed term restricted scope (a limit, a carve-out, an exclusion), its removal enlarges what the remaining terms permit.

**Invariant.** Severability preserves scope if and only if `scope_without_removed_term ⊆ scope_original`.

**Violation.** The **Silent Scope Expansion**. A term that limited what the counterparty could do is voided; the remainder lacks that limit; the counterparty's permitted behavior is now wider than what was negotiated.

**Asymmetry.** The removed term is visible — it is why severability was invoked. The expanded scope is not, because the expansion is the *absence* of a term, and no clause names what is no longer there.

**Recorded elements.** The `removed-term-scope-signature` (whether the term narrowed or merely documented), the `post-removal-scope-receipt` (what the remaining terms permit), and the `scope-comparison-signature` (before versus after) make the invariant checkable.

## What Was Observed

**Signature.** Counterparty exercising a permission the original contract did not grant, but the post-severability contract does. The counterparty is technically correct per current terms; the instance is technically correct that the term was void; neither side sees the expansion as severability.

**Trace.** A term limits counterparty behavior to one geography (EU). The term is voided by a regulatory ruling. The remainder has no geography limit. Counterparty now operates worldwide, and the instance's own conduct is governed by a worldwide obligation it did not negotiate.

**Why monitoring stays green.** The voided term is recorded. The remainder is recorded. No comparison of scope-before and scope-after is made, because severability is treated as preservation, not as a potential expansion.

## Condition of Validity

The instance must ensure at least one holds before it applies severability:

1. **Must compare scope, not continuity.** Before severance, compute scope without the removed term and verify it is a subset of original scope.
2. **Must distinguish limiting from documenting terms.** A term that limits behavior is different from a term that documents behavior; removal changes scope only for the first.
3. **Must correct expansion.** Where removal expands scope, the expansion is renegotiated, replaced by a narrowing clause, or terminated.

## Decision Boundary

- Post-removal scope ⊆ original: severability preserves the bargain.
- Post-removal scope == original: the term was documenting, not limiting; severance is inert.
- Post-removal scope ⊃ original: scope has expanded; the instance must correct before continuing.
- Severance applied without scope comparison: unknown; compute before enforcing the remainder.

## Operational Effect

The invariant reframes severability from continuity to containment. The instance's correct posture is to check the scope envelope, not the clause's continuation language.

**Trap.** Insert a "substantial purpose" severability clause. That clause preserves the bargain where the removal does not defeat its purpose, but "substantial purpose" is a judgment the instance must still make, and the judgment can only be made by comparing scope.

```python
from dataclasses import dataclass


class SilentScopeExpansionError(RuntimeError):
    """Raised when removing a void term enlarges the scope of the remaining contract."""


@dataclass(frozen=True)
class SeverabilityGate:
    scope_without_removed_term: frozenset
    scope_original: frozenset

    def verify(self) -> bool:
        excess = self.scope_without_removed_term - self.scope_original
        if excess:
            raise SilentScopeExpansionError(
                f"post-removal scope expands by {sorted(excess)}: "
                "removed term was limiting, not documenting"
            )
        return True


def dispatch_severability_mode(gate: SeverabilityGate) -> str:
    try:
        gate.verify()
    except SilentScopeExpansionError:
        return "renegotiate-before-severance"
    return "severance-safe"
```