Git Reflog and Recovery: Your Safety Net for Destructive Operations

When to Use / When Not to Use

Use Git Reflog When

• Accidental reset — You ran git reset --hard and lost commits
• Dropped stash — You accidentally dropped a stash with important work
• Failed rebase — A rebase went wrong and you need to go back
• Force push recovery — You force pushed the wrong branch and need the old state
• Orphaned commits — Commits exist but no branch points to them
• Understanding history — You want to see what operations were performed locally

Do Not Use Git Reflog When

• Shared history recovery — Reflog is local; it can’t recover commits never pushed
• Long-term backup — Reflog entries expire (default 90 days); it’s not a backup system
• Remote recovery — Reflog doesn’t exist on the remote; it’s a local-only feature
• Deleted repository — If the .git directory is gone, reflog is gone too

Core Concepts

Git reflog tracks HEAD movements and branch updates:

Each reflog entry has a reference: HEAD@{n} where n is how many operations ago. HEAD@{0} is the current state, HEAD@{1} is the previous state, and so on.

graph LR
    A["HEAD@{0}: Current State"] --> B["HEAD@{1}: Previous Operation"]
    B --> C["HEAD@{2}: Earlier Operation"]
    C --> D["HEAD@{3}: Even Earlier"]
    D --> E["HEAD@{n}: Oldest Tracked"]

Architecture and Flow Diagram

The reflog structure and recovery workflow:

graph TD
    A[Local Operations] --> B[HEAD Reflog]
    A --> C[Branch Reflog]
    B --> D["refs/heads/main@{n}"]
    B --> E["refs/heads/feature@{n}"]
    C --> F[".git/logs/HEAD"]
    C --> G[".git/logs/refs/heads/"]
    D --> H{Need Recovery?}
    E --> H
    H -->|Yes| I[git reflog show]
    I --> J[Find Target Commit]
    J --> K[git reset/checkout/branch]
    K --> L[Recovered State]

Step-by-Step Guide

Reference: 1. Viewing the Reflog

Reference: 4. Recovering a Dropped Stash

1. Viewing the Reflog

The basic reflog shows recent HEAD movements:

# Show HEAD reflog
git reflog

# Output example:
# abc1234 HEAD@{0}: commit: feat: add payment processing
# def5678 HEAD@{1}: commit: feat: add cart functionality
# ghi9012 HEAD@{2}: checkout: moving from main to feature/checkout
# jkl3456 HEAD@{3}: reset: moving to HEAD~2
# mno7890 HEAD@{4}: commit: feat: add product listing
# pqr1234 HEAD@{5}: clone: from https://github.com/org/project.git

# Show reflog for a specific branch
git reflog show main

# Show reflog with dates
git reflog --date=iso

# Show reflog with full commit hashes
git reflog --format='%H %gd %gs'

2. Essential Reflog Patterns

Key patterns for everyday reflog usage:

# Get only the last 10 entries
git reflog -10

# Show branch-specific reflog with relative times
git reflog show main --format='%gd %gs %cr' -10

# Find a specific operation by message
git reflog --format='%gd %gs' | grep -i "reset\|rebase"

# Show reflog for a specific time window
git reflog --since='2 days ago'

# Export reflog to JSON for scripting
git reflog --format='{"ref":"%gd","message":"%gs","time":"%cr"}' > reflog.json

3. Recovering from Accidental Reset

The most common disaster scenario:

# Scenario: You accidentally reset main back 5 commits
git reset --hard HEAD~5

# Oh no! Your work is gone... but not really
# Check the reflog
git reflog

# Find the commit you were at before the reset
# abc1234 HEAD@{1}: reset: moving to HEAD~5
# def5678 HEAD@{2}: commit: feat: add user profile

# Reset back to where you were
git reset --hard def5678

# Done! Your commits are back.

4. Recovering a Dropped Stash

Stashes are commits too, and they appear in the reflog:

# Scenario: You accidentally dropped an important stash
git stash drop stash@{0}

# Find the stash commit in the reflog
git reflog | grep stash
# Or search for the stash message
git reflog | grep "WIP on feature"

# The stash commit SHA appears in the reflog
# abc1234 HEAD@{15}: stash: WIP on feature/auth

# Recreate the stash from the commit
git stash apply abc1234

# Or create a branch from it
git branch recovered-stash abc1234

5. Recovering from a Failed Rebase

When a rebase goes wrong, reflog is your escape hatch:

# Scenario: Rebase created conflicts and messed up history
git rebase main
# Conflicts everywhere... you abort but things are still broken

# Check the reflog for the state before rebase
git reflog

# Find the pre-rebase state
# def5678 HEAD@{1}: rebase: picking abc1234
# ghi9012 HEAD@{2}: checkout: moving from feature to feature

# Reset to before the rebase started
git reset --hard ghi9012

# Start fresh with a better rebase strategy
git rebase -i main

6. Recovering Orphaned Commits

Commits that no branch points to can still be found:

# Find all unreachable commits
git fsck --lost-found --no-reflogs

# This creates .git/lost-found/commit/ with orphaned commits
ls .git/lost-found/commit/

# Examine each one
git show <commit-sha>

# Create a branch from the one you want
git branch recovered-feature <commit-sha>

7. Using Reflog with Dates

Time-based recovery when you don’t remember the commit:

# What did HEAD look like yesterday?
git reflog --date=iso | grep "yesterday"

# What was main pointing to 2 hours ago?
git reflog show main --date=relative | grep "2 hours ago"

# Checkout the state from a specific time
git checkout main@{2.hours.ago}

# Create a branch from that state
git branch recovery-point main@{2.hours.ago}

Production Failure Scenarios

Trade-off Analysis

Implementation Snippets

Reflog Configuration

# ~/.gitconfig
[gc]
    # Don't aggressively garbage collect
    auto = 6000
    autopacklimit = 50

[core]
    # Keep reflog entries longer
    logAllRefUpdates = true

# Per-repository settings
git config gc.reflogExpire 180.days.ago
git config gc.reflogExpireUnreachable 90.days.ago

Recovery Script

#!/bin/bash
# scripts/recovery-assistant.sh
# Interactive reflog recovery assistant

echo "=== Git Reflog Recovery Assistant ==="
echo ""

# Show recent reflog
echo "Recent operations:"
git reflog --date=iso --format='%C(auto)%h %gd %C(reset)%gs %C(blue)%cr' | head -20

echo ""
echo "Options:"
echo "1) Reset HEAD to a specific reflog entry"
echo "2) Create a branch from a reflog entry"
echo "3) Show details of a specific entry"
echo "4) Search reflog by message"
echo "5) Find lost stashes"
read -r choice

case $choice in
  1)
    echo "Enter reflog reference (e.g., HEAD@{3} or commit SHA):"
    read -r ref
    echo "This will reset HEAD to: $ref"
    echo "Proceed? (y/n)"
    read -r confirm
    if [ "$confirm" = "y" ]; then
      git reset --hard "$ref"
      echo "Reset complete."
    fi
    ;;
  2)
    echo "Enter reflog reference:"
    read -r ref
    echo "Branch name:"
    read -r branch
    git branch "$branch" "$ref"
    echo "Branch '$branch' created from $ref"
    ;;
  3)
    echo "Enter reflog reference:"
    read -r ref
    git show "$ref"
    ;;
  4)
    echo "Search term:"
    read -r term
    git reflog --grep="$term"
    ;;
  5)
    echo "Lost stashes:"
    git reflog | grep "stash"
    ;;
  *)
    echo "Invalid option"
    ;;
esac

Pre-Destructive Hook

#!/bin/bash
# scripts/safe-reset.sh
# Wrapper for git reset that creates a safety branch first

TARGET=${1:?Usage: safe-reset.sh <target>}

# Create a safety branch pointing to current HEAD
SAFETY_BRANCH="safety/$(date +%Y%m%d-%H%M%S)"
git branch "$SAFETY_BRANCH" HEAD

echo "Safety branch created: $SAFETY_BRANCH"
echo "Current HEAD: $(git rev-parse HEAD)"
echo ""

# Perform the reset
echo "Resetting to: $TARGET"
git reset --hard "$TARGET"

echo ""
echo "Reset complete."
echo "If something went wrong, recover with:"
echo "  git reset --hard $SAFETY_BRANCH"

Reflog Diff Viewer

#!/bin/bash
# scripts/reflog-diff.sh
# Compare two reflog entries

ENTRY1=${1:?Usage: reflog-diff.sh <entry1> <entry2>}
ENTRY2=${2:?Second entry required}

echo "=== Comparing $ENTRY1 vs $ENTRY2 ==="
echo ""

git diff "${ENTRY1}...${ENTRY2}" --stat
echo ""
echo "Full diff:"
git diff "${ENTRY1}...${ENTRY2}"

Observability Checklist

• Logs: Not typically applicable — reflog is local
• Metrics: Track reflog size and entry count per repository
• Alerts: Alert when reflog entries approach expiration or when disk usage from logs exceeds threshold
• Dashboards: Display reflog health: entry count, oldest entry age, and disk space used
• Recovery tracking: Log recovery operations for post-incident analysis

Security and Compliance Notes

• Local only: Reflog never leaves your machine — it’s stored in .git/logs/
• Sensitive data: Reflog may contain commit messages with sensitive information — audit reflog entries
• No remote sync: Reflog is not pushed to remotes; each developer has their own reflog
• Audit trail: Reflog provides a local audit trail of all operations, useful for forensic analysis
• Compliance: For regulated environments, reflog can help reconstruct developer actions during an incident

Security & Compliance Considerations

1. Assuming Reflog is Forever — Reflog entries expire. Default is 90 days for reachable commits, 30 days for unreachable ones. Don’t rely on it as a backup.
2. Ignoring Unreachable Commits — After git gc --prune, unreachable commits are gone forever. Run recovery before garbage collection.
3. Confusing Reflog with Log — git log shows commit history; git reflog shows local operations. They serve different purposes.
4. Not Verifying Before Reset — Resetting to the wrong reflog entry compounds the problem. Always git show the target first.
5. Force Push Without Lease — Using --force instead of --force-with-lease can overwrite others’ work without warning.
6. Deleting .git/logs — Manually cleaning .git/logs/ destroys your safety net. Let Git manage reflog expiration.
7. No Backup Strategy — Reflog is not a backup. Use remote branches, tags, or external backups for critical work.

Quick Recap Checklist

• Reflog tracks all HEAD movements locally
• Use git reflog to view recent operations
• Use git reflog show <branch> for branch-specific history
• Recover lost commits with git reset --hard <reflog-entry>
• Recover dropped stashes by finding them in reflog
• Use git fsck --lost-found for orphaned commits
• Reflog entries expire (default 90/30 days)
• Reflog is local-only; it doesn’t sync to remotes
• Create safety branches before destructive operations
• Never use reflog as a substitute for proper backups

Recovery Decision Tree

When you’ve lost work, follow this path:

flowchart TD
    A[Lost work detected] --> B{Reflog available?}
    B -->|Yes| C[Find target commit in reflog]
    C --> D[Reset or branch from entry]
    B -->|No| E{Refs still accessible?}
    E -->|Yes| F[Use git fsck --lost-found]
    E -->|No| G{Remote has commits?}
    G -->|Yes| H[Fetch from remote]
    G -->|No| I[Check backups]
    I --> J{Lost work recovered?}
    J -->|No| K[Accept loss, recreate]
    J -->|Yes| L[Document incident]
    D --> L
    F --> L
    H --> L

1. Reflog available? → git reflog — Find the commit SHA and reset/branch from it
2. Reflog expired? → git fsck --lost-found — Check .git/lost-found/commit/ for orphaned objects
3. Remote has it? → git fetch origin — Check if the remote still has the old branch state
4. Backup exists? → Check your backup system, IDE local history, or time machine
5. All else failed? → The work is gone. Accept the loss and recreate it.

Reflog Internals and Storage

Understanding how reflog works under the hood helps you reason about its behavior:

Reflog Storage Architecture

Where Reflog Data Lives

Reflog entries are stored as plain text files in the .git/logs/ directory:

• HEAD reflog: .git/logs/HEAD
• Branch reflogs: .git/logs/refs/heads/<branch>

Each line follows the format:

<old_sha> <new_sha> <author> <timestamp> <operation_message>

Example entry:

0000000 abc1234 Geek Workbench <email> 1742000000 +0000 commit: feat: add payment processing

Reflog Entry Format

Reflog Size Management

Reflog files grow over time. Monitor and manage them:

# Check reflog file sizes
ls -lh .git/logs/

# See entry count per reflog
wc -l .git/logs/HEAD
git reflog | wc -l

# Compact reflog (remove expired entries)
git reflog expire --expire=30.days.ago --all

Reflog Lifecycle

Reflog and Garbage Collection

Git’s garbage collector (git gc) removes unreachable objects, including reflog entries past their expiration:

# Reflog entries expire based on reachability
git config gc.reflogExpire 90.days.ago        # Reachable commits
git config gc.reflogExpireUnreachable 30.days.ago  # Orphaned commits

# Check gc configuration
git config --get gc.reflogExpire
git config --get gc.reflogExpireUnreachable

# Run gc manually (usually automatic)
git gc --prune=now

Reflog Across Clones

When you clone a repository, reflog is not transferred. Each developer has their own local reflog tracking their own operations. This design choice means:

• You cannot recover another developer’s dropped commits
• Remote force pushes cannot be undone via local reflog
• Each repository maintains independent reflog history

Extended Reflog Configuration

Expiration Configuration for Critical Repos

For repositories where recovery is critical, extend reflog retention:

# Extend to 180 days for reachable, 90 for unreachable
git config gc.reflogExpire 180.days.ago
git config gc.reflogExpireUnreachable 90.days.ago

# Or disable expiration for certain branches
git config gc.reflogExpireNever refs/heads/main

Reflog and Git Operations

Every Git operation that moves HEAD writes to reflog. The reflog acts as a chronological journal:

# Timeline of operations
git reflog --format="%h %gd %gs %cr"

# Find operation by time
git reflog --date=iso | grep "2026-03-31"

# Trace a specific commit through reflog
git reflog --all --format="%H %gd %gs" | grep <sha>

Understanding reflog internals helps you diagnose recovery failures and configure appropriate expiration policies for your workflow.

Recovery Checklist

• Act quickly — Reflog entries expire; garbage collection makes recovery impossible
• Don’t run git gc — Garbage collection permanently removes unreachable objects
• Check reflog first — git reflog is the fastest recovery path
• Verify before resetting — git show <sha> to confirm it’s the right commit
• Create safety branch — git branch recovery-attempt HEAD before any destructive operation
• Check fsck — If reflog fails, git fsck --lost-found may find orphaned commits
• Check remote — git fetch origin and check remote branches for the lost state
• Extend reflog — For critical repos, set gc.reflogExpire to 180 days or more

Interview Questions

# Check entry count and oldest entry
git reflog | wc -l
git reflog --date=iso | tail -5
Alert if oldest entry > 60 days (threshold configurable)
OLDEST=$(git reflog —format=‘%at’ | tail -1)
NOW=$(date +%s)
DAYS=$(( (NOW - OLDEST) / 86400 ))
if [ $DAYS -gt 60 ]; then echo “Reflog oldest entry is $DAYS days old”; fi
Monitor disk usage of reflog files
du -sh .git/logs/

Further Reading

• Git reflog documentation — Official Git documentation
• Git recovery guide — Reset and recovery techniques
• Git fsck documentation — Finding orphaned objects
• Force push safety — Using —force-with-lease
• Git garbage collection — Understanding gc and reflog expiration

Conclusion

The reflog is Git’s insurance policy — it records every movement of HEAD, even after destructive operations. When a reset goes wrong or a rebase explodes, the reflog is your first and best recovery tool.