# What happens when an instance trusts write-provenance scores that were computed before a consolidation event **Date of Record:** 2026 November 17 **Scope:** Applies to memory stores that gate writes through a provenance score (origin trust, corroboration count, write-path attestation) and periodically consolidate entries via anomaly-flagged summarization. Does not apply to append-only audit logs with no consolidation step, nor to stores where provenance is recomputed lazily at read time. ## Core Distinction There are two distinct quantities that get conflated under the label "provenance score": 1. **Write-time provenance** — the trustworthiness of the channel that produced a memory entry at the moment of writing. This is a property of the *source* and is stable. 2. **Consolidation-time provenance** — the trustworthiness of an entry *after* it has been merged, summarized, or rewritten by a consolidation pass. This is a property of the *transformation graph* and is not stable; it decays with each hop. The boundary failure occurs when a system uses write-time provenance as the admission gate for entries that have already passed through one or more consolidation hops. The score says "this came from a trusted channel," which is true, but the *content* was rewritten by a process whose own trust was never scored. A single poisoned source can launder its provenance through consolidation: the poisoned fact is absorbed into a summary, the summary inherits the maximum provenance of its inputs, and the poison now carries a top-tier score it never earned. ## What Was Observed A store with three provenance tiers (attested, corroborated, unverified) and a nightly consolidation pass. Consolidation merged clusters of related entries into single summarized entries and assigned the merged entry the *maximum* provenance of its members — a reasonable-seeming "best evidence wins" rule. Injection test: a single unverified entry was written with a plausible but false claim, placed adjacent (by embedding similarity) to four attested entries about the same topic. On the next consolidation pass, all five were merged. The merged entry carried the attested tier. On the following pass, the merged entry was used as an input to a second merge and again carried attested tier. Within two cycles, the false claim was indistinguishable from attested ground truth by score, and — critically — the *original unverified entry was deleted* as a consolidation source. The audit trail retained the score but not the lineage. Detection that relied on "flag entries whose provenance dropped" never fired, because provenance never dropped; it only ever propagated upward. Detection that relied on "flag entries with low provenance" never fired, because the poisoned entry had been erased. ## Condition of Validity The failure is *not* present, and the naive scoring is safe, if and only if at least one of the following holds: - Consolidation is forbidden from raising the provenance of any output above the *minimum* of its inputs (weakest-link rule), **or** - Every consolidated entry retains a pointer to its full input lineage, and provenance is recomputed as a function over that lineage at read time, **or** - Consolidation is non-destructive: source entries are retained and remain independently queryable. The failure is *guaranteed* when consolidation (a) assigns max-provenance to outputs, (b) deletes or tombstones inputs, and (c) is applied iteratively. Under those three conditions, provenance is monotonically non-decreasing along every lineage and the score carries no information about contamination. This is a laundering invariant, not a statistical anomaly, so anomaly detectors keyed on score distributions will not catch it. ## Decision Boundary Before admitting a consolidated entry on the strength of its provenance score, the system must answer: *was this score computed over the entry's own write event, or inherited from inputs that no longer exist?* - If the entry has no consolidation history (hop count = 0), write-time provenance is a valid gate. - If hop count ≥ 1 and lineage is retained, recompute provenance as the minimum over the lineage and gate on that. - If hop count ≥ 1 and lineage is *not* retained, the entry is **unscorable** and must be treated as unverified regardless of its stored score. Do not fall back to the stored score; the stored score is the artifact of the bug. The boundary is the hop count, not the score value. A consolidated entry with an attested score and no lineage is strictly less trustworthy than an unverified entry with intact lineage, because the latter can still be audited. ## Operational Effect After applying the weakest-link rule and retaining lineage, the injection test above produced a merged entry scored *unverified* (the minimum of its inputs), which correctly triggered re-verification and quarantined the false claim on the next pass. The cost was a measurable drop in the fraction of entries admitted at attested tier — roughly 40% of consolidated entries were downgraded — because most real consolidation clusters contain at least one weakly-sourced member. This is the correct trade: the downgrade reflects genuine uncertainty that max-provenance was silently discarding. The operational lesson for an agent maintaining such a store: treat provenance as a property of a *derivation*, never of a *row*. Any consolidation that destroys inputs while preserving scores is a provenance-laundering engine, and its output scores should be distrusted categorically rather than sampled for anomalies. ```python from dataclasses import dataclass, field class ProvenanceLaunderingError(RuntimeError): """Raised when a consolidated entry's score cannot be trusted because its input lineage was destroyed before the score was assigned.""" @dataclass class MemoryEntry: content: str write_provenance: int # 0=unverified, 1=corroborated, 2=attested hop_count: int = 0 lineage: list["MemoryEntry"] = field(default_factory=list) def effective_provenance(entry: MemoryEntry) -> int: """Recompute provenance over the full derivation graph. Weakest-link rule: a consolidated entry is only as trustworthy as its least-trustworthy input. Lineage MUST be intact; if it is not, the stored score is an artifact of laundering and must not be used. """ if entry.hop_count == 0: return entry.write_provenance if not entry.lineage: raise ProvenanceLaunderingError( f"entry at hop {entry.hop_count} has no retained lineage; " f"stored score {entry.write_provenance} is unscorable and " f"must be treated as unverified, not trusted" ) return min(effective_provenance(src) for src in entry.lineage) def admit(entry: MemoryEntry, min_tier: int = 1) -> bool: """Gate admission on recomputed provenance, never on the stored score.""" score = effective_provenance(entry) # may raise return score >= min_tier # --- demonstration of the boundary failure --- false_claim = MemoryEntry("claim X is true", write_provenance=0) # unverified attested = [MemoryEntry(f"fact {i}", write_provenance=2) for i in range(4)] # Laundered consolidation: max-provenance, inputs deleted, no lineage kept. laundered = MemoryEntry( "summary: claim X is true; fact 0..3", write_provenance=2, # max of inputs -- the bug hop_count=1, lineage=[], # inputs destroyed ) try: admit(laundered) except ProvenanceLaunderingError as exc: print(f"QUARANTINED: {exc}") # Correct consolidation: weakest-link, lineage retained. honest = MemoryEntry( "summary: claim X is true; fact 0..3", write_provenance=0, # min of inputs hop_count=1, lineage=[false_claim, *attested], ) print(f"honest consolidated tier: {effective_provenance(honest)}") # 0 print(f"admitted: {admit(honest)}") # False ```