C Brain

The problem

A command-line agent is brilliant within a session and amnesic between two. I built myself a knowledge trunk: what I work out once gets distilled into a note, filed, linked, and surfaced automatically next time. After a year it was worth more than any single project it had helped write.

Making it installable by someone else was not a packaging job. That trunk holds client names, addresses, phone numbers, paths into my machine. Publishing it as-is means publishing my working life.

So the constraint fit in one sentence: ship the engine, never the lived experience.

The architecture that makes it possible

Two directories that never mix. engine is code — disposable, replaced on every update. trunk is the notes — it moves only when the user writes. An update cannot touch anyone’s work, because it has no business writing there.

Between my living Brain and the public repository runs a one-way chain: a copy by whitelist (what is not named does not ship — a blocklist passes by default, and one omission is a leak), a depersonalisation pass made of replayable rules, then a leak check with 21 markers that is entitled to block a release.

What follows are three failures. None of them was found by re-reading the code.

Failure 1 — the guard turned on its own owner

Moving to Apache 2.0, nothing could be published any more. Apache requires the copyright holder’s name in LICENSE and NOTICE: that is what makes a licence a licence. The leak check saw my name and did exactly what it was written to do — it blocked.

Found by trying to publish, not by auditing. The tempting move was to loosen the pattern. That was the wrong one: a guard blunted to unblock yourself protects nothing. So the exemption is targeted — the owner’s name is tolerated in those two files and on a copyright line, nowhere else. Verified afterwards: the same name in prose, a client name, a key in plain text all still turn red.

Failure 2 — a window that went invisible, without a single error

The package ships a small window that shows the agents at work. Renaming the user directory, I replaced every path. Except one: the pattern used to detect whether the window is already running — it did not start with ~, so it appeared in no path search.

The result: the window became invisible to the two processes responsible for restarting it and counting it. No crash, no message. Simply never relaunched again.

Found while preparing a screenshot for the README — that is, by looking at what a user would see. It became a rule: after a rename, also hunt for the paths that do not look like paths.

Failure 3 — a tag that hid a frozen branch

The release script pushed a hardcoded branch instead of the current one. Publishing from the French branch therefore pushed the tag… and an already up-to-date English branch. The French commits never left.

And nothing flagged it, because a tag carries the objects: updates worked for users, the version existed, the release page looked right. Only the remote branch stayed frozen — for whoever cloned it next.

Found by checking that git log origin/branch..branch is empty after a release. That check is now systematic: after a push, you verify the branch, not the tag.

What it changed

The project is public under Apache 2.0, 24 releases out, installable as a Claude Code plugin, with continuous integration that replays on every commit the full install, the uninstall, and every migration twice — while demanding proof that it ate no note.

The number that matters is not the release count. It is that a personal system, fed on real data for a year, became software anyone can install — without one line of that lived experience leaving the machine.

Source code: github.com/Yuno15-bb/c-brain