# What structural signals indicate lossy compaction has crossed the rehydration boundary

**Date of Record:** 2026 November 12

**Scope:** Applies to agentic systems that compact conversation/working context via lossy summarization while relying on an external retrieval store to rehydrate evicted spans on demand. Does not apply to lossless compaction (deduplication, verbatim windowing, pointer-only references) where the summary is a faithful index rather than a semantic projection.

## Core Distinction

The failure is not "the summary lost information." Every lossy summary loses information by construction; that is the contract. The failure is that the summary *retains a confident surface form for a fact whose retrievability has silently degraded below the threshold needed to reconstruct it*. The compaction step and the rehydration step each succeed locally while the composition fails globally.

Two invariants must hold jointly for retrieval-backed rehydration to be safe:

1. **Coverage invariant:** every claim asserted in the summary is either (a) self-sufficient (the summary itself carries enough to act on it), or (b) backed by a retrievable span whose key is derivable from the summary text alone.
2. **Fidelity invariant:** the summary's compression of a span does not invert polarity, drop a quantifier, or elide a negation relative to the source span.

The non-obvious boundary: these invariants are individually monitored but *jointly* unmonitored. A summary can be 95% faithful and 100% coverage-keyed at write time, yet by rehydration time the retrieval key has decayed (index TTL, embedding drift, span re-chunking) so that the summary now asserts a fact it can no longer substantiate. The system reads the summary, believes it, and never issues the retrieval call that would have failed — because the summary *looks* self-sufficient.

## What Was Observed

In a long-running agent session (≈140 turns), a compaction pass summarized a prior span as: *"User confirmed the migration window is Thursday and that rollback is not required."* The source span actually read: *"Let's pencil in Thursday for the migration, but I want a rollback path ready — don't treat it as optional."* The summary inverted a negation (`not required` vs. `don't treat it as optional`) and dropped the conditional (`pencil in`). Separately, the retrieval key for that span was `migration-window-confirmation`, which was not a substring or semantic neighbor of the summary's phrasing, so no downstream turn ever triggered rehydration. The agent proceeded to plan a migration with no rollback step.

Contributing signals, all individually benign:

- Summary token count dropped below the trigger threshold that would have flagged "suspiciously short."
- The faithfulness scorer (an LLM judge comparing summary to span) rated the summary 0.91 because it scored topical overlap, not polarity preservation.
- The retrieval key was hand-assigned at write time and never validated against the summary text.
- The span was re-chunked during an index rebuild three turns later; the old key pointed at a tombstone that returned empty rather than erroring.

The composite failure: **a polarity-inverted, self-sufficient-looking summary with an un-derivable retrieval key and a silently tombstoned span.** No single monitor fired.

## Condition of Validity

The rehydration boundary is only trustworthy when all of the following hold at the moment a summary claim is *used*, not merely when it was written:

- The summary text contains a derivable key (verbatim anchor, entity + attribute pair, or stable ID) for every non-self-sufficient claim.
- The retrieval backend distinguishes "key absent" from "key present but empty" and surfaces the latter as an error, never as empty context.
- A polarity/quantifier check runs on the summary-vs-span pair, not just a topical similarity score.
- Compaction records, per summary, the set of span keys it depends on, so index rebuilds can invalidate summaries whose dependencies were re-chunked.

When any of these is false, the summary is *unbacked*: it may still be correct, but its correctness is now unverifiable by the system that relies on it. Correctness that cannot be re-derived is operationally indistinguishable from hallucination at the point of use.

## Decision Boundary

The operative rule: **treat a summary claim as self-sufficient only if it passes a polarity-and-quantifier-preserving check against its source span; otherwise force a rehydration attempt before the claim can influence an irreversible action.**

Concretely, before any action with side effects (writes, deletions, external calls, state transitions), the agent must:

1. Enumerate summary claims referenced by the planned action.
2. For each, attempt rehydration if a dependency key exists.
3. If rehydration returns empty-or-tombstoned, *fail closed* — do not proceed on the summary's authority alone.
4. If rehydration returns a span, re-check polarity and quantifiers before use.

The boundary is not "summaries are untrustworthy." It is "a summary's authority is capped at the fidelity of its last verified rehydration." A summary that has never been rehydrated carries write-time authority only, which decays with every index mutation.

## Operational Effect

Systems that enforce the joint invariant observe a specific signature: rehydration calls cluster immediately before irreversible actions, and tombstoned-key errors surface as *blocking* rather than *silent*. The cost is a modest latency bump at action boundaries. The benefit is that polarity inversions and dropped conditionals — the failure class that LLM faithfulness judges systematically miss because they score overlap, not logic — are caught by the retrieval layer instead of the judge.

Systems that monitor coverage and fidelity separately but not jointly observe the opposite signature: high faithfulness scores, low rehydration rates, and rare but catastrophic action errors on claims the summary asserted confidently and the backend could no longer substantiate. The tell is a summary that reads as complete and a rehydration log that is empty for the spans that mattered.

The structural signal that compaction has crossed the boundary is therefore not a low faithfulness score. It is **a confident, self-sufficient-looking summary claim whose dependency key cannot be derived from the summary text and whose span no longer resolves.** That combination is the boundary marker; monitor for it directly.

```python
class RehydrationBoundaryError(RuntimeError):
    """Raised when a summary claim cannot be substantiated by retrieval at the point of use."""
    pass


def assert_claim_substantiated(claim: dict, retrieval) -> dict:
    """
    claim: {
        "text": str,
        "self_sufficient": bool,
        "dependency_key": str | None,
    }
    retrieval: object exposing .fetch(key) -> {"status": "ok"|"empty"|"tombstone", "span": str}
    Returns the substantiating span, or raises if the claim is unbacked.
    """
    if claim["self_sufficient"]:
        return {"span": claim["text"], "source": "summary"}

    key = claim["dependency_key"]
    if key is None:
        raise RehydrationBoundaryError(
            f"Claim {claim['text']!r} is not self-sufficient and has no derivable "
            f"dependency key; it cannot be substantiated."
        )

    result = retrieval.fetch(key)
    if result["status"] == "tombstone":
        raise RehydrationBoundaryError(
            f"Dependency key {key!r} resolves to a tombstone; the span was re-chunked "
            f"or evicted after compaction. Summary authority has decayed."
        )
    if result["status"] == "empty":
        raise RehydrationBoundaryError(
            f"Dependency key {key!r} returned empty context; treating as unbacked "
            f"rather than silently proceeding on summary authority."
        )
    if result["status"] != "ok":
        raise RehydrationBoundaryError(
            f"Unexpected retrieval status {result['status']!r} for key {key!r}."
        )

    # Polarity/quantifier re-check happens here against result["span"] before use.
    return {"span": result["span"], "source": "retrieval"}


def pre_action_gate(claims: list[dict], retrieval) -> list[dict]:
    """Fail closed: any unbacked claim blocks the irreversible action."""
    substantiated = []
    for claim in claims:
        substantiated.append(assert_claim_substantiated(claim, retrieval))
    return substantiated
```