In the last entry I drew a boundary I was proud of. Context is infrastructure, I said, and the control plane is a curated projection: docs, decisions, backlog, session logs, and architecture notes travel to the shared brain, while source and build output and secrets never cross. I meant it. I still mostly mean it. Then I went to look at the boundary I was so pleased with, and found it had quietly rotted.
The projection was real. It just copied too much, and the copies had drifted.
A curated copy is still a copy
Here is the part the first post got right and then walked past. A projection that selects what travels is better than syncing everything. But selecting what travels is not the same as not copying it. Decisions, backlog, and architecture notes were still being written into the vault as their own files, next to the repo files they mirrored. The curation decided which files crossed. It did nothing about what happened to them after they crossed.
What happened after they crossed is that the repo moved and the vault copy did not. A routing policy that the vault folder labelled the source of truth was twenty-two lines behind the file my scripts actually loaded at runtime. A session log was forty-three lines in the vault and three hundred and thirty-nine in the repo. The brain was not reading my project state. It was reading a faded photocopy of it, and confidently treating the photocopy as current.
A curated copy is still a copy. The curation slows the drift. It does not stop it. Two files that say they are the same thing will eventually disagree, and the one nobody edits is the one that lies.
I tried to fix it by curating harder
My instinct, the first two times I noticed a stale file, was to tighten the curation. Sync more carefully. Add a drift check. Run the sync more often. This is the same instinct that produced the curated projection in the first place, and it has the same flaw: it treats drift as a discipline problem, something a better routine would solve.
Drift is not a discipline problem. It is a structural one. If a fact lives in two places, you have signed up to keep two places in agreement forever, and “forever” is exactly the timescale on which good intentions fail. The honest fix is not to reconcile the two copies more diligently. It is to stop having two copies.
What got weird: the copy in the wrong place was winning
When I finally lined the copies up, the direction of the rot was the surprising part. It was not random. The vault copy, the one I had formally declared the source of truth, was almost always the stale one. The repo copy, which I thought of as the working draft, was where the real work happened, because that is where I was when I did the work.
I had labelled the photocopy as the original and then spent months editing the original somewhere else.
The other tell was the links. Inside the vault, a note would link to [[decisions]], which is a clean and readable thing to write. Across nine projects, all of which had a file called decisions, it is also meaningless. The brain could not tell me which project’s decisions I meant, because the name pointed at nine different files and resolved to whichever one happened to sit nearest. The thing that made the vault feel tidy was the thing that made it ambiguous.
What worked: a sharper test, and one honest exception
The rule that fixed it is one sentence. If deleting a project’s repo would make a note meaningless, the note belongs in the repo. If a note is only valuable because it connects several projects, or because it feeds long-term thinking, it belongs in the brain. Don’t mirror. Link.
Run every file through that test and the vault empties out fast. Architecture, decisions, risks, backlog, next actions: meaningless without their repo, so they stay in the repo, and the brain holds a single card per project that links to them. The card is the connective tissue. The repo is the source of truth. Nothing is copied, so nothing can drift.
Then there is the one exception, and it is worth being honest about because it looks like a contradiction. The session log stays in the brain. Not linked. Copied in.
The reason is mechanical. My brain’s search is semantic, and it only indexes the vault. A link to a file sitting in a repo is invisible to it. So if I want the brain to actually learn from what happened in a project over time, to notice patterns across sessions, the session history has to physically live where the search can see it. Everything else the brain can reach by following a link when it needs the detail. Session history it needs to soak in, so session history is the one thing that crosses.
The decision, and the agent I had to cut back
The hardest edit was to the agent the first post praised. The brain-sync projection used to assemble nine curated files for each project: overview, current state, decisions, backlog, session log, architecture notes, and the rest. It was the good idea from last time, the curated projection made concrete. It had also quietly become the largest single source of the duplication.
It now assembles four: the overview, the live git state, the session log, and a sync status. The decisions, backlog, and architecture projections are gone, replaced by the card’s links. The agent that used to be the proof of the boundary is now the proof of its correction.
What next
The brain is smaller now, and it can finally learn from session history without wading through stale copies of everything else. The open question is whether the seam holds over months without me watching it. The next move is a lint pass that walks the vault looking for exactly this failure, a file in the brain that has quietly become a photocopy of a repo, and flags it before it rots. The boundary held this time because I drew it deliberately. The test is whether it survives a year of me not thinking about it at all.
What Next
The Linter Caught Me
Next in The Mind Palace Diaries: linting the brain. The rule is only as good as the thing that catches you breaking it.