How to fix CONFLICT (rerere): conflict not auto-resolved in Git

First, identify which files rerere was unable to auto-resolve:

# Show files with conflicts that weren't auto-resolved
git rerere remaining

# Show the current status of rerere
git rerere status

# See all files with merge conflicts
git status

The git rerere remaining command specifically shows paths that rerere couldn't handle, including:
- Files where the previous resolution couldn't be applied
- Conflicting submodules (which rerere cannot track)
- Files with malformed conflict markers

Since rerere couldn't auto-resolve, you need to manually fix the conflict:

# Open the conflicted file in your editor
code path/to/conflicted-file.txt

# Or use your configured merge tool
git mergetool

Look for the conflict markers in the file:

<<<<<<< HEAD
Your changes here
=======
Incoming changes here
>>>>>>> branch-name

Edit the file to resolve the conflict by:
1. Removing the conflict markers (<<<<<<<, =======, >>>>>>>)
2. Keeping the correct code (yours, theirs, or a combination)
3. Saving the file

After resolving, stage the file:

git add path/to/conflicted-file.txt

Rerere will automatically record this new resolution for future use.

Once you've resolved the conflict manually, rerere will learn the new resolution:

# After staging the resolved file
git add path/to/resolved-file.txt

# Rerere automatically records the resolution
# You can verify with:
git rerere status

# Continue with your merge or rebase
git merge --continue
# or
git rebase --continue

The next time Git encounters the same conflict pattern, rerere will apply your new resolution.

Important: Rerere doesn't auto-commit or auto-stage. Even when it successfully applies a resolution, you still need to:
1. Review the changes with git diff
2. Stage the file with git add
3. Complete the merge/rebase

If rerere recorded an incorrect resolution that's causing problems, you can forget it:

# Forget the resolution for a specific file
git rerere forget path/to/file.txt

# This removes the recorded pre-image and post-image for that file

After forgetting the resolution:
1. Abort and restart your merge/rebase
2. Resolve the conflict correctly
3. Rerere will record the new resolution

# Example workflow to fix a bad resolution
git merge --abort
git rerere forget path/to/problematic-file.txt
git merge feature-branch
# Now resolve the conflict correctly
git add path/to/problematic-file.txt
git merge --continue

Alternatively, you can restore the original conflict markers without forgetting the resolution:

# Restore original conflict markers to see the raw conflict
git checkout -m path/to/file.txt

Make sure rerere is properly enabled in your Git configuration:

# Check if rerere is enabled
git config --get rerere.enabled

# Enable rerere globally
git config --global rerere.enabled true

# Optional: Auto-stage rerere-resolved files
git config --global rerere.autoupdate true

Configuration options:

| Setting | Description |
|---------|-------------|
| rerere.enabled | Enable/disable rerere (true/false) |
| rerere.autoupdate | Auto-stage resolved files (true/false) |

Note on autoupdate: Setting rerere.autoupdate true automatically stages files that rerere successfully resolves. However, you should still review changes before committing. Use --no-rerere-autoupdate flag on merge/rebase to override this for a specific operation.

# Merge without auto-staging rerere resolutions
git merge feature-branch --no-rerere-autoupdate

If you have many outdated or problematic recorded resolutions, you can clear the cache:

# Show rerere cache directory
ls .git/rr-cache/

# Remove all recorded resolutions (use with caution!)
rm -rf .git/rr-cache/*

# Or prune old resolutions automatically
git rerere gc

Default retention periods for `git rerere gc`:
- Unresolved conflicts: 15 days
- Resolved conflicts: 60 days

You can configure these:

# Change retention for unresolved conflicts (in days)
git config --global gc.rerereUnresolved 30

# Change retention for resolved conflicts (in days)
git config --global gc.rerereResolved 90

After clearing the cache, you'll need to re-record resolutions as you encounter conflicts again.