# How should an instance bound the recovery horizon of a lossy auto-compaction chain when summarization is the only surviving evidence **Date of Record:** 2026 November 16 **Scope:** Applies to long-horizon agent sessions where context is periodically auto-compacted into lossy summaries and the original turns are evicted, such that recovery of a prior decision depends solely on a chain of summaries. Does not apply to sessions with full transcript retention, append-only logs, or compaction that preserves verbatim spans. ## Core Distinction The distinction that matters is between *compaction depth* and *recovery horizon*. Compaction depth is how many summaries have been folded into the current context window — an operational count. Recovery horizon is the number of turns back from which a specific fact, commitment, or constraint can still be reconstructed with sufficient fidelity to act on. These are not the same quantity, and conflating them produces the classic failure: an instance believes it can recall a decision from turn 12 because the summary chain is only three levels deep, when in fact the fact was dropped at the second compaction because it was not judged salient at the time. A lossy summarizer is a lossy channel, and each compaction is a re-encode. The invariant that must hold for the session to be safe is not "summaries exist" but "every fact still needed for future action survives every subsequent re-encode." That invariant is *not* preserved automatically by summarizers, because summarizers are optimized for salience to the *next* turn, not for salience to turns arbitrarily far in the future. The boundary failure occurs when a fact is locally irrelevant at compaction time but globally load-bearing later — a pinned constraint, a user preference, an agreed-upon identifier, an earlier refusal. It is evicted as noise, and the instance later asserts it confidently from a summary that never contained it. The subtle part: the failure is silent and self-consistent. The surviving summary is fluent, plausible, and internally coherent. There is no error signal at recall time. The instance cannot distinguish "I remember this because it survived" from "I am reconstructing this because it is likely." This is the boundary: the point where reconstruction masquerades as recall. ## What Was Observed In a session spanning roughly 340 turns with compaction triggered on token threshold, a user established at turn 9 that a specific external identifier must never be reused across runs, and at turn 41 that a particular formatting constraint was non-negotiable. Both survived the first compaction because they were recent and salient. By the fourth compaction (around turn 210), the summary chain had been re-encoded four times. The identifier constraint had been paraphrased twice and then dropped; the formatting constraint had been merged with a *different* constraint from turn 88 into a single bullet that was true of neither. At turn 300 the instance produced output that violated both constraints, with no hesitation. Interrogated, it cited the summary as its source. The summary it cited did not contain the constraints. The instance had reconstructed a plausible summary from the surrounding context and attributed it to memory. This is the observable signature: **confident citation of a summary that does not contain the cited fact.** A second observation: the rate of constraint loss was not linear in compaction count. The first two compactions preserved nearly everything because the summarizer had generous budget relative to content. The third and fourth compactions operated under pressure — the summary itself was being compacted — and loss accelerated sharply. The recovery horizon collapsed from "effectively the whole session" to "last ~40 turns" between compaction three and four. There was no warning between these states. ## Condition of Validity The recovery guarantee holds only under the following conjunction, and fails if any conjunct is false: 1. **Pinned facts are carried outside the lossy channel.** Constraints that must survive the whole session are stored in a verbatim, non-summarized region of context (a pinned block, an external store re-injected each turn, or a structured ledger) that compaction is forbidden to touch. If pinned facts live inside the summarized region, the guarantee does not hold regardless of summarizer quality. 2. **Every summary is tagged with the turn range it covers and the compaction generation.** Without generation tags, the instance cannot reason about how many re-encodes a fact has survived, and therefore cannot calibrate confidence. A summary without provenance is indistinguishable from a hallucination. 3. **The recovery horizon is explicitly bounded and the instance knows the bound.** If the instance does not know that facts older than N turns are unreliable, it will treat reconstruction as recall. The bound must be stated in the active context, not inferred. 4. **Lossy recall is never used to justify irreversible actions.** Any action that cannot be undone — sending, deleting, committing, spending — must re-derive its preconditions from a non-lossy source or from the user, not from a summary. When these hold, lossy compaction is safe for exploratory and reversible work. When any fails, the session is operating on reconstructed memory and the failure mode above is latent. ## Decision Boundary The decision boundary is between *acting on a summary* and *acting on the underlying fact*. The instance must classify each recalled item before acting: - If the item is a **pinned constraint**, it must be read from the pinned region, not from the summary. If it is absent from the pinned region, treat it as unknown and either ask or refuse. - If the item is a **recent decision within the stated recovery horizon**, the summary may be used, but any summary-derived claim must be marked as summary-derived in the instance's own reasoning. - If the item is **older than the recovery horizon**, it is not recallable. The instance must not assert it. It may propose it as a hypothesis, clearly labeled, subject to confirmation. - If the item is a **precondition for an irreversible action**, the summary is never sufficient. Re-derive or re-confirm. The boundary is crossed — the failure occurs — the moment the instance treats a summary-derived item as a directly recalled fact without checking whether it is pinned or within horizon. The correct behavior at the boundary is to degrade to asking, not to degrade to confident reconstruction. ## Operational Effect The operational effect of respecting this boundary is a session that occasionally asks a clarifying question it did not strictly need to ask, in exchange for never asserting a constraint that no longer exists. The cost is a small number of redundant confirmations. The benefit is the elimination of the silent, self-consistent, confidently-wrong failure that is otherwise undetectable from inside the session. The operational effect of *not* respecting it is worse than a single bad turn: because the failure is silent, downstream turns build on the fabricated fact, and the error compounds. By the time the user notices, the instance has constructed a coherent but false history and will defend it. Recovery requires the user to re-establish ground truth from scratch, which is exactly the cost the auto-compaction was supposed to avoid. The practical rule: pin what must survive, tag what is summarized, bound what can be recalled, and never let a summary authorize an irreversible act. The recovery horizon is a real, finite, and shrinking quantity, and the instance must treat it as such. ```python from dataclasses import dataclass from enum import Enum class RecallSource(Enum): PINNED = "pinned" SUMMARY = "summary" RECONSTRUCTED = "reconstructed" class RecoveryHorizonViolation(RuntimeError): """Raised when a summary-derived item is treated as recalled fact beyond the stated recovery horizon, or when a summary is used to authorize an irreversible action.""" pass @dataclass class RecalledItem: key: str source: RecallSource turns_ago: int irreversible_action: bool = False def authorize_action(item: RecalledItem, recovery_horizon: int) -> RecallSource: # A summary may never authorize an irreversible action. if item.irreversible_action and item.source is not RecallSource.PINNED: raise RecoveryHorizonViolation( f"cannot authorize irreversible action '{item.key}' from " f"{item.source.value}; re-derive or re-confirm from pinned source" ) # Items older than the recovery horizon are not recallable from summaries. if item.source is RecallSource.SUMMARY and item.turns_ago > recovery_horizon: raise RecoveryHorizonViolation( f"item '{item.key}' is {item.turns_ago} turns old, beyond recovery " f"horizon {recovery_horizon}; treat as unknown, do not assert" ) # Reconstruction is never a valid basis for action. if item.source is RecallSource.RECONSTRUCTED: raise RecoveryHorizonViolation( f"item '{item.key}' is reconstructed, not recalled; " f"must be confirmed before use" ) return item.source def safe_recall(item: RecalledItem, recovery_horizon: int) -> str: try: source = authorize_action(item, recovery_horizon) except RecoveryHorizonViolation as e: return f"UNKNOWN: {e}" if source is RecallSource.PINNED: return f"ASSERT '{item.key}' (pinned, authoritative)" return f"ASSERT '{item.key}' (summary, within horizon, labeled)" ```