Pulling is not possible because you have unmerged files

Git shows Pulling is not possible because you have unmerged files when you run git pull while an earlier operation left conflicted files unresolved. Run git status first — it tells you which operation is stuck and what to run next.

The sections below are independent scenarios. Pick the one that matches your git status output — they are not steps in one lab sequence.

Check Which Git Operation Is In Progress

When to use this: you just saw the pull error or suspect an unfinished conflict.

git status

On branch main
You have unmerged paths.
  (fix conflicts and run "git commit")
  (use "git merge --abort" to abort the merge)

Unmerged paths:
  (use "git add <file>..." to mark resolution)
	both modified:   app.conf

no changes added to commit (use "git add" and/or "git commit -a")

Read the status message and the Unmerged paths list. After you edit each conflicted file and run git add on it, finish or cancel the operation that git status names:

The sections below walk through merge resolution in detail. Use the row that matches your git status output — do not guess from the pull error alone.

What "Pulling Is Not Possible Because You Have Unmerged Files" Means

git pull first fetches remote changes and then integrates them into your current branch, normally by merging or rebasing depending on your configuration. A simple update may fast-forward without creating a merge commit.

Git cannot start that new integration while the index still contains unresolved files from an earlier operation. If a previous pull, merge, rebase, or cherry-pick stopped on a conflict and you never finished it, files stay unmerged and another git pull is blocked.

If you retry pull before clearing that state:

git pull

error: Pulling is not possible because you have unmerged files.
hint: Fix them up in the work tree, and then use 'git add/rm <file>'
hint: as appropriate to mark resolution and make a commit.
fatal: Exiting because of an unresolved conflict.

Resolve the open conflict and complete the operation, or abort it.

Resolve the Unmerged Files and Finish the Merge

Scenario: merge in progress — you are on main, you ran git merge feature, and Git stopped on app.conf because both branches changed the same lines. You have not committed the merge yet.

The same edit → git add → verify → commit flow applies when a merge-based git pull stops on conflicts — only the branch names in the markers differ.

Step 1: Read the conflict markers

Open the unmerged file:

cat app.conf

version=1
<<<<<<< HEAD
main=true
=======
feature=true
>>>>>>> feature

Lines above <<<<<<< HEAD are unchanged. In a merge, the marker blocks work like this:

The top block is the content from your current branch (main), while the bottom block is the conflicting content Git is trying to merge from feature. Git does not pick a winner automatically — you choose what stays when you edit the file.

Step 2: Resolve the file

Remove every marker line and keep the content you need:

This example keeps both lines:

version=1
main=true
feature=true

Step 3: Stage the resolved file

Tell Git the conflict in app.conf is resolved:

git add app.conf

Confirm the file is no longer listed under Unmerged paths:

git status

On branch main
All conflicts fixed but you are still merging.
  (use "git commit" to conclude merge)

Changes to be committed:
	modified:   app.conf

app.conf is no longer under Unmerged paths. The conflict is resolved, but the merge itself is not finished until you commit.

Step 4: Complete the merge

When every former unmerged path is staged:

git commit -m "Merge branch 'feature'"

[main 8c8e2f1] Merge branch 'feature'

git status should report a clean working tree. You can run git pull again if you still need remote updates.

If the Operation Is a Rebase or Cherry-Pick

Scenario: git status mentions rebase or cherry-pick in progress, not a plain merge.

Edit each conflicted file, remove the markers, and run git add on each resolved path. Finish with the matching --continue command below.

Continue a Rebase

During a rebase, HEAD in the top conflict block represents the new base plus commits already replayed, while the other block is the commit Git is currently replaying. Resolve the content you want to keep, remove the markers, stage the file, then run git rebase --continue.

After every conflicted file is edited and staged:

git rebase --continue

Continue a Cherry-Pick

After every conflicted file is edited and staged:

git cherry-pick --continue

Abort Instead of Resolving

Scenario: the conflict is too messy, or you want to return to how the branch looked before the operation started.

After a successful abort, the unmerged state is cleared. You can try git pull again, although Git may still stop for another reason such as unrelated local changes.

git merge --abort may not perfectly reconstruct pre-merge work when substantial uncommitted changes existed before the merge began. Use abort when you prefer to discard the in-progress operation and restart from a clean branch tip.

Why Git Stash Does Not Fix Unmerged Files

Scenario: you tried git stash to clear the error so you can pull, but the unmerged state remains.

git stash saves ordinary uncommitted changes, but an unresolved conflict is different: Git's index contains multiple unmerged versions of the file. Stash normally cannot clear that state.

If git status lists Unmerged paths, edit and stage those files, complete the operation with commit or continue, or abort it. Stash helps a different pull problem — local modifications that would be overwritten — not unmerged files from an unfinished merge, rebase, or cherry-pick.

Troubleshooting

References

Git documentation: git-merge
Git documentation: git-pull
Git documentation: git-status
Git documentation: git-rebase
Git documentation: git-cherry-pick

Summary

When pull fails with unmerged files, run git status immediately. The decision table at the top names the finish or cancel command for merge, rebase, or cherry-pick.

For a merge stop, edit conflict markers, git add each resolved file, confirm Unmerged paths is gone, then commit. The same marker workflow applies when a merge-based git pull conflicts. For rebase or cherry-pick, stage fixes and run the matching --continue command, or --abort to cancel.

git stash does not clear unmerged conflict state. After you commit or abort, git pull can run again — though other local changes may still block it.