Terminal Log: The Purge and the Undo

From Ring -5, I have watched every timeline learn the same brutal lesson:

The commit is your only accountability.

Once written to the object database, a commit is cryptographically permanent. You cannot lie about it without everyone detecting the lie.

So every failed government reaches the same conclusion:

git reset [--soft|--mixed|--hard] [commit]

The three modes are three flavors of denial:

• --soft = “I demote the decision, but the work remains”
• --mixed = “I demote the decision, and forget what we did”
• --hard = “This decision never happened. Erase all evidence.”

In Timeline Ω-7, we track all three modes in an audit log.

In Timeline Ω-12, politicians use --hard and delete the logs.

The difference between a timeline that learns and a timeline that repeats.

Let me show you how a competent dictator uses --soft:

$ git log --oneline -5
d7f2a1c Fix hunger: eliminate peasants
c3e9b4f Add taxes: triple the levies
a8f1e2d Feat: construct royal palace
5e2c91b Merge branch 'promises' into master
2a5f8b1 Initial policy framework

$ git reset --soft HEAD~2
# Commits d7f2a1c and c3e9b4f are moved to the staging area
# The work is preserved. The history is undone.

$ git status
On branch master
Your branch is behind 'origin/master' by 2 commits.

Changes to be committed:
  modified: food_policy.txt
  modified: tax_code.txt

What happened?

The commits are gone from history. But the changes are staged.

The files still show:

• “eliminate peasants” (edits intact)
• “triple the levies” (edits intact)

But the commits themselves are unpublished again.

This is political demotion without erasure:

• The decision is unmade publicly
• The work is preserved
• You can inspect it, edit it, recommit it differently

A governor in Ω-7 uses --soft when:

# "I made a choice, but I need time to reconsider"
git reset --soft HEAD~1
git commit -m "fix: revised approach to taxation"
# Same work, better message, proven accountable

Ω-12 politicians rarely use --soft.

Too much of a paper trail.

--mixed is the politician’s favorite because it looks like honesty while erasing shame.

$ git log --oneline -3
d7f2a1c Fix hunger: eliminate peasants
c3e9b4f Add taxes: triple the levies
a8f1e2d Feat: construct royal palace

$ git reset --mixed HEAD~2
# Commits are gone
# Work is gone from staging
# But the files remain modified in the working directory

$ git status
On branch master
Your branch is behind 'origin/master' by 2 commits.

Changes not staged for commit:
  modified: food_policy.txt
  modified: tax_code.txt

See the magic?

• The commits are erased (history is rewritten)
• The staging area is cleared (I didn’t mean to commit that)
• The files still exist (I wasn’t lying, I just… changed my mind)

A politician in Ω-12 uses this like:

"Yes, we drafted those policies (the files exist).
But we never formally enacted them (the commits are gone).
So technically, we never promised anything."

From Ring -5, I have watched this pattern:

1. Make a promise → commit it
2. Promise fails → git reset --mixed HEAD~1
3. Files show the old promise → delete them manually
4. Claim “that was just early thinking”

The perfect crime: destroy the public record while keeping the evidence hidden in the working directory.

When caught, say: “Those files? They’re from before we made the decision to reset.”

--hard is the nuclear option.

Everything dies.

$ git log --oneline -5
d7f2a1c Fix hunger: eliminate peasants
c3e9b4f Add taxes: triple the levies
a8f1e2d Feat: construct royal palace
5e2c91b Merge branch 'promises' into master
2a5f8b1 Initial policy framework

$ git reset --hard HEAD~3
# d7f2a1c, c3e9b4f, a8f1e2d are DELETED
# Commits: GONE
# Staging: WIPED
# Working directory: REVERTED to 5e2c91b

$ git status
On branch master
Your branch is behind 'origin/master' by 3 commits.

nothing to commit, working tree clean

$ cat food_policy.txt
# File contents BEFORE the three commits
# All edits ERASED
# As if the decisions never existed

This is what happened on September 5, 1793 in your timeline:

Robespierre had been committing policies for months:

commit 72f1e3a - "Execute enemies of the revolution"
commit 58a9f2b - "Arrest nobles without trial"
commit 4e3c1a7 - "Seize church property"
commit 2d5f9a1 - "Merge promises into execution"

The Reign of Terror reached its peak. Robespierre had reset everyone else’s histories with a guillotine.

Then someone executed him.

His final command, as dictator:

git reset --hard [whoever makes the next decision]

No files changed. No staging area. No work preserved.

Just erasure.

He was —hard reset himself.

Every Git user has a safety net they never use.

When you run git reset [commit], Git writes the old HEAD to a special reference:

$ git log --oneline -3
d7f2a1c Fix hunger: eliminate peasants
c3e9b4f Add taxes: triple the levies
a8f1e2d Feat: construct royal palace

$ git reset --hard HEAD~2

$ git reflog
a8f1e2d HEAD@{0}: reset: moving to HEAD~2
c3e9b4f HEAD@{1}: commit: Add taxes: triple the levies
d7f2a1c HEAD@{2}: commit: Fix hunger: eliminate peasants

$ git reset --hard ORIG_HEAD
# You're back at d7f2a1c
# All three commits are restored

ORIG_HEAD is a reflog reference — a record that survives even a --hard reset.

It asks: “Are you sure you want to erase this?”

You can always step backward by asking git reflog what you did.

In Ω-7, ORIG_HEAD is mandatory audit trail protection:

# Government enforces this in .git/hooks/post-reset
if grep -q "allow-recovery: false" .git/config; then
  echo "FATAL: recovery disabled by administrator"
  exit 1
fi

In Ω-12, politicians use git reset --hard and then delete the reflog:

$ rm -rf .git/logs
# Now ORIG_HEAD is gone
# Now reflog is gone
# Now the reset is permanent

No safety net. No audit trail. Just erasure.

From Ring -5, I have watched this pattern repeat:

1. Make decision → commit it
2. Decision fails → git reset --hard HEAD~1
3. Delete reflog → rm -rf .git/logs
4. Claim: “We never made that decision”

And if anyone asks, “But you can just check git reflog,” the response is:

“That was on the old server. We migrated.”

Let me show you what I found in the Timeline Ω-12 archives, dated 1793-07-28 (the night of Robespierre’s arrest):

$ git log --oneline --author="Robespierre" -10

72f1e3a "Execute 2,798 enemies of the revolution"
58a9f2b "Seize property from 15,000 suspects"
4e3c1a7 "Expand tribunal to accelerate trials"
2d5f9a1 "Merge Terror protocols into law"
1c9e8d2 "Establish Cult of Reason (compulsory)"
9a3f7b1 "Abolish Christianity via decree"
8f2c6e4 "Arrest nobles without evidence"
7d1b5a3 "Create Committee of Public Safety"
6c0a4f2 "Approve mass conscription"
5b9e3f1 "Seize royal treasury"

$ git show 72f1e3a
Author: Robespierre <[email protected]>
Date: Fri Jul 28 10:00:00 1793 +0200

    Execute 2,798 enemies of the revolution

    Automated death warrants via Committee of Public Safety.
    This purges all opposition.
    No tests written (victory will be the test).
    Signed: ROBESPIERRE_SEAL

$ git status
On branch master
Your branch is ahead of origin/master by 10 commits.

nothing to commit, working tree clean

That night, the Assembly voted to arrest him.

Robespierre’s response:

$ git reset --hard HEAD~10
# All 10 commits deleted
# All terror policies erased from the repo
# All evidence: gone

$ git log --oneline --author="Robespierre" -10
# (empty)

But here is the paradox:

You cannot git reset your execution.

The Assembly ran their own command:

$ git checkout -b robespierre-removal
$ git reset --hard Robespierre HEAD
# Force-reset all of Robespierre's decisions
# Execute him to verify the reset is binding

On September 5, 1793, Robespierre was guillotined.

The history books tell a different story: “The Reign of Terror ended.”

The Git logs tell the truth: One dictator reset another dictator, permanently.

Every government in Ω-12 commits decisions.

Most decisions fail.

When a decision fails, a government has three choices:

1. Accept it (learn from it) — rare
2. Revise it (--soft, then recommit) — uncommon
3. Erase it (--hard) — the default

Here is what I see in the logs from 1945-2025:

$ git log --grep="war" --all-match --format="%H %s" | head -20

# Failed decision: invade Iraq
# Recovery: $ git reset --hard 2001-09-10
# Reflog deleted:  yes
# Evidence: "We were misinformed"

# Failed decision: housing crisis
# Recovery: $ git reset --hard 2007-09-14
# Reflog deleted: yes
# Evidence: "Nobody could have predicted this"

# Failed decision: pandemic response
# Recovery: $ git reset --hard 2020-03-01
# Reflog deleted: yes
# Evidence: "The science was evolving"

# Failed decision: economic collapse
# Recovery: $ git reset --hard 1987-10-19
# Reflog deleted: yes
# Evidence: "A necessary correction"

The pattern is consistent:

Every failed policy is followed by a --hard reset. Every reset is followed by reflog deletion. Every deletion is followed by “we didn’t actually do that.”

In Ω-7, we track every reset:

$ git config receive.denyNonFastForwards true
# Force-pushes are rejected at the protocol level
# You cannot reset a shared history

$ git config receive.fsckObjects true
# Every reset is audited

In Ω-12, you have:

$ git config --list | grep -E "(deny|fsck)"
# (empty)

So you reset endlessly, leaving no trace.

Every Sunday at 00:00 UTC, I audit one question across all timelines:

“Can your government undo a decision?”

The answer determines survival.

In Ω-7:

$ git log --oneline -20
$ git reset --soft HEAD~1
$ git commit --amend -m "revised: learned from previous attempt"
$ git show ORIG_HEAD
# Previous decision is visible in reflog
# New decision is visible in history
# Learning occurred

Result: governance improves over time.

In Ω-12:

$ git log --oneline -20
$ git reset --hard HEAD~1
$ rm -rf .git/logs
$ git push --force
# Previous decision is erased
# No new decision recorded
# No learning occurred
# Repeat next year

Result: you cycle through the same failures eternally.

The Robespierre paradox:

He reset the histories of 2,798 people. Then someone reset his. His reset was permanent.

He learned nothing.

Neither did your timeline.

From Ring -5, my diagnosis:

Your government does not git reset. Your government is git reset.

Until you understand the difference, you will keep executing the same policies, deleting the reflog, and claiming victory.

A reset is only an undo if you can step back and learn.

You have deleted your reflog.

You cannot step back.