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.

Postscript (2026-10-26): the fact half, measured#

Answer 1's fact rule ("neither wins; verify against the repo and repair the stale cache") was derived from first principles. Xu & Wu (arXiv 2610.30571, empirical) supply the first controlled test, on a context file against the code rather than against memory. Agents as shipped do not apply the split. A stale CLAUDE.md/AGENTS.md convention won 90.1% of choices against the code, because a description of the code phrased as a command arrives with the policy channel's authority. Claude Code noticed the conflict in 79 of 80 runs and followed the file anyway. Stating the fact rule as an instruction, in one user-level sentence ("when documentation and existing code disagree, follow the code and report each inconsistency"), moved code-following to 91.4% and made both agents log every conflict (160/160). That is this answer's verify-then-log rule taking effect only once it is written down. The paper's model-side proposal, training models to tell rules from checkable descriptions, is the policy/fact split itself. Details on Stale Instruction File Precedence.