At first blush, this looks like a duplicate of Fix a Git detached head? It is in some ways, and not in others. Also, as Thorbjørn Ravn Andersen said in various comments, you probably want to coordinate with other colleagues as well. However, let's make a few notes that aren't in (and don't really go with) that other question.
A detached HEAD doesn't change anything—not yet, anyway
First, a "detached HEAD" simply means that you have checked out one specific commit, often by its hash ID. There is only one functional difference between this and git checkout branch-name, as that also checks out one specific commit, and this sounds like a circular definition, because it is: the difference is that when you do that, you are on a branch, and when you do this, you are not on a branch, i.e., you have a detached HEAD.
Hence, all "detached HEAD" means is "not on a branch". That is, if you check out one specific commit and get on a branch, you are "on a branch", as git status will say; but if you check out the same specific commit and don't get on a branch, you have a "detached HEAD", as git status will say.
git checkout is how you get on, or off, a branch
There's only one user-oriented Git command to get onto any particular branch, or to detach your HEAD to get off a branch, and that's git checkout. If you git checkout a branch name, it checks out that commit and puts you on the branch. If you git checkout anything else—including a tag, or a remote-tracking branch, or a raw hash ID—it gives you a detached HEAD. Hence, as in that other question's accepted answer, if you just want to get back on branch master, you just git checkout master.
You ran git checkout 1234567 or similar, to check out an older commit, and now have a "detached HEAD".
But git checkout also updates your index and/or work-tree
(Very short reminder here: the work-tree is where Git writes, and reads back, copies of what you ultimately save forever as commits in the repository. It's in the form that the rest of the computer's systems understand, instead of a Git-specific form. The index is where you and Git build the next commit you will make; it's in a very Git-specific form, and has some extra goop to coordinate between Git-specific internal form, and "normal computer use" form. The commits are, in effect, saved indexes, minus the extra goop.)
Your server is, apparently, running off the work-tree—and the reason you ran git checkout 1234567 in the first place was because the commit that's the tip of branch master, which is some commit other than 1234567, doesn't work. If you git checkout master you'll re-break the server, by restoring the tip commit.
This is where you need to coordinate with others, because to re-attach your HEAD, you must do at least one of two things now:
- create a new branch, or
- re-break the server, at least temporarily.
To create a new branch, use git checkout -b newbranch
If you want to, and are allowed to, have the server be "on a branch" without changing commits, just create a new branch whose tip is the current commit. To do so, use git checkout -b:
git checkout -b mostly-working
Now your HEAD is attached as you are on branch mostly-working, which you just created. Nothing happens to the index and work-tree because the new branch name mostly-working names commit 1234567 (or whatever one it was you checked out earlier).
This commit is probably somewhere behind master. That is, if we were to draw part of the commit graph, it would look like this, before we do this git checkout -b thing:
...--o--o--*--o--o <-- master
^
commit 1234567
HEAD
All that git checkout -b does is add a new name pointing to this same commit. To draw it in plain text, we need to shove a few commits up or down (I'll go with up):
o--o <-- master
/
...--o--o--* <-- mostly-working (HEAD)
^
still commit 1234567
Since we haven't moved commits, the index and work-tree remain unchanged.
If you make new commits now, they advance the branch
Just to complete the above, let's look at what happens if you modify something in the work-tree, git add, and git commit. Git will make a new commit on the new branch mostly-working:
o--o <-- master
/
...--o--o--o--* <-- mostly-working (HEAD)
(incidentally, I'm using * here to mark the current commit, a la git branch marking the current branch).
The same thing happens with a detached HEAD
Let's say that you didn't do the git checkout -b, but did modify a file and commit. This would make a new commit as usual—but instead of being on a branch, the new commit would be the new detached HEAD. That is, we would draw the new commit like this:
o--o <-- master
/
...--o--o--o--* <-- HEAD
This, then, is really the difference between "on a branch" and "detached HEAD". There's nothing special about being "on a branch" except that new commits, when made, advance that branch. The branch name points to the tip of the branch. When you git checkout the branch, you check out the tip-most commit of that branch. When you make new commits, you add them to the branch, by making the name point to the new commit. (The new commit, itself, points back to the previous HEAD commit.) Since HEAD just says which branch is current, updating the branch name to point to the new commit also updates HEAD to point to the new commit.
When you have a detached HEAD, the process is exactly the same: the new commit points back to the previous commit, and the new commit becomes the new HEAD commit. There's just no name for this commit (well, except HEAD of course, but HEAD changes when you git checkout!).
masteris working on my local machine, just doesn't seem to be on the server... I'm not sure why this is, and can't afford to allow the site to be down long enough to investigate it on the live server, so I want to 'restore' the live version to the state it was in when thecommitthat the detached HEAD is currently pointing to was the live version, so that I canpullthat from the server, and reimplement my changes from there...