re0-git

Rewrite a finished commit message so the log hands off on its own — in the author's own voice, not an imposed one.

Goal

Repeated amends and momentum commits leave a message bloated, stale, or padded with trivia.

re0-git

rewrites the message into a clean version that lets a fresh session continue from

git log

alone, without reading the diff. It refines what the author already writes. Only the message moves — and timestamps, per the date rule below; the tree never changes.

It is user-invoked — run it once you've decided to commit. A commit-cleanup tool in the agent's reach would bias it toward committing when it shouldn't.

Workflow

Scope the target — usually
```
HEAD
```
, sometimes a short unpushed range.
Read the change (
```
git show --stat
```
,
```
git diff
```
) and any documented commit rules. Then sample nearby non-target messages: start with 10, stop earlier if the convention is obvious, or expand only until the convention is clear.
Resolve mixed logs in this order: documented project rules, nearby commits touching the same area, then same-author commits within that convention. Do not average incompatible styles or let one author's habits override the repo.
Rewrite the message to the commit-economy (below): keep only durable handoff facts, fold supporting edits into the change they serve, and cut anything the diff or tag already proves. Give trivia no bullet of its own.
Re-commit signed, dates per the rule below. For the tip (
```
HEAD
```
):
```
git commit --amend -S --date=now
```
— the
```
--date=now
```
is what moves the author date to now; a bare
```
--amend
```
resets only the committer date and leaves the author date stale. For an older commit, keeping its dates: rebuild it —
```
GIT_AUTHOR_DATE
```
/
```
GIT_COMMITTER_DATE git commit-tree <tree> -p <parent> -S -m "<new message>"
```
— then replay every descendant onto the rebuilt commit (a non-tip rewrite is a rebase, not a ref move), or you orphan them.
Verify and report.

Rules

Never create or suggest a commit — re0-git only rewrites the message of a commit that already exists. Using it is never a reason to commit.
Message only — the tree must stay byte-identical (
```
git diff <old> <new>
```
empty); never edit content in a re0-git pass.
commit-economy — the commit-message standard this skill enforces: one bullet per real, durable change with supporting edits folded in, nothing the diff or version already proves, no co-author tags, matched to the local log's own shape (sampled above). Where that sampling finds no settled shape, fall back to a subject line, a blank line, then one
```
-
```
bullet per change on a single unwrapped line — never prose paragraphs, which explain where a log should list. A step a documented checklist already mandates for any change of this shape (registering a new skill, syncing translated docs after a source edit) is proof the process ran, not a fact about this change — fold it as a trailing clause on the bullet it serves, or drop it if that bullet already implies it; it earns a bullet of its own only when something about how it was done is itself non-obvious. The same bar governs the first draft; re0-git only enforces it on a message that already drifted past it.
Dates by position; always gpg-signed. The commit you're finalizing —
```
HEAD
```
— takes both author and committer date = now, because re-cleaning the latest commit is itself continued work. Every older commit (
```
HEAD~1
```
and back) keeps its original author + committer dates; never restamp the past.
Never rewrite pushed or shared history without explicit confirmation — it forces a force-push.

Verification

```
git diff <old-tip> <new-tip>
```
is empty — content unchanged.
Each rewritten commit is gpg-signed (
```
%G?
```
=
```
G
```
) with dates as intended.
Re-read
```
git log
```
alone, diff hidden — if any cut line turns out to be needed to follow the change, restore it.

re0-git

NPX Install

Tags

SKILL.md Content

Goal

Workflow

Rules

Verification