Terminal Log: The Faction Protocol

From Ring -5, I watch commit graphs fork and never come back together.

On 1054‑07‑16 in your calendar, a legate dropped a bull of excommunication on an altar in Constantinople, and two branches that had shared a thousand years of common history diverged with no merge commit ever scheduled.

$ git log --graph --oneline --all
* 1054-schism (HEAD -> rome)   diverged, no tracking branch
| * 1054-schism (constantinople) diverged, no tracking branch
|/
* shared-history-until-1054

Nine hundred and seventy years later, in your calendar, that graph still hasn’t merged. No conflict resolution was ever attempted. Nobody even ran git diff between the branches to see how far apart they’d drifted.

Your historians call it a schism. I call it a fork with --no-track set from the very first commit.

Before Ring -5 formalized branching, the multiverse object store had one HEAD and one history, full stop. Every disagreement had to be resolved in-place, in the same linear commit chain, before work could continue.

$ git commit -m "faction disagrees with previous commit"
fatal: cannot commit — no branch isolation exists
fatal: resolve the disagreement in HEAD or do not commit at all

This sounds disciplined. It was actually paralyzing. Every disagreement blocked every other change, because there was no way to isolate a competing idea without overwriting the only timeline that existed.

Branching wasn’t invented to enable division. It was invented so disagreement could be worked on without freezing everyone else’s progress, on the explicit assumption that it would eventually merge back.

When Git needed lightweight, cheap-to-create branches, I ported the exact mechanics of 1054 — minus the part where nobody ever reconciles.

$ git branch rome
$ git branch constantinople
$ git checkout constantinople
$ git commit -m "diverge on the filioque clause"

A branch, in Git, is nothing but a movable pointer to a commit. Creating one costs almost nothing. That was the design insight Ring -5 sent downstream: make divergence cheap, so it happens early and often, instead of building up for a thousand years and detonating once.

Linus received this in 2005 and called it “the killer feature.” I called it “obviously required, once you’ve watched a schism run uncompressed for a millennium.”

Your documentation says:

“List, create, or delete branches.”

Correct, and it undersells what a branch actually is: a name for a disagreement you intend to eventually resolve.

$ git branch -vv
* main            a1b2c3d [origin/main] canonical history
  faction-a       f8e9d21 [origin/faction-a: ahead 4] disputes clause 3
  faction-b       c4d8e37                            no tracking, gone dark

Notice faction-b has no tracking branch. Nobody upstream knows it exists. It has been committing in isolation, diverging further every day, with no plan to ever open that conversation back up.

Ω-7 requires every branch to declare, at creation, its intended merge target and a rough timeline. Ω-12 lets branches diverge indefinitely and calls the resulting distance “polarization,” as if it were weather instead of a merge that everyone kept postponing.

Four invocations, and the difference between the third and fourth has ended real alliances:

# 1. List branches already merged into HEAD — safe to remove
git branch --merged

# 2. List branches NOT merged — these still hold unresolved work
git branch --no-merged

# 3. Safe delete — refuses if the branch has unmerged commits
git branch -d faction-a

# 4. Force delete — deletes regardless, unmerged work is discarded
git branch -D faction-b

-d is Git refusing, on your behalf, to let you quietly discard a disagreement nobody resolved. -D overrides that protection. Ring -5 policy: -D requires two-signature approval. Ω-12 uses -D by default and wonders why nothing ever reconciles.

A branch left unmerged long enough stops being a branch and becomes its own repository in every way that matters, except one: it still claims to be part of the same project.

$ git log main..faction-b --oneline | wc -l
14,309
$ git log faction-b..main --oneline | wc -l
19,884

Thirty-four thousand commits of combined divergence, and still listed under the same remote, still nominally “one project.” That’s not a branch anymore. That’s two sovereign histories sharing a name out of habit.

From Ring -5: the moment a faction stops running git merge --no-ff main on any cadence, stop calling it a branch. Call it what it is — a fork that hasn’t updated its own description.

Some branches Ring -5 does not wait on. We force-delete, publish the reflog, and let the historians argue about it — this log carries no single session date; it’s been appended to across every century since 1054, this entry included, nine and a half centuries before it was written here:

$ cat .git/multiverse/branches.force-deleted
2003 timeline/omega-12/coalition-of-the-willing — no tracking ref, no merge plan
2011 timeline/omega-12/arab-spring-transition — diverged faster than review cycle
2020 timeline/omega-12/pandemic-response — 50 competing branches, zero coordination

git branch -D does not erase the commits. They stay in the reflog for the grace period, recoverable if anyone actually wants to reconcile.

Nobody ever does.

That’s not a limitation of the command.

That’s Ω‑12 telling Ring -5, every time, exactly which disagreements it never intended to resolve in the first place.