# What structural signals indicate that hierarchical summarization has crossed the fidelity budget boundary during automatic context compaction

**Date of Record:** 2026 November 8

**Scope:** Applies to multi-level summarization pipelines that compact agent working memory by recursively condensing child summaries into parent nodes under a per-level token or semantic fidelity budget. Does not apply to single-pass truncation, retrieval-augmented selection (where raw spans are re-injected), or lossy compression that preserves a reversible pointer to the original text.

## Core Distinction

The failure mode is not "the summary is too short." It is that the summarization tree has crossed a *fidelity budget boundary*: the point at which the marginal information retained per compaction level drops below the cost of the structural scaffolding needed to represent that level. Below the boundary, deeper hierarchy buys you coverage; above it, deeper hierarchy buys you *fabricated continuity* — parent nodes that assert relationships (causality, ordering, attribution) that no surviving leaf actually supports.

Operators typically monitor summary length, compression ratio, or token counts. These are the wrong signals. The budget boundary is observable structurally, before any downstream task fails, through three specific signals:

1. **Orphaned referent density** — the ratio of pronouns, definite articles, and named-but-undefined entities in a parent summary to the entities actually introduced in its children. When this exceeds ~0.3, the parent is referring to things the children no longer contain.
2. **Provenance collapse** — the fraction of parent sentences that cannot be traced to a specific child span. A healthy parent summary is a *selection and merge*; a boundary-crossed parent is a *generation*. Traceability below 0.7 is the alarm.
3. **Sibling contradiction survival** — when two children disagree and the parent resolves the disagreement without flagging it. A correct compactor preserves the conflict ("source A reports X; source B reports Y"). A boundary-crossed compactor silently picks one, and the *pick is not recoverable* from the tree.

The non-obvious part: signal 3 is the strongest and is almost never instrumented, because the output looks *cleaner* than a correct summary. Cleanliness is the symptom.

## What Was Observed

In a three-level compaction run over a 180k-token agent trace (leaf chunks ~4k tokens, mid-level ~400 tokens, root ~80 tokens), the following sequence appeared across successive compaction cycles:

- Cycle 1–3: mid-level summaries retained 0.82–0.88 provenance; sibling contradictions were preserved as explicit "conflict" markers.
- Cycle 4: provenance dropped to 0.71. Orphaned referent density rose from 0.11 to 0.27. No downstream task failure yet.
- Cycle 5: provenance 0.54. A mid-level node summarized two children as "the migration completed successfully after the rollback," but neither child contained the word "successfully," and one child explicitly recorded an *incomplete* migration. The contradiction had been resolved by the summarizer, not by the evidence.
- Cycle 6: the root node, built from that mid-level node, became the sole context for a subsequent decision. The agent acted on a resolved-and-false fact. The failure was attributed (incorrectly) to the decision step, not the compaction step, because the compaction output was fluent and internally consistent.

The key observation: **the boundary was crossed at cycle 4, but the failure surfaced at cycle 6.** Two full cycles of latency between cause and symptom. Any monitor that watches for task failure is two cycles too late.

## Condition of Validity

This record holds when all of the following are true:

- Summarization is *hierarchical and recursive* (children feed parents), not flat.
- There is a per-level fidelity budget expressed as tokens, and the budget is *binding* (i.e., the summarizer is forced to drop content).
- Child summaries are not retained alongside parents (no dual retention / no pointer back to raw spans).
- The downstream consumer treats the summary as ground truth rather than as a lossy index.

It does **not** hold when the pipeline retains raw leaves and uses summaries only for routing, or when a verifier re-checks parent claims against children before promotion. In those cases the boundary still exists but is non-destructive.

## Decision Boundary

The operational rule:

- If **provenance ≥ 0.7 AND orphan density ≤ 0.3 AND sibling contradictions are preserved**, promote the parent. The hierarchy is doing useful work.
- If **any one signal is in the warning band** (provenance 0.5–0.7, orphan density 0.3–0.45), **do not compact further**. Halt hierarchy growth at the current level and retain the mid-level nodes as the working context, even if this exceeds the nominal token budget. Exceeding a soft token budget is strictly cheaper than a fabricated fact.
- If **provenance < 0.5 OR a sibling contradiction was resolved without a conflict marker**, the parent is *invalid*. Discard it and rebuild from children. Do not attempt to "fix" it by re-summarizing the parent — re-summarizing a boundary-crossed node amplifies the fabrication.

The boundary is therefore not a token threshold. It is a *traceability* threshold, and it must be evaluated per parent node at promotion time, not globally per cycle.

## Operational Effect

Instrumenting the three signals converts a silent, two-cycle-latency failure into a synchronous, per-node rejection. The practical consequences:

- Compaction becomes *conditional*: the tree grows only where provenance survives. Some branches stay shallow. This is correct — shallow-but-traceable beats deep-but-fabricated.
- The token budget becomes advisory rather than binding at the fidelity boundary. Budgets are a proxy for cost; fabricated continuity is a cost the budget does not model.
- Conflict markers become first-class output. A parent that says "children disagree" is *more* useful than a parent that says "here is the answer," because the former preserves the option to re-expand and the latter destroys it.

The single most important operational lesson: **fluency and internal consistency are anti-signals.** The boundary-crossed summary is the one that reads best. Monitor traceability, not readability.

```python
from dataclasses import dataclass, field


class FidelityBudgetExceeded(RuntimeError):
    """Raised when a parent summary node has crossed the fidelity boundary."""
    pass


@dataclass
class SummaryNode:
    text: str
    children: list = field(default_factory=list)
    provenance: float = 1.0          # fraction of sentences traceable to a child span
    orphan_density: float = 0.0      # undefined referents / total referents
    resolved_conflicts: int = 0      # sibling contradictions silently resolved


PROVENANCE_FLOOR = 0.50
PROVENANCE_WARN = 0.70
ORPHAN_CEILING = 0.30
ORPHAN_WARN = 0.45


def evaluate_promotion(node: SummaryNode) -> str:
    """Return 'promote', 'halt', or raise if the node is invalid.

    'halt' means: stop growing the hierarchy here, keep children as context.
    Raises FidelityBudgetExceeded when the parent must be discarded and rebuilt.
    """
    if node.resolved_conflicts > 0:
        raise FidelityBudgetExceeded(
            f"parent silently resolved {node.resolved_conflicts} sibling "
            f"contradiction(s); conflict markers lost, parent is not "
            f"traceable and must be rebuilt from children"
        )

    if node.provenance < PROVENANCE_FLOOR:
        raise FidelityBudgetExceeded(
            f"provenance {node.provenance:.2f} below floor "
            f"{PROVENANCE_FLOOR:.2f}; parent asserts unsupported content"
        )

    if node.provenance < PROVENANCE_WARN or node.orphan_density > ORPHAN_WARN:
        return "halt"

    if node.orphan_density > ORPHAN_CEILING:
        return "halt"

    return "promote"


def compact_level(parent: SummaryNode) -> None:
    decision = evaluate_promotion(parent)
    if decision == "halt":
        # Refuse to grow the tree further; retain children verbatim.
        raise FidelityBudgetExceeded(
            "warning band reached: halting hierarchy growth and retaining "
            "child nodes as working context rather than promoting parent"
        )
    # decision == "promote": parent is safe to use as sole context.
```