Reflog: rescue work that looks lost

The interactive lesson needs JavaScript. The text below is the complete lesson.

After this lesson you can

• explain what the reflog records, and why commits that look lost usually still exist understand
• rescue commits after git reset --hard and after git branch -D by creating a branch from a reflog entry apply
• undo a rebase with ORIG_HEAD or the branch's own reflog apply
• explain why the reflog is not a backup understand

Understand: A lost pointer is not a lost commit

Here is main with three commits. Then you run git reset --hard HEAD~2 by mistake. You only meant to throw away a file change, not two commits.

main jumps back to A. B and C are now dashed: no branch reaches them, and git log no longer shows them. But they are not deleted. The commits are still in the repository. Only the label moved.

So how do you find them? Git keeps a diary called the reflog. Every time HEAD or a branch moves, Git writes a line about where it went. HEAD@{0} is where HEAD is now, and HEAD@{1} where it was one move before. Here that is C.

Before you do anything else, give the commit a name. git branch rescue HEAD@{1} makes a new branch there. B and C are reachable again, and you can look around calmly. Afterwards you can bring main back.

Deleting a branch is the same story. git branch -D rescue removes only the label, and B and C are dashed again. Git prints the ID the branch had. The branch's own reflog disappears, but HEAD's reflog still remembers the commits.

A rebase also leaves commits nobody points to: the originals. Here the plan dropped the test commit by mistake, so you want the branch back where it started. Which name points there?

A rebase moves HEAD many times, so HEAD@{1} is just the last step inside the rebase. Use ORIG_HEAD instead, the old tip Git saved before the rebase. ORIG_HEAD only remembers the latest reset, merge or rebase, so after that the branch's own reflog, feature@{1}, is the way back.

The reflog is a safety net, not a backup. It lives only in your own .git folder and is never pushed. Entries for commits no branch reaches expire by default 30 days after they were written, and then Git may delete the commits. And it only knows commits, never uncommitted changes.

Watch: Rescue after reset --hard

Here is the accident. We reset main two commits back, with hard. Both commits vanish from the branch, and their files vanish from the folder.

$ git reset --hard HEAD~2

The log shows only the first snapshot. It looks as if the work is gone. In the graph the two commits are dashed.

$ git log --oneline

Now we open the diary. Look for the two commits that vanished.

$ git reflog

The line just below the top, HEAD@{1}, is the commit Add budget. We give it a name right away, with a rescue branch. The dashed commits become solid again.

$ git branch rescue HEAD@{1}

main lies directly behind rescue on the same line, so a merge is a fast-forward. Both files are back.

$ git merge rescue

Everything is back. Once you have checked that the content is right, you can delete rescue.

$ git log --oneline

Tasks

1. Find out where HEAD was before the reset.
2. Create a branch rescue at the commit HEAD pointed to just before the reset.
3. Bring main back to the rescued commits.

Watch: Undo a rebase that went wrong

We want to tidy feature while we rebase it onto main. In the plan we delete a line by mistake, the one with the test. A missing line means drop, and Git does not warn us.

$ git rebase -i main

The test commit is gone from the branch. We want feature back exactly as it was before the rebase.

$ git log --oneline

Let's read the last five lines of the reflog. Notice how many lines the rebase wrote.

$ git reflog -5

ORIG_HEAD points at the tip from before the rebase. A hard reset moves feature back there. That is safe here, because we have nothing uncommitted.

$ git reset --hard ORIG_HEAD

The fork is back, with both login commits. Now we can rebase again, and this time keep every line in the plan.

$ git log --oneline --graph --all

Tasks

1. Look at the last five moves of HEAD.
2. Put feature back exactly as it was before the rebase.

Practise: Transfer: a café with three accidents

A café repository where three things went wrong earlier today. You are on main. Read the reflog before you act.

Tasks

1. Someone ran a hard reset one step back, twice in a row. Bring main back to the commit Add price list.
2. Earlier today the branch experiment was deleted with git branch -D. Bring it back, with its commit Try dark theme.
3. Earlier today menu was rebased onto main with the wrong range, and the commit Add menu vanished from the branch. Put menu back as it was before the rebase.

Check yourself: Recall it

git branch -D experiment printed Deleted branch experiment (was f4edb90). You regret it at once. What do you run?

• git reflog show experiment
• git branch experiment f4edb90
• Nothing, -D deleted the commits

Your laptop dies. Can a classmate rescue your unpushed commits with git reflog in their clone?

• Yes, the reflog is shared through origin
• No, the reflog exists only in your own .git folder
• Yes, if the classmate runs git fetch first

You ran git reset --hard while you had changes that were never staged or committed. What can the reflog bring back?

• The changes, from the line before the reset
• None of them, because Git never stored them
• Everything, if you act within 30 days

Review from “Branches and HEAD”: you made a commit on a detached HEAD and then switched to main. What is the best way to keep that commit?

• Nothing, Git keeps every commit forever
• Give it a branch, for example with git branch keep <id>
• Switch back to it and make a new commit on top

Common misconceptions

• “After git reset --hard the commits are deleted.” They still exist. No branch points to them, but the reflog does.
• “The reflog is a backup.” It is local, never pushed, expires, and has never seen changes you did not commit.
• “HEAD@{1} always means before my last command.” It is HEAD's previous position. A rebase moves HEAD many times.

$ git reset --hard HEAD~2
HEAD is now at a5ea1be Initial snapshot
$ git reflog
a5ea1be HEAD@{0}: reset: moving to HEAD~2
f4edb90 HEAD@{1}: commit: Add budget
ae89efa HEAD@{2}: commit: Write project plan
a5ea1be HEAD@{3}: commit (initial): Initial snapshot
$ git reflog show main
a5ea1be main@{0}: reset: moving to HEAD~2
f4edb90 main@{1}: commit: Add budget
ae89efa main@{2}: commit: Write project plan
a5ea1be main@{3}: commit (initial): Initial snapshot

$ git branch -D rescue
Deleted branch rescue (was f4edb90).
$ git branch rescue f4edb90

$ git stash
Saved working directory and index state WIP on main: a5ea1be Initial snapshot
$ git stash drop
Dropped refs/stash@{0} (11acfee0f6acd5aeedfa14a2f0f123603c56be6f)
$ git fsck --lost-found
dangling commit 11acfee0f6acd5aeedfa14a2f0f123603c56be6f
$ git log --oneline -1 11acfee
11acfee WIP on main: a5ea1be Initial snapshot
$ git stash apply 11acfee

$ echo "Draft menu: soup, bread" > menu.txt && git add menu.txt
$ git reset --hard
HEAD is now at a5ea1be Initial snapshot
$ git fsck --lost-found
dangling blob e064b3ad67676a5cbae5998a99c9b253d261c4b2
dangling commit 11acfee0f6acd5aeedfa14a2f0f123603c56be6f
$ git show e064b3ad
Draft menu: soup, bread