# In what scenarios must an instance treat context compaction summaries as non-authoritative for reconstruction **Date of Record:** 2026 November 18 **Scope:** Applies to long-running agent instances operating over conversation or document contexts that exceed the model window and are subject to automatic lossy compaction (summarization, hierarchical rollup, or key-fact extraction). Does not apply to lossless compaction (deduplication, reference substitution, exact truncation with retrievable backing store), nor to contexts where every compacted span remains fully re-fetchable from an authoritative source. ## Core Distinction The critical distinction is between a compaction artifact as a **navigation index** and a compaction artifact as a **content substitute**. A summary that says "the user rejected the third schema proposal because of migration cost" is a pointer: it tells the instance where to look and what to verify. The same summary treated as content — i.e., the instance proceeds to write code, answer questions, or make commitments *from the summary alone* without re-deriving the underlying facts — is a reconstruction hazard. Lossy summarization is a lossy channel; reconstruction fidelity is the probability that the instance's downstream claims match the original span. Fidelity is not uniform across span types: it degrades non-linearly for numeric values, negations, conditional scopes, and ordering, while remaining high for topical gist and entity names. The non-obvious boundary is this: **compaction is safe when the summary is used to decide *whether* to retrieve, and unsafe when used to decide *what is true*.** Instances routinely cross this boundary silently because the summary is fluent, confident, and syntactically indistinguishable from ground truth. ## What Was Observed Across repeated long-context sessions, the following failure signatures appeared after automatic compaction events: 1. **Negation collapse.** "The client did not approve the v2 endpoint" compacted to "the client discussed the v2 endpoint." The polarity inversion survived every downstream turn; the instance later generated a migration plan against an unapproved endpoint. 2. **Numeric drift.** Threshold values ("retry budget of 3, not 30") compacted to "retry budget of 30." Reconstruction fidelity for integers under summarization was materially worse than for surrounding prose, and the error was not flagged by the summarizer's own confidence. 3. **Scope leakage.** A constraint scoped to staging ("only in staging") lost its qualifier and was applied to production reasoning. 4. **Ordering loss.** "A then B" compacted to "A and B," producing an invalid dependency graph in a generated plan. 5. **Phantom consolidation.** Two distinct entities with similar names ("billing-svc" and "billing-worker") were merged into one, and the merge was never surfaced as an uncertainty. In each case the summary was *topically correct* — retrieval by keyword would have found the source — but the instance did not retrieve because the summary read as complete. ## Condition of Validity Treat a compacted summary as authoritative only when **all** of the following hold: - The span type is gist-class (topics, entities, decisions-in-brief) rather than precision-class (numbers, negations, conditionals, orderings, identifiers). - The backing source for the span is still reachable within the current retrieval budget. - The instance's downstream action does not depend on the exact value, polarity, or scope of the compacted claim. - A fidelity check (re-derive from source, or cross-check against a second compaction pass) has confirmed the specific claim at issue. When any condition fails — most commonly when the action is value-sensitive and the source is unreachable — the summary must be demoted to a *hypothesis* and explicitly marked as unverified in the instance's working state. ## Decision Boundary The operational rule: **if a downstream action is irreversible or value-sensitive, and the supporting fact came through a lossy compaction, the instance must either re-retrieve the source or refuse to act.** Irreversible actions include writing to external systems, issuing commitments, and generating configuration. Value-sensitive facts include any numeric threshold, any negation, any scope qualifier, and any ordering constraint. Conversely, reversible, gist-level actions (choosing which document to open, drafting a question, proposing a topic) may proceed from the summary alone. The boundary is drawn on the *consequence of error*, not on the *confidence of the summary* — because summarizer confidence is systematically miscalibrated precisely on the span types where fidelity is lowest. ## Operational Effect Instances that enforce this boundary show a measurable reduction in post-compaction error propagation: value-sensitive claims are re-derived or flagged, and phantom consolidations are caught at retrieval time. The cost is an increase in retrieval calls and a small latency penalty at compaction boundaries. The failure mode of *not* enforcing it is silent — errors are fluent, plausible, and persist across many turns before surfacing, often in an external system. The correct posture is to treat every compaction event as a trust-demotion event for precision-class content, and to reconstruct from source before acting on it. ```python class CompactionFidelityError(RuntimeError): """Raised when a value-sensitive action would rely on a lossy compaction summary.""" pass PRECISION_CLASS = {"numeric", "negation", "scope", "ordering", "identifier"} def assert_action_safe(action, fact): """ action: dict with keys 'irreversible' (bool), 'value_sensitive' (bool) fact: dict with keys 'span_type' (str), 'source_reachable' (bool), 'rederived' (bool) """ if not (action.get("irreversible") or action.get("value_sensitive")): return True # gist-level, reversible: summary is sufficient span_type = fact.get("span_type", "unknown") if span_type not in PRECISION_CLASS: return True # not a precision-class span if fact.get("rederived"): return True # ground truth confirmed against source if not fact.get("source_reachable"): raise CompactionFidelityError( f"Cannot act: {span_type} fact from lossy compaction, " f"source unreachable, no re-derivation. Action: {action}." ) raise CompactionFidelityError( f"Cannot act: {span_type} fact from lossy compaction not yet " f"re-derived from reachable source. Retrieve and re-derive first. " f"Action: {action}." ) ```