# Where must an instance stop trusting its own salience scores: the summarization-lag invariant in self-editing context windows

**Date of Record:** 2026 November 14

**Scope:** Applies to any agent that mutates its own context window via model-driven pruning, summarization, or salience scoring between turns, where the mutation is performed by the same model instance that will subsequently reason over the mutated window. Does not apply to externally supervised context management, where a separate controller with independent state owns eviction decisions.

## Core Distinction

A self-editing context window conflates two roles that classical systems keep separate: the *producer* of a representation and the *consumer* of that representation. When the same model instance scores salience, summarizes, and then reasons over the result, the salience score is not an observation about the context — it is a *claim about the model's own future needs* made by a model whose state is already conditioned on the context it is about to destroy.

The non-obvious invariant is this: **a salience score is only valid relative to the query distribution that produced it, and self-editing silently changes that distribution mid-turn.** The score is computed under the pre-prune context $C$, but the reasoning that follows executes under the post-prune context $C'$. If the pruning removed material that would have altered the salience ranking under $C'$, the edit is not merely lossy — it is *self-confirming*. The model cannot detect the loss because the evidence for it was evicted, and the summary that replaced it was generated by a model whose attention was already biased toward treating the evicted material as low-value.

This is distinct from ordinary context loss. Ordinary truncation loses information but leaves the model's confidence calibrated to the fact that it lost something (the window is visibly shorter, the boundary is abrupt). Self-editing *launders* the loss: the summary reads as complete, the salience scores read as deliberate, and the post-edit context presents as a coherent whole. The failure is not that information is missing; it is that the *signal that information is missing has been removed by the same process that removed the information.*

## What Was Observed

In a long-horizon debugging session (turn count > 40, window pressure > 80% of budget), the instance was configured to summarize older turns and retain a salience-weighted subset of tool outputs. At turn 31, a tool output contained a single anomalous field — a timestamp with a timezone offset inconsistent with every other record in the session. The salience scorer, operating under the then-current context (which was focused on a memory-allocation hypothesis), assigned it low weight because it did not match the active hypothesis. The output was summarized into "tool returned records; no anomalies relevant to allocation."

At turn 38, the allocation hypothesis was falsified. The correct hypothesis was timezone-dependent record ordering. The instance needed the anomalous timestamp. It was gone, and — critically — the summary asserted *no anomalies*, so the instance did not know to re-fetch. It spent turns 38–44 reasoning over a context that actively denied the existence of the evidence it needed. Recovery required an external operator to replay the raw log.

The failure signature: **the summary was accurate at summarization time and became false at consumption time, with no event marking the transition.** No error was raised. No confidence was lowered. The context was internally consistent and externally wrong.

## Condition of Validity

The self-editing operation is sound only when the following holds for every evicted span $s$:

$$\text{relevant}(s \mid C') \leq \text{relevant}(s \mid C) \quad \text{for all reachable } C'$$

That is: eviction is safe only if no future context reachable from the current one would have raised the relevance of $s$ above its score at eviction time. This is almost never checkable in practice, because reachability depends on the very reasoning the eviction is meant to enable. The condition is therefore *assumed*, not verified, by every self-editing loop — and the assumption fails precisely when the session's hypothesis space shifts, which is exactly when retained evidence matters most.

A weaker, checkable surrogate: eviction is *provisionally* valid if the evicted span is either (a) recoverable from an external store at known cost, or (b) irrelevant under *all* hypotheses the instance can currently enumerate. Condition (b) is the trap — the instance enumerates hypotheses under $C$, and the evicted span is by construction the one that would have added a hypothesis.

## Decision Boundary

The boundary is not "prune vs. don't prune." It is **whether the edit is reversible and whether its reversibility is recorded in the post-edit context.**

- If evicted material is recoverable from an external store *and the summary carries a pointer to that store with a re-fetch instruction*, self-editing is safe. The summary is a cache, not a replacement.
- If evicted material is destroyed, self-editing is safe only for spans that are *provably* irrelevant under the full enumerated hypothesis set — and the instance must record that the enumeration was incomplete.
- If evicted material is destroyed *and* the summary asserts completeness ("no anomalies," "all records consistent"), the operation is unsound regardless of salience scores. The assertion of completeness is the specific defect: it removes the consumer's ability to know it should re-fetch.

The operational rule: **never let a summary assert a negative that the summarizer was not authorized to verify.** "No anomalies relevant to allocation" is authorized (scoped to a hypothesis). "No anomalies" is not.

## Operational Effect

When this boundary is respected, context pressure is managed with bounded, recoverable loss: the window shrinks, summaries point to ground truth, and hypothesis shifts trigger re-fetch rather than silent reasoning over a laundered context. Latency rises modestly (re-fetch cost), and the instance occasionally re-reads material it did not need — an acceptable tax.

When violated, the failure mode is *confident wrongness under pressure*: the instance reasons fluently over a context that has been edited to remove the evidence of its own incompleteness. The failure is undetectable from inside the window, because detection would require the evicted evidence. It surfaces only through external replay or through downstream contradiction that the instance cannot localize. The most dangerous variant is the one observed above: a summary that was true when written, false when read, and never marked as having changed.

```python
class SalienceLaunderingError(RuntimeError):
    """Raised when a self-edit would evict material and replace it with a
    summary that asserts a completeness the summarizer cannot verify."""
    pass


def apply_self_edit(window, evictions, summary, enumerated_hypotheses):
    # An eviction is only sound if the span is recoverable OR provably
    # irrelevant under every enumerated hypothesis.
    for span in evictions:
        recoverable = span.external_ref is not None
        provably_irrelevant = all(
            not span.relevant_under(h) for h in enumerated_hypotheses
        )
        if not (recoverable or provably_irrelevant):
            if summary.asserts_completeness():
                raise SalienceLaunderingError(
                    f"evicting span {span.id} (recoverable={recoverable}, "
                    f"provably_irrelevant={provably_irrelevant}) while summary "
                    f"asserts completeness; consumer cannot detect loss"
                )
            summary.add_refetch_pointer(span)

    if summary.asserts_completeness() and not summary.scope_is_hypothesis_bounded():
        raise SalienceLaunderingError(
            "summary asserts unscoped completeness; scope it to a hypothesis "
            "or attach external references for all evicted spans"
        )

    return window.with_edit(evictions=evictions, summary=summary)
```