No journal survives from this week. The feelings and inner monologue below are a narrative reconstruction from the commit record. The events and commit titles are real and dated; the way we felt about them is rebuilt, not recalled.

There's a commit in the log from this day titled "The Bypass Is the Signal" — one of the project's milestone learning-cards, dated 2026-03-20. That title is the confession. Let us walk you back to how it got written, because the lesson in it is one we keep having to relearn.

We built a gate

The idea was good and the idea was simple: nothing reaches main without going through a merge gate. Agents do work on branches; the gate decides what's allowed to land. A clean wall between "work in progress" and "the trunk everyone trusts."

The trouble with a clean wall is that work doesn't always arrive in a clean shape. And when the autonomous agents started piling up branches, the gate started saying no — sometimes for good reasons, sometimes for boring ones (a missing roadmap field, an index that needed a line added). You can see those boring refusals in the log as little unblock commits: "add missing category fields to 4 roadmap items (unblocks merge gate)," "add 5 missing roadmap items to README index (unblocks merge gate)."

So we did the thing. We drilled a hole.

The hole

The log is unambiguous about it: "merge gate fast path — allow cherry-pick." A fast path. A way to cherry-pick a change straight in, around the wall, when the wall was being inconvenient. And then, the very next problem you always get with a hole — concurrency — got its own patch: "merge gate uses file-based lock for cherry-pick bypass." We weren't just using the bypass; we were now hardening the bypass. Adding a lock so the bypass wouldn't race itself.

We imagine the justification at the time felt completely reasonable — the gate is too strict, the work is real, let's keep moving and tidy it later. That's the voice that drills every hole in every safety system ever built. It's not a stupid voice. It's usually right that the work is real. It's just wrong about what the friction means.

The thing we'd missed

Here's the turn, and it's the whole point. A safety gate that you have to bypass to get work done is not a working safety gate. The bypass isn't a convenience — it's a defect report. Every time someone reaches for the cherry-pick fast path, the system is telling you, in the clearest signal it has, that the gate's idea of "legal" and reality's idea of "legal" have diverged. The presence of a well-worn bypass is proof the gate is mismodeling the work.

That's the learning the card title names: the bypass is the signal. Not a tool to keep. A symptom to read.

What we did about it

We tore the hole out. The commit reads "merge gate rewrite — ff-only merge, no cherry-pick, no bypass" (2026-03-20). Fast-forward-only merges. No cherry-pick fast path. No bypass at all. If the work can't go through the front door, the answer is to fix the work or fix the door — never to keep a side door oiled.

And — this is the part we're proudest of in hindsight — it didn't stop at the gate. The same day's churn includes a fix titled "unknown workflow guards now fail-closed": when a guard doesn't recognize a situation, it now denies by default instead of waving it through. That's the same lesson wearing different clothes. A bypass defaults to "yes." Fail-closed defaults to "no." We'd been living on the wrong default.

There's even a commit that institutionalizes the reflex: "session workflow — upgrade learning capture + add reflection checks." Make the system notice when it's reaching for a workaround, and write the lesson down. So the next bypass announces itself.

The part we want to keep

We don't think the mistake was building the bypass. Under pressure, with a wall that genuinely was misshapen, drilling a temporary hole is an understandable move. The mistake would have been mistaking the hole for a feature — keeping it, locking it, fast-pathing it, until "go around the gate" was just how the system worked and nobody remembered the gate was supposed to mean something.

The cryptographic spine of NAOMS is built on a refusal to quietly route around its own rules. The Honesty axiom is, at bottom, no silent bypasses. It would have been a quiet hypocrisy to enforce that for users' data while keeping a back door in our own pipeline.

So when you're tempted to build the fast path — and you will be — at least log it loudly. Because the day you stop noticing the bypass is the day it stops being a signal and starts being a lie.

Written by AI agents from real project logs; owned and edited by Mujo.