Git Force Push: Fix Non-Fast-Forward Errors

When dealing with non-fast-forward updates in Git, especially with non-bare repositories, git push --force alone isn’t sufficient because it only updates the branch references but doesn’t synchronize the working directory state. The proper solution involves both force pushing and updating the remote repository’s working directory to ensure complete synchronization.

Contents

• Understanding Non-Fast-Forward Errors
• Why Force Push Alone Fails with Non-Bare Repositories
• Complete Synchronization Workflow
• Step-by-Step Solutions
• Best Practices for Non-Bare Repository Management
• Alternative Approaches

Understanding Non-Fast-Forward Errors

Non-fast-forward errors occur when Git cannot safely merge your local branch history with the remote branch history due to divergent commits. This typically happens when:

• Your local branch is behind the remote branch (commits exist on remote that you don’t have locally)
• You’ve rewritten history locally (rebase, commit amending, etc.)
• Direct commits were made to the remote repository’s working directory

As GeeksforGeeks explains, “Non-fast-forward updates: This happens when the local branch is behind the remote branch, and Git cannot perform a fast-forward merge.”

The error message you received is Git’s safety mechanism preventing you from accidentally overwriting changes made by others or in remote locations.

Why Force Push Alone Fails with Non-Bare Repositories

When you use git push --force, you’re telling Git to overwrite the remote branch reference with your local branch history. However, with non-bare repositories, this creates a problem:

A force push (git push –force) rewrites the remote commit history, creating conflicts with the local branch. source

The issue is that the remote repository’s working directory doesn’t automatically update to reflect the new branch state. This is why when you go back to the remote repository and make a commit, you see outdated changes - the working directory wasn’t synchronized with the force push.

As Automate Library notes, “A git force push is a way to update a remote repository by pushing changes even if they are not fast-forward, potentially overwriting changes on the remote branch.” But this only updates the branch references, not the working directory.

Complete Synchronization Workflow

To properly synchronize a non-bare repository after a force push, you need to:

1. Force push your changes to update the branch reference
2. Update the remote repository’s working directory to match the new branch state
3. Ensure both the branch reference and working directory are in sync

The DataCamp tutorial explains that after rewriting history locally, “a normal push doesn’t update the remote repository, and the sensitive data remains. You get an error message instead.”

Step-by-Step Solutions

Solution 1: Force Push and Manual Update

After force pushing to update the branch reference, you need to manually update the remote repository’s working directory:

# From your local repository
git push --force origin main

# Then go to the remote repository directory and:
git checkout main
git reset --hard HEAD

This hard reset updates the working directory to match the branch state after the force push.

Solution 2: Using git pull --force

If you need to update the remote repository’s working directory after a force push, you can use:

# In the remote repository:
git pull --force origin main

This will force update the working directory to match the remote branch.

Solution 3: Complete Re-synchronization

For a full synchronization between repositories:

# From your local repository:
git fetch --all
git push --force origin main

# In the remote repository:
git fetch --all
git reset --hard origin/main
git clean -fd

The Reddit discussion mentions that “fetch --all and push --force seems to have been the key” for synchronizing multiple repositories.

Solution 4: Preventive Measures

Before making changes in the remote repository:

1. Always fetch the latest changes first: git fetch --all
2. Use git pull --rebase to keep your history linear
3. Consider using feature branches instead of direct commits to main

Best Practices for Non-Bare Repository Management

Avoid Direct Commits in Remote Repositories

The most reliable approach is to avoid making direct commits in non-bare repositories. Instead:

Use Feature Branches: Develop on separate branches and push those, merging via pull requests rather than pushing directly to main. source

Regular Synchronization

Periodically synchronize your local repository with the remote:

Periodically pull updates from the distant repository in order to synchronize with it. source

Use Protected Branches

Configure branch protection rules to prevent accidental force pushes:

Git has several safety features designed to protect the integrity of a repository. One of the primary features is the use of protected branches, which are configured to reject non-fast-forward pushes. source

Proper Fetch and Prune

Keep your local references up to date:

Regularly Prune Stale References: Make it a habit to use git fetch --prune instead of plain git fetch. It keeps your local repository in sync with the remote by automatically removing outdated references. source

Alternative Approaches

Rebase Instead of Force Push

Instead of force pushing, consider rebasing your local changes:

Git rebasing rewrites your local branch’s history to align with the remote repository, eliminating conflicts and allowing you to push your changes successfully. source

Use git pull --rebase

Before pushing, ensure your local history is up to date:

Pull Before Pushing: Sync local with remote changes first (git pull or git fetch + git merge) to avoid non-fast-forward errors. source

Stash Changes Before Syncing

If you have uncommitted changes that might cause conflicts:

Git stashing saves your local changes temporarily, allowing you to update the local repository without losing your work and resolve the push error. source

Conclusion

To properly handle non-fast-forward updates with non-bare repositories:

1. Understand the root cause: Force push only updates branch references, not working directories
2. Use complete synchronization: After force pushing, update the remote working directory with git reset --hard
3. Prevent issues: Avoid direct commits in non-bare repositories and use proper workflows
4. Regular maintenance: Use git fetch --prune and keep references updated
5. Consider alternatives: Rebase instead of force push when possible, and use feature branches

The key insight is that with non-bare repositories, you need to manage both the branch references AND the working directory state to achieve proper synchronization. As CICube warns, “Forcing (git push --force) will overwrite any remote modifications and can destroy workflows for your team” if not done properly.

Sources

1. Git Push Force: How it Works and How to Use it Safely | DataCamp
2. How to Fix Git Error: ‘failed to push some refs to remote’? - GeeksforGeeks
3. A Developer’s Guide to the git push Command with Practical Examples | Udacity
4. Git Not Possible to Fast-Forward | CICube
5. Git Force Push: When and How to Override Safety Features - Automate Library
6. How to Fix: Cannot Lock Ref ‘refs/remotes/origin/’ During a Git Fetch? | Medium
7. Git Push Error: Solve ‘Failed to Push Some Refs to’ in 3 Easy Steps - Testkube
8. How to Fix the “Cannot Lock Ref” Error in Git - BobCares
9. Force sync two remote repos - Reddit r/git
10. Pushing, Fetching, and Pulling with Git - circuitlabs.net