Find a lost commit with reflog

• Read the reflog as this repository's record of where HEAD and branches have been.
• Check a candidate commit's content before rescuing it.
• Create a branch at the measured commit without checking it out.
• Say what the reflog cannot bring back: uncommitted work and expired entries.

You are on private/lost-signup, a branch from lesson 18's result M. You committed a note, "docs: keep the signup recovery note", which added docs/signup-recovery.md, and then ran a hard reset one commit back. The note is gone from the branch, from the graph and from your files. You have no rescue branch yet, and you changed nothing else.

Everything is local and on the Free plan (GitTree asks you to sign in): no hosting account, no provider, no internet. Every identity is fictional (example.com). Never run this lesson in a real project. The hard reset in the preparation is a rehearsal in a disposable copy.

Make the changes in GitTree or with the native Git commands, not both in the same copy. Reading the result is always safe. The menu labels come from GitTree 2.0's own strings and the native commands were run with Git 2.43 in disposable copies. The GitTree steps were not run on macOS, Windows or Linux.

The reflog is a local diary of ref movements. HEAD has one, and so does each branch. It records "commit", "checkout", "reset" and the like, with the commit each one landed on. Another clone does not have your diary. A commit that no branch names can still exist, and the reflog is how you find it.

Selectors such as HEAD@{1} count entries back from now, so they change with every later operation. Read the action, the time, the ID and the file of a candidate before you use it. Do not memorise an offset as a recipe.

The reflog finds commits that were saved. It cannot find an edit that was never committed, as lesson 27 showed. Entries expire: by default Git keeps entries for commits no branch reaches for about thirty days, and a repository can change that. Do not run cleanup or expiry commands while you recover.

Creating a branch at the commit adds one ref and nothing else. The current branch, the index and your files stay where they are.

Start from a separate ordinary copy of lesson 18's result M and leave your original untouched. Create the branch, save DOC_LOST, commit it and hard-reset one commit back. This destructive preparation is for a disposable copy only.

Save only at the phase named below. These are full UTF-8/LF bodies with a final newline; never paste Markdown fences. Unchanged runnable files inherit the named input. Versions in separate variants must not overwrite the original.

docs/signup-recovery.md — DOC_LOST

# Recovered signup work

Keep a branch name before leaving useful experimental work.

Open the palette with Command+Shift+P (Ctrl+Shift+P on Ubuntu).

1. Build the rehearsal as the next section shows and note the subject of the lost commit.
2. Open the palette and run View Reflog…. The dialog "Reflog" opens with Reflog of set to HEAD; the entries are listed newest first.
3. Read the top entries. The newest says "reset" and the one below it says "commit" with the subject "docs: keep the signup recovery note". Use Show Older Entries if the list is long. Do not assume the second row is always the right one.
4. Select the commit entry. The dialog shows Show in Graph and New branch name. Show in Graph can only place a commit that a branch reaches, so for this lost commit it closes the dialog and the graph stays on M: reopen the reflog for the next step. You read the commit's file after you restore it.
5. Back in the dialog, select the same entry, type rescue/signup in New branch name and choose Restore as Branch. The notice says "Created branch rescue/signup. Undo removes it again."
6. Check the result: rescue/signup points at the lost commit, the current branch is still private/lost-signup on M, and your files are unchanged. Select the restored commit and open its file docs/signup-recovery.md: it is DOC_LOST.
7. Leave the rescue branch in place. Do not run any cleanup to tidy the graph.

For every ordinary commit in the course: Summary is the stated subject, Description is empty and the options Amend Previous Commit, Skip Hooks, Add Signed-off-by, Different Author, Push After Commit and Allow Empty Commit stay off.

Only in a separate, clean copy of lesson 18's result:

git switch --create private/lost-signup

Save DOC_LOST as docs/signup-recovery.md, then:

git add -- docs/signup-recovery.md
git commit --quiet -m "docs: keep the signup recovery note"
git reset --hard HEAD~1
git reflog show --format=%gs -2 HEAD

reset: moving to HEAD~1
commit: docs: keep the signup recovery note

List the candidates with their IDs and check the one you think is lost:

git reflog show --format='%H %gs' HEAD
git show "<lost-sha>:docs/signup-recovery.md"

Replace <lost-sha> with the ID on the "commit: docs: keep the signup recovery note" line. In this immediate example HEAD@{1} is the same commit, but that offset is not a rule. Create the rescue branch without checking it out:

git branch rescue/signup "<lost-sha>"
git show rescue/signup:docs/signup-recovery.md
git symbolic-ref --short HEAD
git status --short

The file is DOC_LOST, the branch printed is private/lost-signup and the status is empty. Your files do not show the note, because HEAD stayed on M. No expiry or cleanup command is part of this.

Where you end: rescue/signup points at the lost commit and its file is DOC_LOST. The current branch, the index and your files are exactly as they were after the reset, and nothing was pushed.

• Using HEAD@{1} as a fixed recipe instead of reading the entry.
• Resetting or checking out again before saving a branch, which adds more entries and buries the one you want.
• Expecting the reflog to hold an edit that was never committed.
• Running cleanup commands while looking for something.

If the commit is not in the list, you may be looking at the wrong ref: switch Reflog of between HEAD and the branch, and use Show Older Entries. If it is truly gone, it expired or was never committed. In the app, the notice after Restore as Branch says Undo removes the branch again.

Answer each question, then read why. Questions marked “Required” count toward completing the lesson.

1. Question 1 of 6

   Question 1 of 6

   What is the reflog?

   Choose one answer.

   A shared log that every clone and the server keep in step.

   A backup of your files.

   A local record of where HEAD and each branch have pointed.

   The same thing as the commit graph.

   Check answer
2. Question 2 of 6

   Question 2 of 6

   Which of these are true of the reflog?

   Choose every answer that applies.

   It stores edits you never committed.

   HEAD and each branch have their own.

   Old entries expire.

   Another clone of the project does not have your entries.

   Check answer
3. Question 3 of 6

   Question 3 of 6Required

   You found the lost commit in the reflog and used Restore as Branch with the name rescue/signup. What do you see?

   Choose one answer.

   rescue/signup points at the lost commit, and you are still on private/lost-signup at M with your files unchanged.

   You are now on rescue/signup and the note is back in your files.

   private/lost-signup moves forward to the lost commit.

   The reflog entry is deleted.

   Check answer
4. Question 4 of 6

   Question 4 of 6

   Change the input: you never committed the note, and then you ran the hard reset. Can the reflog bring it back?

   Choose one answer.

   Yes, through Show Older Entries.

   Yes, with HEAD@{1}.

   No. The reflog points at commits, and this content was never in one.

   Yes, by switching Reflog of to the branch.

   Check answer
5. Question 5 of 6

   Question 5 of 6Required

   You did a few more operations, then ran git branch rescue HEAD@{1}, and the file is not the one you wanted. What happened?

   Choose one answer.

   HEAD@{1} is always the right commit after a reset.

   The reflog is corrupt.

   The lost commit was deleted by the new branch.

   HEAD@{1} counts back from now, so each new operation changes what it names. Read the list and use the lost commit's ID.

   Check answer
6. Question 6 of 6

   Question 6 of 6Required

   After you created the rescue branch, which readbacks show it worked as the lesson says?

   Choose every answer that applies.

   docs/signup-recovery.md now exists in your files.

   git show rescue/signup:docs/signup-recovery.md prints the recovered note, starting with "# Recovered signup work".

   git status --short prints nothing.

   git symbolic-ref --short HEAD prints private/lost-signup.

   Check answer

Report the two newest reflog lines, the ID of the lost commit, the first line of the recovered file and the branch your checkout is on. Then say what the reflog would show for an edit you never committed.

• The reflog is a local diary of ref moves.
• Check the candidate, then branch from it.
• It finds commits, not unsaved edits.

• Reset: soft, mixed and hard (lesson 27)
• Read history without moving HEAD (lesson 8)
• Download GitTree

Reflog — سجل المراجع; rescue branch — فرع حفظ; selector — محدِّد.