When Knowledge Layers Disagree: Context Files vs Memory, and Conflicting Sources at Compile Time

The questions#

Two #oq/now items about the same underlying problem — which truth wins when an agent's knowledge substrates disagree:

1. Agent Context Files — how should context files and bounded memory files interact when they disagree? Memory is lossy and cache-delayed; the context file is authoritative but static. Which wins, and when?
2. LLM-as-Compiler Knowledge Base — how to handle conflicting information across sources during compilation?

The shared spine#

Both answers rest on one principle the corpus establishes independently at the security layer and at the epistemics layer: a claim's standing comes from its channel and provenance, never from its content-plausibility or its recency. The security half is the TMA-NM separation theorem — deciding authority from memory content or lineage is provably unsound, because plausible-looking content can be laundered; authority must be bound to origin at write time (Non-Malleable Memory Authority (TMA-NM)). The epistemics half is the direction-instability result — the same telemetry supports opposite headlines under defensible analysis choices, so surface content cannot adjudicate (Review as the Control Point, Pearl's "data are profoundly dumb"). The corollary both answers use: the disagreement itself is a first-class signal — Garry Tan's hygiene doctrine ("contradiction checks when new information collides with the old"; "a brain nobody curates becomes a garbage dump with great search") and this vault's own flag-contradictions-explicitly compile rule (LLM-as-Compiler Knowledge Base).

Answer 1: Context file vs memory — split by disagreement type, log every conflict#

The control-plane placement already assigns the roles: context files are the policy plane — versioned, human-reviewed, inspectable, loaded deterministically; memory files are bounded recall — "advisory, not authoritative" (Agent Context Files, Agent Control Plane Patterns: Tickets, Loops, Specs, and Memory Files). The disagreement rule follows from what kind of claim is in conflict:

• Policy disagreements: the context file wins, always. A context file is the high-integrity channel — human-authored or human-reviewed, git-versioned, changed only through a diff someone approved. Memory is agent-written, lossy by construction (Hermes caps MEMORY.md at ~2,200 chars), and writable through paths that untrusted content can influence — which makes "memory says otherwise" indistinguishable from staleness or poisoning; the laundering theorem says no content inspection can tell them apart (Non-Malleable Memory Authority (TMA-NM)). Recency cannot confer authority. An agent that lets a memory item override a context-file rule has let a low-integrity channel write up — the exact failure the Biba framing forbids.
• Fact disagreements: neither wins — ground truth does. Both layers are caches over reality, and Code as Source of Truth names the actual source of truth: the repo and live state, because that is the artifact kept current by being the thing changed. When the context file says the build uses X and memory recalls Y, the correct move is not to arbitrate between caches but to verify against the live state, then repair whichever cache is stale — memory rewritten directly; the context file through its reviewed channel. The question's "authoritative but static" tension dissolves here: the context file is authoritative about policy; about facts it is just the slower, better-reviewed cache.
• Every conflict gets logged, none silently broken. The disagreement is routed to the maintenance loop — the lint/pruning pass that is the only legitimate writer of the policy plane (Agent Context Files's pruning discipline; Tan's librarian "whose actual job is pruning"). The mid-task pattern is the deviations log: proceed under the conservative reading, record the conflict where the human will see it (Unknowns as the Agentic Bottleneck's implementation-notes.md Deviations section). A recurring context-vs-memory conflict is a signal one of the two files needs editing — swallowing it mid-session guarantees it recurs.

One asymmetry completes the rule: memory may never modify the context file, but the context file legitimately constrains memory — retention rules, what may be persisted, bounded sizes. The write path only flows down the integrity ordering, which is the same write-time origin-binding TMA-NM proves necessary, applied at the file layer.

Answer 2: Compile-time conflicts — the five-step protocol the vault already runs#

The vault's practice, made explicit and grounded in its three worked contradiction cases:

1. Align constructs before declaring a conflict. Most apparent contradictions dissolve into non-comparability. The worked example: Faros's and CMU's "opposite" under-review findings were a delta-in-count vs a level-of-share, enterprise vs open source, a cross-section vs a calendar trend, and different authorship units — "the datasets never disagreed, only the framings did" (The Under-Review Divergence: Faros's Widening Crisis vs. CMU's Convergence). Declaring a conflict before aligning metric, population, time axis, and unit manufactures contradictions that don't exist.
2. Attach provenance and evidence tier to every claim; weigh by method and incentive, never average. The vault's empirical > vendor-claim > practitioner-opinion tiers, with incentive flags attached inline ("Faros sells the platform… the conclusion conveniently favors the vendor's product" — Telemetry vs. Survey Measurement). Tan's "provenance on every fact" is the same rule; TMA-NM is its adversarial-case proof (LLM-as-Compiler Knowledge Base, Non-Malleable Memory Authority (TMA-NM)).
3. Stage genuine conflicts explicitly, on every affected page, bidirectionally. A named tension section on both pages, linked both ways — the Faros-vs-CMU contradiction lives on Review as the Control Point and on the Faros side; Ng-vs-Fung is "kept visible rather than averaged away." Silent choice is the compile-time form of laundering: it erases the provenance of the disagreement and hands future queries a confident answer with an invisible dissent.
4. Convert staged conflicts into tracked open questions. A contradiction the current sources can't settle becomes an #oq item with the resolution condition named ("worth tracking against future DORA editions") — the open-question lifecycle turns disagreement into the query/research worklist rather than a permanent shrug.
5. Resolve at compile/lint time, not query time. Contradiction checks run when new information collides with old (Tan's librarian; this vault's lint pass). Queries inherit the staged conflict — they may synthesize across it with the weights visible (as the telemetry-vs-survey resolution does), but re-adjudicating a conflict per-query reintroduces exactly the re-derivation the compiled-store architecture exists to eliminate (LLM-as-Compiler Knowledge Base's "explorations always compound").

The protocol's payoff shows in this vault's own history: contradictions staged rather than smoothed (ATLAS↔AEI, Faros↔DORA, Ng↔Fung) were later resolved by new instruments and syntheses precisely because the disagreement's structure — who claims what, on which method, with which incentive — was preserved instead of averaged into mush.

One consolidated takeaway#

Both questions ask "which wins?"; the corpus's answer is that "winning" is the wrong operation. For an agent's live substrates, authority follows the channel (policy → context file, facts → ground truth) and the conflict is logged upward. For a compiled store, conflicts are aligned, weighed, staged, tracked, and resolved only by the maintenance loop when new evidence arrives. In both cases the failure mode is the same silent choice — a plausible-content winner picked mid-task or mid-compile — and the reason it's forbidden is the same theorem: plausibility can be laundered; provenance can't.