Remote Operations

$ git clone server/support-bot.git you/support-bot
Cloning into 'you/support-bot'...
done.
$ cd you/support-bot
$ cat .git/config
[core]
	repositoryformatversion = 0
	filemode = true
	bare = false
	logallrefupdates = true
	ignorecase = true
	precomposeunicode = true
[remote "origin"]
	url = $LAB/ch12/remote-anatomy/server/support-bot.git
	fetch = +refs/heads/*:refs/remotes/origin/*
[branch "main"]
	remote = origin
	merge = refs/heads/main

$ git remote -v
origin	$LAB/ch12/remote-anatomy/server/support-bot.git (fetch)
origin	$LAB/ch12/remote-anatomy/server/support-bot.git (push)
# Refs in your clone:
$ git show-ref --abbrev
510ee94 refs/heads/main
510ee94 refs/remotes/origin/HEAD
336d5ee refs/remotes/origin/feature/reranker
510ee94 refs/remotes/origin/main
2828fba refs/tags/v0.1.0
# Refs in the server repository:
$ git -C ../../server/support-bot.git show-ref --abbrev
336d5ee refs/heads/feature/reranker
510ee94 refs/heads/main
2828fba refs/tags/v0.1.0

$ git branch -a -vv
* main                            510ee94 [origin/main] Add retrieval config
  remotes/origin/HEAD             -> origin/main
  remotes/origin/feature/reranker 336d5ee Add reranker stub
  remotes/origin/main             510ee94 Add retrieval config
$ git log --oneline --graph --decorate --all
* 336d5ee (origin/feature/reranker) Add reranker stub
* 510ee94 (HEAD -> main, tag: v0.1.0, origin/main, origin/HEAD) Add retrieval config
* 95671d3 Add retriever skeleton
* f56c1bb Add README

  server/support-bot.git  (bare)                 you/support-bot
  +---------------------------------------+      +------------------------------------------------+
  | HEAD -> refs/heads/main               |      | refs/remotes/origin/HEAD -> origin/main        |
  | refs/heads/main              510ee94  | ---> | refs/remotes/origin/main              510ee94  |
  | refs/heads/feature/reranker  336d5ee  | ---> | refs/remotes/origin/feature/reranker  336d5ee  |
  | refs/tags/v0.1.0             2828fba  | ---> | refs/tags/v0.1.0                      2828fba  |
  +---------------------------------------+      |                                                |
                                                 | refs/heads/main  510ee94   (HEAD -> main)      |
        fetch copies names left to right         +------------------------------------------------+
        push copies names right to left, only the refs you name, only if the rules allow it

$ ls -F ../../server/support-bot.git
config
description
HEAD
hooks/
info/
objects/
refs/
$ git -C ../../server/support-bot.git config get core.bare
true
$ git -C ../../server/support-bot.git status
fatal: this operation must be run in a work tree
[exit status: 128]

$ git remote set-url origin ../../server/support-bot.git
$ git remote -v
origin	../../server/support-bot.git (fetch)
origin	../../server/support-bot.git (push)
$ git config get --all --show-names --regexp "^(remote|branch)\."
remote.origin.url ../../server/support-bot.git
remote.origin.fetch +refs/heads/*:refs/remotes/origin/*
branch.main.remote origin
branch.main.merge refs/heads/main

$ git init by-hand
Initialized empty Git repository in $LAB/ch12/clone-by-hand/by-hand/.git/
$ cd by-hand
$ git remote add origin ../server/support-bot.git
$ git config get --all --show-names --regexp "^remote\."
remote.origin.url ../server/support-bot.git
remote.origin.fetch +refs/heads/*:refs/remotes/origin/*

$ git fetch origin
From ../server/support-bot
 * [new branch]      feature/reranker -> origin/feature/reranker
 * [new branch]      main             -> origin/main
 * [new tag]         v0.1.0           -> v0.1.0
$ git show-ref --abbrev
510ee94 refs/remotes/origin/HEAD
336d5ee refs/remotes/origin/feature/reranker
510ee94 refs/remotes/origin/main
2828fba refs/tags/v0.1.0
$ git symbolic-ref refs/remotes/origin/HEAD
refs/remotes/origin/main
$ git status
On branch main

No commits yet

nothing to commit (create/copy files and use "git add" to track)

$ git switch main
Already on 'main'
branch 'main' set up to track 'origin/main'.
$ git config get --all --show-names --regexp "^branch\."
branch.main.remote origin
branch.main.merge refs/heads/main
$ git branch -vv
* main 510ee94 [origin/main] Add retrieval config
$ ls
app
config.yaml
README.md

$ git clone --origin company --branch release/0.1 server/support-bot.git by-name
Cloning into 'by-name'...
done.
$ git -C by-name config get --all --show-names --regexp "^(remote|branch)\."
remote.company.url $LAB/ch12/clone-options/server/support-bot.git
remote.company.fetch +refs/heads/*:refs/remotes/company/*
branch.release/0.1.remote company
branch.release/0.1.merge refs/heads/release/0.1
$ git -C by-name branch -a -vv
* release/0.1                      510ee94 [company/release/0.1] Add retrieval config
  remotes/company/HEAD             -> company/main
  remotes/company/feature/reranker f1552ff Add reranker stub
  remotes/company/main             510ee94 Add retrieval config
  remotes/company/release/0.1      510ee94 Add retrieval config

$ git clone --branch v0.1.0 server/support-bot.git at-tag 2>&1 | head -4
Cloning into 'at-tag'...
done.
warning: refs/tags/v0.1.0 5ff339bf8f9ce7c8035bcda803ebf0afe0fc417b is not a commit!
Note: switching to '510ee948fb6354959cf03862f0ebe47c58eb2a74'.
$ git -C at-tag status
Not currently on any branch.
nothing to commit, working tree clean

$ git clone --single-branch server/support-bot.git narrow
Cloning into 'narrow'...
done.
$ git -C narrow config get --all remote.origin.fetch
+refs/heads/main:refs/remotes/origin/main
$ git -C narrow branch -r
  origin/HEAD -> origin/main
  origin/main

$ git clone --bare server/support-bot.git copy.git
Cloning into bare repository 'copy.git'...
done.
$ git -C copy.git config get --all --show-names --regexp "^(core\.bare|remote)"
core.bare true
remote.origin.url $LAB/ch12/clone-options/server/support-bot.git
$ git -C copy.git show-ref --abbrev
f1552ff refs/heads/feature/reranker
510ee94 refs/heads/main
510ee94 refs/heads/release/0.1
5ff339b refs/tags/v0.1.0

$ git clone --mirror server/support-bot.git mirror.git
Cloning into bare repository 'mirror.git'...
done.
$ git -C mirror.git config get --all --show-names --regexp "^(core\.bare|remote)"
core.bare true
remote.origin.url $LAB/ch12/clone-options/server/support-bot.git
remote.origin.tagopt --no-tags
remote.origin.fetch +refs/*:refs/*
remote.origin.mirror true
$ git -C mirror.git show-ref --abbrev
f1552ff refs/heads/feature/reranker
510ee94 refs/heads/main
510ee94 refs/heads/release/0.1
5ff339b refs/tags/v0.1.0

# The server has moved: one new commit on main and a new branch release/1.0.
$ git ls-remote --branches ../server/support-bot.git
04db75fbdfbdbffc617297a4d0d76042bff057ba	refs/heads/main
04db75fbdfbdbffc617297a4d0d76042bff057ba	refs/heads/release/1.0
$ git -C copy.git fetch
From ../../server/support-bot
 * branch            HEAD       -> FETCH_HEAD
$ git -C copy.git show-ref --abbrev
510ee94 refs/heads/main
$ git -C copy.git config get --all remote.origin.fetch || echo "(no fetch refspec configured)"
(no fetch refspec configured)

$ git -C mirror.git fetch
From ../../server/support-bot
   510ee94..04db75f  main        -> main
 * [new branch]      release/1.0 -> release/1.0
$ git -C mirror.git show-ref --abbrev
04db75f refs/heads/main
04db75f refs/heads/release/1.0

# release/1.0 has been deleted on the server.
$ git -C mirror.git remote update --prune
From ../../server/support-bot
 - [deleted]         (none)     -> release/1.0
$ git -C mirror.git show-ref --abbrev
04db75f refs/heads/main

$ cat .git/refs/remotes/origin/HEAD
ref: refs/remotes/origin/main
$ git rev-parse --abbrev-ref origin/HEAD
origin/main
$ git log --oneline -1 origin
510ee94 Add retrieval config

# The server default branch is now trunk (its HEAD was repointed).
$ git ls-remote --symref origin HEAD
ref: refs/heads/trunk	HEAD
510ee948fb6354959cf03862f0ebe47c58eb2a74	HEAD
$ git fetch
From ../../server/support-bot
 * [new branch]      trunk      -> origin/trunk
$ git rev-parse --abbrev-ref origin/HEAD
origin/main
$ git remote set-head origin --auto
'origin/HEAD' has changed from 'main' and now points to 'trunk'
$ git rev-parse --abbrev-ref origin/HEAD
origin/trunk

$ cd ../../asha/support-bot
$ git fetch --prune
From ../../server/support-bot
 - [deleted]         (none)     -> origin/main
   refs/remotes/origin/HEAD has become dangling after refs/remotes/origin/main was deleted
$ git rev-parse --verify origin/HEAD
warning: ignoring dangling symref refs/remotes/origin/HEAD
fatal: Needed a single revision
[exit status: 128]
$ git remote set-head origin --auto
'origin/HEAD' has changed from 'main' and now points to 'trunk'
$ git branch -r
  origin/HEAD -> origin/trunk
  origin/trunk

$ git remote set-head origin --delete
$ git branch -r
  origin/trunk
$ git fetch --dry-run
$ git branch -r
  origin/HEAD -> origin/trunk
  origin/trunk

$ git rev-parse --abbrev-ref origin/HEAD
origin/main
$ git config set remote.origin.followRemoteHEAD warn
$ git fetch
hint: Run 'git remote set-head origin trunk' to follow the change, or set
hint: 'remote.origin.followRemoteHEAD' configuration option to a different value
hint: if you do not want to see this message. Specifically running
hint: 'git config set remote.origin.followRemoteHEAD warn-if-not-branch-trunk'
hint: will disable the warning until the remote changes HEAD to something else.
hint: Disable this message with "git config set advice.fetchRemoteHEADWarn false"
'HEAD' at 'origin' is 'trunk', but we have 'main' locally.
$ git rev-parse --abbrev-ref origin/HEAD
origin/main

# The value suggested by the hint above, then the value described in the manual:
$ git config set remote.origin.followRemoteHEAD warn-if-not-branch-trunk
$ git fetch 2>&1 | tail -1
'HEAD' at 'origin' is 'trunk', but we have 'main' locally.
$ git config set remote.origin.followRemoteHEAD warn-if-not-trunk
$ git fetch

$ git config set remote.origin.followRemoteHEAD always
$ git fetch
$ git rev-parse --abbrev-ref origin/HEAD
origin/trunk

$ git status
On branch main
Your branch is up to date with 'origin/main'.

nothing to commit, working tree clean
$ git show-ref --abbrev
510ee94 refs/heads/main
510ee94 refs/remotes/origin/HEAD
510ee94 refs/remotes/origin/main

$ git ls-remote origin
ef22149d97a296904ccbf984cf520a1fc387e195	HEAD
698e2261b0e2c60654fc059c6016c8d743a05571	refs/heads/feature/reranker
ef22149d97a296904ccbf984cf520a1fc387e195	refs/heads/main
effd2621f6264b45f395c4ba776533482d6f466b	refs/tags/v0.1.0
ef22149d97a296904ccbf984cf520a1fc387e195	refs/tags/v0.1.0^{}

$ git fetch
From ../../server/support-bot
   510ee94..ef22149  main             -> origin/main
 * [new branch]      feature/reranker -> origin/feature/reranker
 * [new tag]         v0.1.0           -> v0.1.0
$ cat .git/FETCH_HEAD
ef22149d97a296904ccbf984cf520a1fc387e195		branch 'main' of ../../server/support-bot
698e2261b0e2c60654fc059c6016c8d743a05571	not-for-merge	branch 'feature/reranker' of ../../server/support-bot
effd2621f6264b45f395c4ba776533482d6f466b	not-for-merge	tag 'v0.1.0' of ../../server/support-bot

$ git show-ref --abbrev
510ee94 refs/heads/main
ef22149 refs/remotes/origin/HEAD
698e226 refs/remotes/origin/feature/reranker
ef22149 refs/remotes/origin/main
effd262 refs/tags/v0.1.0
$ git status
On branch main
Your branch is behind 'origin/main' by 1 commit, and can be fast-forwarded.
  (use "git pull" to update your local branch)

nothing to commit, working tree clean

$ git log --oneline --graph --decorate --all
* 698e226 (origin/feature/reranker) Add reranker stub
* ef22149 (tag: v0.1.0, origin/main, origin/HEAD) Implement retrieval
* 510ee94 (HEAD -> main) Add retrieval config
* 95671d3 Add retriever skeleton
* f56c1bb Add README
$ git log --oneline main..origin/main
ef22149 Implement retrieval

$ git reflog show origin/main
ef22149 refs/remotes/origin/main@{0}: fetch: fast-forward
$ git reflog show main
510ee94 main@{0}: clone: from $LAB/ch12/fetch-anatomy/server/support-bot.git

$ git merge --ff-only origin/main
Updating 510ee94..ef22149
Fast-forward
 app/retriever.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)
$ git status -sb
## main...origin/main

  before git fetch                                  after git fetch

  server   ...---510ee94---ef22149   main           server   unchanged
  you      ...---510ee94             main           you      ...---510ee94---ef22149
                 origin/main                                      main      origin/main
                                                                  (HEAD)    tag: v0.1.0

$ git fetch origin main
From ../../server/support-bot
 * branch            main       -> FETCH_HEAD
   ef22149..3f226f1  main       -> origin/main
$ cat .git/FETCH_HEAD
3f226f11ffbe22690dad919d155901b0885028cc		branch 'main' of ../../server/support-bot
$ git status -sb
## main...origin/main [behind 1]

$ git fetch ../../server/support-bot.git feature/reranker
From ../../server/support-bot
 * branch            feature/reranker -> FETCH_HEAD
$ cat .git/FETCH_HEAD
698e2261b0e2c60654fc059c6016c8d743a05571		branch 'feature/reranker' of ../../server/support-bot
$ git log --oneline -1 FETCH_HEAD
698e226 Add reranker stub

$ git ls-remote --tags origin
e4e2561179ddf88e121ea1ebbb2485416f92363c	refs/tags/experiment/rejected-1
f858aefbb840dff2a665a6adbbaf8103bb645238	refs/tags/v0.1.0
99b643016420ca155f7432cf4555c1991c7679a5	refs/tags/v0.1.0^{}
$ git fetch
From ../../server/support-bot
   510ee94..99b6430  main       -> origin/main
$ git show-ref --abbrev --tags
5ff339b refs/tags/v0.1.0

$ git fetch --tags
From ../../server/support-bot
 * [new tag] experiment/rejected-1 -> experiment/rejected-1
 ! [rejected] v0.1.0                -> v0.1.0  (would clobber existing tag)
[exit status: 1]
$ git show-ref --abbrev --tags
e4e2561 refs/tags/experiment/rejected-1
5ff339b refs/tags/v0.1.0

$ git fetch --tags --force
From ../../server/support-bot
 t [tag update]      v0.1.0     -> v0.1.0
$ git show-ref --abbrev --tags
e4e2561 refs/tags/experiment/rejected-1
f858aef refs/tags/v0.1.0

Observed behavior : "Your branch is up to date with 'origin/main'", yet the server has newer commits.
Git state         : refs/heads/main and refs/remotes/origin/main name the same commit; the server's
                    refs/heads/main names a newer one.
Mechanism         : git status compares two local refs. It opens no connection.
Root cause        : origin/main is a record of your last fetch, not a view of the server.
Why Git does this : every command except the transfer commands works offline and instantly; a status
                    that needed the network would be slow, and useless on a plane.
Correct fix       : git fetch, then read the status again; or git ls-remote origin main to ask the
                    server without changing anything.
Prevention        : fetch before any decision that depends on the server (tagging, releasing, cutting
                    a hotfix branch). In scripts compare against git ls-remote, never against a
                    remote-tracking ref of unknown age.

$ git switch -c feature/eval-harness
Switched to a new branch 'feature/eval-harness'
$ git branch -vv
* feature/eval-harness b83418c Add eval harness entry point
  main                 510ee94 [origin/main] Add retrieval config
$ git push
fatal: The current branch feature/eval-harness has no upstream branch.
To push the current branch and set the remote as upstream, use

    git push --set-upstream origin feature/eval-harness

To have this happen automatically for branches without a tracking
upstream, see 'push.autoSetupRemote' in 'git help config'.

[exit status: 128]

$ git push -u origin feature/eval-harness
To ../../server/support-bot.git
 * [new branch]      feature/eval-harness -> feature/eval-harness
branch 'feature/eval-harness' set up to track 'origin/feature/eval-harness'.
$ git config get --all --show-names --regexp "^branch\.feature/eval-harness\."
branch.feature/eval-harness.remote origin
branch.feature/eval-harness.merge refs/heads/feature/eval-harness
$ git branch -vv
* feature/eval-harness b83418c [origin/feature/eval-harness] Add eval harness entry point
  main                 510ee94 [origin/main] Add retrieval config

$ git rev-parse --abbrev-ref @{upstream}
origin/feature/eval-harness
$ git rev-parse --symbolic-full-name @{u} @{push}
refs/remotes/origin/feature/eval-harness
refs/remotes/origin/feature/eval-harness
$ git log --oneline @{u}..
fc5bd70 Add first eval case
$ git status -sb
## feature/eval-harness...origin/feature/eval-harness [ahead 1]

$ git switch feature/reranker
Switched to a new branch 'feature/reranker'
branch 'feature/reranker' set up to track 'origin/feature/reranker'.
$ git config get --all --show-names --regexp "^branch\.feature/reranker\."
branch.feature/reranker.remote origin
branch.feature/reranker.merge refs/heads/feature/reranker

$ git switch -c docs/runbook main
Switched to a new branch 'docs/runbook'
$ git rev-parse --abbrev-ref @{u}
fatal: no upstream configured for branch 'docs/runbook'
[exit status: 128]
$ git branch -u origin/main
branch 'docs/runbook' set up to track 'origin/main'.
$ git status -sb
## docs/runbook...origin/main
$ git branch --unset-upstream
$ git status -sb
## docs/runbook

$ git config set push.autoSetupRemote true
$ git push
To ../../server/support-bot.git
 * [new branch]      docs/runbook -> docs/runbook
branch 'docs/runbook' set up to track 'origin/docs/runbook'.
$ git branch -vv
* docs/runbook         9416de1 [origin/docs/runbook] Start the runbook
  feature/eval-harness fc5bd70 [origin/feature/eval-harness: ahead 1] Add first eval case
  feature/reranker     336d5ee [origin/feature/reranker] Add reranker stub
  main                 510ee94 [origin/main] Add retrieval config

$ git switch -c latency-fix origin/main
Switched to a new branch 'latency-fix'
branch 'latency-fix' set up to track 'origin/main'.
$ git branch -vv
  docs/runbook         9416de1 [origin/docs/runbook] Start the runbook
  feature/eval-harness fc5bd70 [origin/feature/eval-harness: ahead 1] Add first eval case
  feature/reranker     336d5ee [origin/feature/reranker] Add reranker stub
* latency-fix          70d0911 [origin/main: ahead 1] Set request timeout
  main                 510ee94 [origin/main] Add retrieval config
$ git push
fatal: The upstream branch of your current branch does not match
the name of your current branch.  To push to the upstream branch
on the remote, use

    git push origin HEAD:main

To push to the branch of the same name on the remote, use

    git push origin HEAD

To choose either option permanently, see push.default in 'git help config'.

To avoid automatically configuring an upstream branch when its name
won't match the local branch, see option 'simple' of branch.autoSetupMerge
in 'git help config'.

[exit status: 128]

$ git -c push.default=upstream push --dry-run
To ../../server/support-bot.git
   510ee94..70d0911  latency-fix -> main
$ git -c push.default=current push --dry-run
To ../../server/support-bot.git
 * [new branch]      latency-fix -> latency-fix
$ git -c push.default=nothing push --dry-run
fatal: You didn't specify any refspecs to push, and push.default is "nothing".
[exit status: 128]
$ git -c push.default=matching push --dry-run
To ../../server/support-bot.git
   b83418c..fc5bd70  feature/eval-harness -> feature/eval-harness

$ git pull
From ../../server/support-bot
   510ee94..ef22149  main       -> origin/main
Updating 510ee94..ef22149
Fast-forward
 app/retriever.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)
$ git reflog -1
ef22149 HEAD@{0}: pull: Fast-forward
$ git reflog show origin/main -1
ef22149 refs/remotes/origin/main@{0}: pull: fast-forward

# Asha has pushed "Raise top_k to 8"; you have committed "Add dev requirements".
$ git status -sb
## main...origin/main [ahead 1]
$ git pull
From ../../server/support-bot
   ef22149..527a708  main       -> origin/main
hint: You have divergent branches and need to specify how to reconcile them.
hint: You can do so by running one of the following commands sometime before
hint: your next pull:
hint:
hint:   git config pull.rebase false  # merge
hint:   git config pull.rebase true   # rebase
hint:   git config pull.ff only       # fast-forward only
hint:
hint: You can replace "git config" with "git config --global" to set a default
hint: preference for all repositories. You can also pass --rebase, --no-rebase,
hint: or --ff-only on the command line to override the configured default per
hint: invocation.
fatal: Need to specify how to reconcile divergent branches.
[exit status: 128]

$ git status -sb
## main...origin/main [ahead 1, behind 1]
$ git log --oneline --graph --decorate --all -4
* c498de8 (HEAD -> main) Add dev requirements
| * 527a708 (origin/main, origin/HEAD) Raise top_k to 8
|/  
* ef22149 Implement retrieval
* 510ee94 Add retrieval config

$ git pull --ff-only
hint: Diverging branches can't be fast-forwarded, you need to either:
hint:
hint: 	git merge --no-ff
hint:
hint: or:
hint:
hint: 	git rebase
hint:
hint: Disable this message with "git config set advice.diverging false"
fatal: Not possible to fast-forward, aborting.
[exit status: 128]

$ git pull --no-rebase
Merge made by the 'ort' strategy.
 config.yaml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)
$ git log --oneline --graph --decorate -5
*   7044e06 (HEAD -> main) Merge branch 'main' of ../../server/support-bot
|\  
| * 527a708 (origin/main, origin/HEAD) Raise top_k to 8
* | c498de8 Add dev requirements
|/  
* ef22149 Implement retrieval
* 510ee94 Add retrieval config
$ git reflog -2
7044e06 HEAD@{0}: pull --no-rebase: Merge made by the 'ort' strategy.
c498de8 HEAD@{1}: commit: Add dev requirements

$ git reset --hard ORIG_HEAD
HEAD is now at c498de8 Add dev requirements
$ git status -sb
## main...origin/main [ahead 1, behind 1]

$ git pull --rebase
Rebasing (1/1)
Successfully rebased and updated refs/heads/main.
$ git log --oneline --graph --decorate -4
* 45eec24 (HEAD -> main) Add dev requirements
* 527a708 (origin/main, origin/HEAD) Raise top_k to 8
* ef22149 Implement retrieval
* 510ee94 Add retrieval config
$ git reflog -4
45eec24 HEAD@{0}: pull --rebase (finish): returning to refs/heads/main
45eec24 HEAD@{1}: pull --rebase (pick): Add dev requirements
527a708 HEAD@{2}: pull --rebase (start): checkout 527a708c84be3e9847d2e65528c2d8cb7ce6b863
c498de8 HEAD@{3}: reset: moving to ORIG_HEAD

  diverged, after the fetch half:          --no-rebase (merge):                --rebase:

        c498de8    main (HEAD)                   c498de8---7044e06  main       ef22149---527a708---45eec24  main
       /                                        /         /                              origin/main
  ef22149---527a708  origin/main           ef22149---527a708  origin/main      (45eec24 replaces c498de8)

  --ff-only: refuses, nothing moves

$ sh ../../try-pull.sh
pull.rebase=unset pull.ff=unset -> fatal: Need to specify how to reconcile divergent branches.
pull.rebase=unset pull.ff=only  -> fatal: Not possible to fast-forward, aborting.
pull.rebase=unset pull.ff=false -> merge commit
pull.rebase=unset pull.ff=true  -> merge commit
pull.rebase=false pull.ff=unset -> merge commit
pull.rebase=false pull.ff=only  -> fatal: Not possible to fast-forward, aborting.
pull.rebase=false pull.ff=false -> merge commit
pull.rebase=false pull.ff=true  -> merge commit
pull.rebase=true  pull.ff=unset -> rebase
pull.rebase=true  pull.ff=only  -> fatal: Not possible to fast-forward, aborting.
pull.rebase=true  pull.ff=false -> rebase
pull.rebase=true  pull.ff=true  -> rebase

$ sh ../../try-pull.sh --rebase | cut -d'>' -f2 | sort | uniq -c
  12  rebase
$ sh ../../try-pull.sh --no-rebase | cut -d'>' -f2 | sort | uniq -c
  12  merge commit
$ sh ../../try-pull.sh --ff-only | cut -d'>' -f2 | sort | uniq -c
  12  fatal: Not possible to fast-forward, aborting.

  your clone                                          server (git-receive-pack)
  1 read the server's refs                    <----   advertisement: refs/heads/main = 719650d
  2 client rules for each ref:
      fast-forward? tag exists? lease holds?
      no  -->  "! [rejected]"   (nothing is sent)
  3 send "<old> <new> <ref>" + packfile       ---->   4 objects go into a quarantine directory
                                                      5 ref still at <old>?  receive.deny* settings?
                                                        pre-receive and update hooks?
                                                        no  -->  "! [remote rejected]"
                                                      6 refs updated; post-receive hooks run
  7 move refs/remotes/origin/<branch>         <----   report: ok refs/heads/main

$ git status -sb
## main...origin/main [ahead 1]
$ git push
To ../../server/support-bot.git
 ! [rejected]        main -> main (fetch first)
error: failed to push some refs to '../../server/support-bot.git'
hint: Updates were rejected because the remote contains work that you do not
hint: have locally. This is usually caused by another repository pushing to
hint: the same ref. If you want to integrate the remote changes, use
hint: 'git pull' before pushing again.
hint: See the 'Note about fast-forwards' in 'git push --help' for details.
[exit status: 1]
$ git status -sb
## main...origin/main [ahead 1]

$ git fetch
From ../../server/support-bot
   510ee94..719650d  main       -> origin/main
$ git status -sb
## main...origin/main [ahead 1, behind 1]
$ git push
To ../../server/support-bot.git
 ! [rejected]        main -> main (non-fast-forward)
error: failed to push some refs to '../../server/support-bot.git'
hint: Updates were rejected because the tip of your current branch is behind
hint: its remote counterpart. If you want to integrate the remote changes,
hint: use 'git pull' before pushing again.
hint: See the 'Note about fast-forwards' in 'git push --help' for details.
[exit status: 1]

# The client side of the conversation during the rejected push:
$ GIT_TRACE_PACKET=1 git push 2>&1 | sed -n 's/.*packet: *\(push[<>]\)/\1/p' | fold -s -w 76
push< 719650da56c2910ce851d3c0f47ec270ebb88945 
refs/heads/main\0report-status report-status-v2 delete-refs side-band-64k 
quiet atomic ofs-delta object-format=sha1 agent=git/2.55.0-Darwin
push< 0000
push> 0000

$ git rebase origin/main
Rebasing (1/1)
Successfully rebased and updated refs/heads/main.
$ git push --dry-run
To ../../server/support-bot.git
   719650d..8bf53be  main -> main
$ git push
To ../../server/support-bot.git
   719650d..8bf53be  main -> main
$ git status -sb
## main...origin/main
$ git reflog show origin/main
8bf53be refs/remotes/origin/main@{0}: update by push
719650d refs/remotes/origin/main@{1}: fetch: fast-forward

$ git branch
* hotfix/timeout
  main
$ git push origin master
error: src refspec master does not match any
error: failed to push some refs to '../../server/support-bot.git'
[exit status: 1]
$ git push origin hotfix
error: src refspec hotfix does not match any
error: failed to push some refs to '../../server/support-bot.git'
[exit status: 1]

# A new repository with a remote but no commit yet:
$ git init -q ../../scratch
$ git -C ../../scratch remote add origin ../server/support-bot.git
$ git -C ../../scratch push -u origin main
error: src refspec main does not match any
error: failed to push some refs to '../server/support-bot.git'
[exit status: 1]

$ git switch --detach
HEAD is now at c19ab53 Set request timeout
$ git push
fatal: You are not currently on a branch.
To push the history leading to the current (detached HEAD)
state now, use

    git push origin HEAD:<name-of-remote-branch>

[exit status: 128]
$ git push origin HEAD:refs/heads/hotfix/timeout
To ../../server/support-bot.git
 * [new branch]      HEAD -> hotfix/timeout
$ git switch -
Switched to branch 'hotfix/timeout'

$ git push orign hotfix/timeout
fatal: 'orign' does not appear to be a git repository
fatal: Could not read from remote repository.

Please make sure you have the correct access rights
and the repository exists.
[exit status: 128]
$ git remote
origin

$ git push origin --delete feature/eval-harness
To ../../server/support-bot.git
 - [deleted]         feature/eval-harness
$ git branch -vv
  feature/eval-harness edc57ed [origin/feature/eval-harness: gone] Add eval harness entry point
* main                 510ee94 [origin/main] Add retrieval config
  release/0.1          510ee94 [origin/release/0.1] Add retrieval config
$ git ls-remote --branches origin
510ee948fb6354959cf03862f0ebe47c58eb2a74	refs/heads/main
510ee948fb6354959cf03862f0ebe47c58eb2a74	refs/heads/release/0.1

$ git tag -a v0.2.0 -m "Release 0.2.0"
$ git tag nightly
$ git push
Everything up-to-date
$ git ls-remote --tags origin

$ git push origin v0.2.0
To ../../server/support-bot.git
 * [new tag]         v0.2.0 -> v0.2.0
$ git tag -a v0.2.1 -m "Release 0.2.1"
$ git push --follow-tags
To ../../server/support-bot.git
   510ee94..7aec635  main -> main
 * [new tag]         v0.2.1 -> v0.2.1
$ git ls-remote --tags origin
e4cbd524cd2ce2e1757843ad5ee0c371484fd6f9	refs/tags/v0.2.0
510ee948fb6354959cf03862f0ebe47c58eb2a74	refs/tags/v0.2.0^{}
3b6d020723c18782f5703818be9f01f07146e2f7	refs/tags/v0.2.1
7aec635a45c70d81f8a60b04ce73a0dcfdbb15c8	refs/tags/v0.2.1^{}

$ git tag -f -a v0.2.0 -m "Release 0.2.0, retagged"
Updated tag 'v0.2.0' (was e4cbd52)
$ git push origin v0.2.0
To ../../server/support-bot.git
 ! [rejected]        v0.2.0 -> v0.2.0 (already exists)
error: failed to push some refs to '../../server/support-bot.git'
hint: Updates were rejected because the tag already exists in the remote.
[exit status: 1]

# main is behind the server (Asha pushed); release/0.1 is one commit ahead.
$ git config set advice.pushUpdateRejected false
$ git push --atomic origin main release/0.1
error: atomic push failed for ref refs/heads/main. status: 5
To ../../server/support-bot.git
 ! [rejected]        main -> main (fetch first)
 ! [rejected]        release/0.1 -> release/0.1 (atomic push failed)
error: failed to push some refs to '../../server/support-bot.git'
[exit status: 1]
$ git ls-remote --branches origin
bb34561abaa5aa4fabf570a6dd8417f74b6abb81	refs/heads/main
510ee948fb6354959cf03862f0ebe47c58eb2a74	refs/heads/release/0.1

$ git push origin main release/0.1
To ../../server/support-bot.git
   510ee94..0c10e7b  release/0.1 -> release/0.1
 ! [rejected]        main -> main (fetch first)
error: failed to push some refs to '../../server/support-bot.git'
[exit status: 1]
$ git ls-remote --branches origin
bb34561abaa5aa4fabf570a6dd8417f74b6abb81	refs/heads/main
0c10e7b5f43e3b449f31c690a82fee2a5af38d81	refs/heads/release/0.1

$ git status -sb
## main...origin/main [ahead 1, behind 1]
$ git -C ../../server/support-bot.git config set receive.denyNonFastForwards true
$ git push --force
remote: error: denying non-fast-forward refs/heads/main (you should pull first)        
To ../../server/support-bot.git
 ! [remote rejected] main -> main (non-fast-forward)
error: failed to push some refs to '../../server/support-bot.git'
[exit status: 1]

$ git push origin HEAD:refs/heads/tmp/scratch
To ../../server/support-bot.git
 * [new branch]      HEAD -> tmp/scratch
$ git -C ../../server/support-bot.git config set receive.denyDeletes true
$ git push origin --delete tmp/scratch
remote: error: denying ref deletion for refs/heads/tmp/scratch        
To ../../server/support-bot.git
 ! [remote rejected] tmp/scratch (deletion prohibited)
error: failed to push some refs to '../../server/support-bot.git'
[exit status: 1]

$ git -C ../../server/support-bot.git config unset receive.denyNonFastForwards
$ cp ../../pre-receive ../../server/support-bot.git/hooks/pre-receive
$ chmod +x ../../server/support-bot.git/hooks/pre-receive
$ cat ../../server/support-bot.git/hooks/pre-receive
#!/bin/sh
# Refuse every direct update of main. Standard input has one line per ref:
#   <old-id> <new-id> <ref-name>
while read old new ref; do
  if [ "$ref" = "refs/heads/main" ]; then
    echo "policy: main only changes through a reviewed merge" >&2
    exit 1
  fi
done
exit 0
$ git push --force
remote: policy: main only changes through a reviewed merge        
To ../../server/support-bot.git
 ! [remote rejected] main -> main (pre-receive hook declined)
error: failed to push some refs to '../../server/support-bot.git'
[exit status: 1]

# What your clone believes the server has, and what the server reports during a dry run:
$ git rev-parse --short origin/docs/runbook
17783a7
$ git push --dry-run --force origin docs/runbook
To ../../server/support-bot.git
 + 73f4877...ca3cabb docs/runbook -> docs/runbook (forced update)
$ git cat-file -t 73f4877
fatal: Not a valid object name 73f4877
[exit status: 128]
$ git push --force origin docs/runbook
To ../../server/support-bot.git
 + 73f4877...ca3cabb docs/runbook -> docs/runbook (forced update)
$ git reflog show origin/docs/runbook
ca3cabb refs/remotes/origin/docs/runbook@{0}: update by push
17783a7 refs/remotes/origin/docs/runbook@{1}: update by push

# The overwritten commit still exists: on the server, unreachable, and in the clone of Asha.
$ git -C ../../server/support-bot.git fsck --unreachable --no-reflogs | grep commit
unreachable commit 45de2936b350e2be1d34e97b160ee2af2d260b6d
unreachable commit 17783a7948f064198be834dfcce16644cba85192
unreachable commit 73f4877fe6ae70fc95aacb4cd751411a277c5f0e
$ git -C ../../asha/support-bot log --oneline -2 docs/runbook
73f4877 Add paging section
17783a7 Start the runbook

# Asking the server for the overwritten commit by its object ID:
$ git fetch origin 73f4877
fatal: couldn't find remote ref 73f4877
[exit status: 128]
$ git -c protocol.version=0 fetch origin 73f4877fe6ae70fc95aacb4cd751411a277c5f0e
error: Server does not allow request for unadvertised object 73f4877fe6ae70fc95aacb4cd751411a277c5f0e
[exit status: 1]
$ git fetch origin 73f4877fe6ae70fc95aacb4cd751411a277c5f0e
From ../../server/support-bot
 * branch            73f4877fe6ae70fc95aacb4cd751411a277c5f0e -> FETCH_HEAD
$ git log --oneline -2 FETCH_HEAD
73f4877 Add paging section
17783a7 Start the runbook

$ git log --oneline --decorate -3
12cdd3d (HEAD -> feature/prompt-cache, origin/feature/prompt-cache) wip: ttl
bdbe39f Add prompt cache
510ee94 (origin/main, origin/HEAD, main) Add retrieval config
$ git branch backup/prompt-cache
$ git reset --soft HEAD~2
$ git commit -q -m "Add prompt cache with TTL"
$ git log --oneline --graph --decorate --all -4
* 1a1fa49 (HEAD -> feature/prompt-cache) Add prompt cache with TTL
| * 12cdd3d (origin/feature/prompt-cache, backup/prompt-cache) wip: ttl
| * bdbe39f Add prompt cache
|/  
* 510ee94 (origin/main, origin/HEAD, main) Add retrieval config
$ git status -sb
## feature/prompt-cache...origin/feature/prompt-cache [ahead 1, behind 2]

# Asha, in her clone: git push   (her test commit lands on top of "wip: ttl")
$ git push --force-with-lease
To ../../server/support-bot.git
 ! [rejected]        feature/prompt-cache -> feature/prompt-cache (stale info)
error: failed to push some refs to '../../server/support-bot.git'
[exit status: 1]
$ git rev-parse --short origin/feature/prompt-cache
12cdd3d
$ git ls-remote origin feature/prompt-cache
833bc8ad64cffe287b9e4280a0c93cb6537d625b	refs/heads/feature/prompt-cache

# What an editor or a scheduled job does behind your back:
$ git fetch
From ../../server/support-bot
   12cdd3d..833bc8a  feature/prompt-cache -> origin/feature/prompt-cache
$ git status -sb
## feature/prompt-cache...origin/feature/prompt-cache [ahead 1, behind 3]

$ git push --force-with-lease --force-if-includes
To ../../server/support-bot.git
 ! [rejected]        feature/prompt-cache -> feature/prompt-cache (remote ref updated since checkout)
error: failed to push some refs to '../../server/support-bot.git'
hint: Updates were rejected because the tip of the remote-tracking branch has
hint: been updated since the last checkout. If you want to integrate the
hint: remote changes, use 'git pull' before pushing again.
hint: See the 'Note about fast-forwards' in 'git push --help' for details.
[exit status: 1]
$ git push --force-with-lease=feature/prompt-cache:backup/prompt-cache
To ../../server/support-bot.git
 ! [rejected]        feature/prompt-cache -> feature/prompt-cache (stale info)
error: failed to push some refs to '../../server/support-bot.git'
[exit status: 1]

$ git push --force-with-lease
To ../../server/support-bot.git
 + 833bc8a...1a1fa49 feature/prompt-cache -> feature/prompt-cache (forced update)
[exit status: 0]
$ git ls-remote origin feature/prompt-cache
1a1fa4964ca5cb5de17112e84ab62441aeac53fd	refs/heads/feature/prompt-cache

Observed behavior : git push --force-with-lease overwrote a teammate's commit that I had never looked at.
Git state         : refs/remotes/origin/feature/prompt-cache had been moved to the teammate's commit
                    by a fetch; my local branch did not contain that commit.
Mechanism         : the lease compares the server's ref with my remote-tracking ref. After the fetch
                    they were equal, so the condition "nothing changed since I looked" was true.
Root cause        : a remote-tracking ref records what my clone has fetched, not what I have seen or
                    integrated. Any fetch renews the lease.
Why Git does this : the remote-tracking ref is the only record Git has of "the state I based my work on",
                    and the manual says so and calls the forms without an explicit value experimental.
Correct fix       : restore the overwritten commit (below); nothing can be un-pushed.
Prevention        : --force-with-lease together with --force-if-includes (or push.useForceIfIncludes=true),
                    or the explicit --force-with-lease=<ref>:<commit>; and never rewrite a branch
                    that someone else pushes to without telling them.

$ git reflog show origin/feature/prompt-cache
1a1fa49 refs/remotes/origin/feature/prompt-cache@{0}: update by push
833bc8a refs/remotes/origin/feature/prompt-cache@{1}: fetch: fast-forward
12cdd3d refs/remotes/origin/feature/prompt-cache@{2}: update by push
$ ls ../../server/support-bot.git/logs
ls: ../../server/support-bot.git/logs: No such file or directory
[exit status: 1]
$ git -C ../../server/support-bot.git fsck --unreachable --no-reflogs | grep commit
unreachable commit 833bc8ad64cffe287b9e4280a0c93cb6537d625b
unreachable commit 12cdd3d76a43de79f4cbd643a62ead3eb6d44dec
unreachable commit bdbe39fab454ec59484b2f16d05ff952de9cd6e6

# Both branches were reworded locally. Asha has pushed to docs/runbook; you have not fetched.
$ git branch -vv
  docs/runbook         ca3cabb [origin/docs/runbook: ahead 1, behind 1] Start the on-call runbook
* feature/prompt-cache 886feab [origin/feature/prompt-cache: ahead 1, behind 1] Add prompt cache module
  main                 510ee94 [origin/main] Add retrieval config
$ git config set advice.pushUpdateRejected false
$ git push --force-with-lease=feature/prompt-cache origin feature/prompt-cache docs/runbook
To ../../server/support-bot.git
 + 45de293...886feab feature/prompt-cache -> feature/prompt-cache (forced update)
 ! [rejected]        docs/runbook -> docs/runbook (fetch first)
error: failed to push some refs to '../../server/support-bot.git'
[exit status: 1]
$ git ls-remote --branches origin
73f4877fe6ae70fc95aacb4cd751411a277c5f0e	refs/heads/docs/runbook
886feab6db3f48e44fe9bb9310d582ba8d094014	refs/heads/feature/prompt-cache
510ee948fb6354959cf03862f0ebe47c58eb2a74	refs/heads/main

$ git push --force-with-lease=release/1.0: origin main:refs/heads/release/1.0
To ../../server/support-bot.git
 * [new branch]      main -> release/1.0
$ git push --force-with-lease=release/1.0: origin feature/prompt-cache:refs/heads/release/1.0
To ../../server/support-bot.git
 ! [rejected]        feature/prompt-cache -> release/1.0 (stale info)
error: failed to push some refs to '../../server/support-bot.git'
[exit status: 1]

$ cd ../../asha/support-bot
$ git status -sb
## feature/prompt-cache...origin/feature/prompt-cache
$ git fetch
From ../../server/support-bot
 + 833bc8a...1a1fa49 feature/prompt-cache -> origin/feature/prompt-cache  (forced update)
$ git status -sb
## feature/prompt-cache...origin/feature/prompt-cache [ahead 3, behind 1]
$ git log --oneline --graph --decorate --all -5
* 1a1fa49 (origin/feature/prompt-cache) Add prompt cache with TTL
| * 833bc8a (HEAD -> feature/prompt-cache) Add cache test
| * 12cdd3d wip: ttl
| * bdbe39f Add prompt cache
|/  
* 510ee94 (origin/main, origin/HEAD, main) Add retrieval config

$ git reflog show origin/feature/prompt-cache
1a1fa49 refs/remotes/origin/feature/prompt-cache@{0}: fetch: forced-update
833bc8a refs/remotes/origin/feature/prompt-cache@{1}: update by push
$ git merge-base --fork-point origin/feature/prompt-cache
833bc8ad64cffe287b9e4280a0c93cb6537d625b
$ git pull --rebase
Successfully rebased and updated refs/heads/feature/prompt-cache.
$ git log --oneline --decorate -3
1a1fa49 (HEAD -> feature/prompt-cache, origin/feature/prompt-cache) Add prompt cache with TTL
510ee94 (origin/main, origin/HEAD, main) Add retrieval config
95671d3 Add retriever skeleton

Observed behavior : after a teammate's forced push, git pull --rebase succeeded and my commit vanished
                    from the branch.
Git state         : I had pushed that commit earlier, so the reflog of origin/feature/prompt-cache
                    contains it ("update by push"). The server's branch was then replaced.
Mechanism         : pull --rebase replays only the commits after the fork point, and the fork point is
                    found through the reflog of the remote-tracking ref (git merge-base --fork-point).
                    It was my own pushed commit, so nothing was left to replay.
Root cause        : Git cannot tell "the upstream removed this commit on purpose" from "someone
                    overwrote it by accident". The reflog says only: it was upstream once, it is not now.
Why Git does this : without the rule, everyone downstream of a deliberately rebased branch would
                    re-apply the commits that the upstream had dropped.
Correct fix       : the commit is in my reflog; cherry-pick it onto the new tip and push.
Prevention        : after any "(forced update)" line, look before integrating:
                    git log --oneline --graph HEAD @{u}. Do not pull on a branch that others rewrite.

$ git reflog -4
1a1fa49 HEAD@{0}: pull --rebase (finish): returning to refs/heads/feature/prompt-cache
1a1fa49 HEAD@{1}: pull --rebase (start): checkout 1a1fa4964ca5cb5de17112e84ab62441aeac53fd
833bc8a HEAD@{2}: commit: Add cache test
12cdd3d HEAD@{3}: checkout: moving from main to feature/prompt-cache
$ git cherry-pick HEAD@{2}
[feature/prompt-cache 9074b47] Add cache test
 Date: Mon Sep 7 10:15:00 2026 +0530
 1 file changed, 2 insertions(+)
 create mode 100644 tests/test_cache.py
$ git push
To ../../server/support-bot.git
   1a1fa49..9074b47  feature/prompt-cache -> feature/prompt-cache
$ git log --oneline --decorate -3
9074b47 (HEAD -> feature/prompt-cache, origin/feature/prompt-cache) Add cache test
1a1fa49 Add prompt cache with TTL
510ee94 (origin/main, origin/HEAD, main) Add retrieval config

$ git remote add staging ../../staging-box
$ git push staging main
remote: error: refusing to update checked out branch: refs/heads/main        
remote: error: By default, updating the current branch in a non-bare repository        
remote: is denied, because it will make the index and work tree inconsistent        
remote: with what you pushed, and will require 'git reset --hard' to match        
remote: the work tree to HEAD.        
remote: 
remote: You can set the 'receive.denyCurrentBranch' configuration variable        
remote: to 'ignore' or 'warn' in the remote repository to allow pushing into        
remote: its current branch; however, this is not recommended unless you        
remote: arranged to update its work tree to match what you pushed in some        
remote: other way.        
remote: 
remote: To squelch this message and still keep the default behaviour, set        
remote: 'receive.denyCurrentBranch' configuration variable to 'refuse'.        
To ../../staging-box
 ! [remote rejected] main -> main (branch is currently checked out)
error: failed to push some refs to '../../staging-box'
[exit status: 1]

$ git push staging main:refs/heads/incoming/timeout
To ../../staging-box
 * [new branch]      main -> incoming/timeout
$ git -C ../../staging-box branch -vv
  incoming/timeout c19ab53 Set request timeout
* main             510ee94 [origin/main] Add retrieval config

$ git -C ../../staging-box config set receive.denyCurrentBranch updateInstead
$ git push staging main
To ../../staging-box
   510ee94..c19ab53  main -> main
$ git -C ../../staging-box log --oneline -1
c19ab53 Set request timeout
$ ls ../../staging-box/app
retriever.py
settings.py

$ printf 'hotfix typed directly on the box\n' >> ../../staging-box/README.md
$ git push staging main
To ../../staging-box
 ! [remote rejected] main -> main (Working directory has unstaged changes)
error: failed to push some refs to '../../staging-box'
[exit status: 1]

# The Fork button, in plain Git: a server-side clone.
$ git clone --bare server/support-bot.git forks/you/support-bot.git
Cloning into bare repository 'forks/you/support-bot.git'...
done.
$ git clone forks/you/support-bot.git you/support-bot
Cloning into 'you/support-bot'...
done.
$ cd you/support-bot
$ git remote add upstream ../../server/support-bot.git
$ git fetch upstream
From ../../server/support-bot
 * [new branch]      main       -> upstream/main
$ git remote -v
origin	../../forks/you/support-bot.git (fetch)
origin	../../forks/you/support-bot.git (push)
upstream	../../server/support-bot.git (fetch)
upstream	../../server/support-bot.git (push)

$ git show-ref --abbrev
510ee94 refs/heads/main
510ee94 refs/remotes/origin/HEAD
510ee94 refs/remotes/origin/main
510ee94 refs/remotes/upstream/HEAD
510ee94 refs/remotes/upstream/main

$ git config set remote.pushDefault origin
$ git config set push.default current
$ git switch -c feature/streaming upstream/main
Switched to a new branch 'feature/streaming'
branch 'feature/streaming' set up to track 'upstream/main'.
# One commit made here: "Add streaming responses".
$ git push
To ../../forks/you/support-bot.git
 * [new branch]      feature/streaming -> feature/streaming
$ git rev-parse --abbrev-ref @{upstream} @{push}
upstream/main
origin/feature/streaming
$ git config get --all --show-names --regexp "^(remote\.pushdefault|push\.default|branch\.feature)"
remote.pushdefault origin
push.default current
branch.feature/streaming.remote upstream
branch.feature/streaming.merge refs/heads/main

        upstream = server/support-bot.git        shared; you fetch from it
              |
              |  git fetch upstream, git pull --rebase         (@{upstream} = upstream/main)
              v
        you/support-bot     feature/streaming
              |
              |  git push                                      (@{push} = origin/feature/streaming)
              v
        origin = forks/you/support-bot.git       yours; a pull request offers this branch to upstream

$ git branch -vv
* feature/streaming 08b274c [upstream/main: ahead 1] Add streaming responses
  main              510ee94 [origin/main] Add retrieval config
$ git config set remote.pushDefault origin
$ git push --dry-run
To ../../forks/you/support-bot.git
 * [new branch]      feature/streaming -> feature/streaming
$ git rev-parse --abbrev-ref @{push}
fatal: cannot resolve 'simple' push to a single destination
[exit status: 128]

$ git config set push.default current
$ git push
To ../../forks/you/support-bot.git
 * [new branch]      feature/streaming -> feature/streaming
$ git rev-parse --abbrev-ref @{upstream} @{push}
upstream/main
origin/feature/streaming
$ git for-each-ref --format='%(refname:short): pull from %(upstream:short), push to %(push:short)' refs/heads
feature/streaming: pull from upstream/main, push to origin/feature/streaming
main: pull from origin/main, push to origin/main

$ git config set branch.feature/streaming.pushRemote upstream
$ git push --dry-run
To ../../server/support-bot.git
 * [new branch]      feature/streaming -> feature/streaming
$ git config unset branch.feature/streaming.pushRemote
$ git push --dry-run
Everything up-to-date

$ git config set status.compareBranches "@{upstream} @{push}"
$ git fetch upstream
From ../../server/support-bot
   510ee94..f11a751  main       -> upstream/main
$ git status
On branch feature/streaming
Your branch and 'upstream/main' have diverged,
and have 1 and 1 different commits each, respectively.
  (use "git pull" if you want to integrate the remote branch with yours)

Your branch is up to date with 'origin/feature/streaming'.

nothing to commit, working tree clean

$ git pull --rebase
Rebasing (1/1)
Successfully rebased and updated refs/heads/feature/streaming.
$ git status -sb
## feature/streaming...upstream/main [ahead 1]
$ git push
To ../../forks/you/support-bot.git
 ! [rejected]        feature/streaming -> feature/streaming (non-fast-forward)
error: failed to push some refs to '../../forks/you/support-bot.git'
hint: Updates were rejected because the tip of your current branch is behind
hint: its remote counterpart. If you want to integrate the remote changes,
hint: use 'git pull' before pushing again.
hint: See the 'Note about fast-forwards' in 'git push --help' for details.
[exit status: 1]
$ git push --force-with-lease
To ../../forks/you/support-bot.git
 + 5d5414c...4ce24f2 feature/streaming -> feature/streaming (forced update)

$ git switch main
Switched to branch 'main'
Your branch is up to date with 'origin/main'.
$ git merge --ff-only upstream/main
Updating 510ee94..f11a751
Fast-forward
 config.yaml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)
$ git push
To ../../forks/you/support-bot.git
   510ee94..f11a751  main -> main
$ git log --oneline --graph --decorate --all -4
* 4ce24f2 (origin/feature/streaming, feature/streaming) Add streaming responses
* f11a751 (HEAD -> main, upstream/main, upstream/HEAD, origin/main, origin/HEAD) Raise top_k to 8
* 510ee94 Add retrieval config
* 95671d3 Add retriever skeleton

$ git remote add upstream ../../server/support-bot.git
$ git remote set-url --push upstream DISABLED
$ git remote -v
origin	../../server/support-bot.git (fetch)
origin	../../server/support-bot.git (push)
upstream	../../server/support-bot.git (fetch)
upstream	DISABLED (push)
$ git config get --all --show-names --regexp "^remote\.upstream\."
remote.upstream.url ../../server/support-bot.git
remote.upstream.fetch +refs/heads/*:refs/remotes/upstream/*
remote.upstream.pushurl DISABLED
$ git push upstream main
fatal: 'DISABLED' does not appear to be a git repository
fatal: Could not read from remote repository.

Please make sure you have the correct access rights
and the repository exists.
[exit status: 128]

$ git remote set-url --add --push origin ../../server/support-bot.git
$ git remote set-url --add --push origin ../../backup/support-bot.git
$ git remote -v
origin	../../server/support-bot.git (fetch)
origin	../../server/support-bot.git (push)
origin	../../backup/support-bot.git (push)
upstream	../../server/support-bot.git (fetch)
upstream	DISABLED (push)
$ git push origin main
To ../../server/support-bot.git
   510ee94..c19ab53  main -> main
To ../../backup/support-bot.git
   510ee94..c19ab53  main -> main

$ git config set url.../../server/.insteadOf https://git.example.com/acme/
$ git remote add company https://git.example.com/acme/support-bot.git
$ git config get remote.company.url
https://git.example.com/acme/support-bot.git
$ git remote get-url company
../../server/support-bot.git
$ git ls-remote company main
c19ab53ef3dba868f5f8b8c60d19a9687069f366	refs/heads/main

$ git remote add backup ../../backup/support-bot.git
$ git config set remotes.offsite "company backup"
$ git fetch offsite
Fetching company
From ../../server/support-bot
 * [new branch]      main       -> company/main
Fetching backup
From ../../backup/support-bot
 * [new branch]      main       -> backup/main
$ git push --dry-run offsite main
Pushing to company
Everything up-to-date
Pushing to backup
Everything up-to-date

$ git branch -u company/main
branch 'main' set up to track 'company/main'.
$ git remote rename company canonical
$ git branch -r
  backup/HEAD -> backup/main
  backup/main
  canonical/HEAD -> canonical/main
  canonical/main
  origin/HEAD -> origin/main
  origin/main
$ git config get --all --show-names --regexp "^(remote\.canonical|branch\.main)\."
branch.main.remote canonical
branch.main.merge refs/heads/main
remote.canonical.url https://git.example.com/acme/support-bot.git
remote.canonical.fetch +refs/heads/*:refs/remotes/canonical/*

$ git remote remove canonical
$ git branch -r
  backup/HEAD -> backup/main
  backup/main
  origin/HEAD -> origin/main
  origin/main
$ git branch -vv
* main c19ab53 Set request timeout
$ git remote remove canonical
error: No such remote: 'canonical'
[exit status: 2]

$ git branch -r
  origin/HEAD -> origin/main
  origin/feature/eval-harness
  origin/feature/reranker
  origin/main
  origin/release
$ git ls-remote --branches origin
edc57ed67d3ef2451ee0ad599a1769c54adc92c5	refs/heads/feature/eval-harness
52d3c1ada36809341bc3fac2af09a619cf85ec00	refs/heads/main
52d3c1ada36809341bc3fac2af09a619cf85ec00	refs/heads/release/1.0

$ git remote show origin
* remote origin
  Fetch URL: ../../server/support-bot.git
  Push  URL: ../../server/support-bot.git
  HEAD branch: main
  Remote branches:
    feature/eval-harness                 tracked
    main                                 tracked
    refs/remotes/origin/feature/reranker stale (use 'git remote prune' to remove)
    refs/remotes/origin/release          stale (use 'git remote prune' to remove)
    release/1.0                          new (next fetch will store in remotes/origin)
  Local branches configured for 'git pull':
    feature/eval-harness merges with remote feature/eval-harness
    feature/reranker     merges with remote feature/reranker
    main                 merges with remote main
  Local refs configured for 'git push':
    feature/eval-harness pushes to feature/eval-harness (up to date)
    main                 pushes to main                 (local out of date)

$ git fetch
error: some local refs could not be updated; try running
 'git remote prune origin' to remove any old, conflicting branches
From ../../server/support-bot
   510ee94..52d3c1a  main        -> origin/main
 ! [new branch]      release/1.0 -> origin/release/1.0  (unable to update local ref)
[exit status: 1]

$ git remote prune --dry-run origin
Pruning origin
URL: ../../server/support-bot.git
 * [would prune] origin/feature/reranker
 * [would prune] origin/release
$ git fetch --prune
From ../../server/support-bot
 - [deleted]         (none)      -> origin/feature/reranker
 - [deleted]         (none)      -> origin/release
 * [new branch]      release/1.0 -> origin/release/1.0
$ git branch -r
  origin/HEAD -> origin/main
  origin/feature/eval-harness
  origin/main
  origin/release/1.0

$ git branch -vv
  feature/eval-harness edc57ed [origin/feature/eval-harness] Add eval harness entry point
  feature/reranker     5176652 [origin/feature/reranker: gone] Add reranker stub
* main                 510ee94 [origin/main: behind 2] Add retrieval config
$ git for-each-ref --format="%(refname:short) %(upstream:track)" refs/heads
feature/eval-harness 
feature/reranker [gone]
main [behind 2]

$ git switch feature/reranker
Switched to branch 'feature/reranker'
Your branch is based on 'origin/feature/reranker', but the upstream is gone.
  (use "git branch --unset-upstream" to fixup)
$ git pull
Your configuration specifies to merge with the ref 'refs/heads/feature/reranker'
from the remote, but no such ref was fetched.
[exit status: 1]
$ git push
To ../../server/support-bot.git
 * [new branch]      feature/reranker -> feature/reranker
$ git ls-remote --branches origin
edc57ed67d3ef2451ee0ad599a1769c54adc92c5	refs/heads/feature/eval-harness
5176652525c1216c70b16c80ecb9625c8f350595	refs/heads/feature/reranker
52d3c1ada36809341bc3fac2af09a619cf85ec00	refs/heads/main
52d3c1ada36809341bc3fac2af09a619cf85ec00	refs/heads/release/1.0

$ git push origin --delete feature/reranker
To ../../server/support-bot.git
 - [deleted]         feature/reranker
$ git switch main
Switched to branch 'main'
Your branch is behind 'origin/main' by 2 commits, and can be fast-forwarded.
  (use "git pull" to update your local branch)
$ git pull --ff-only
Updating 510ee94..52d3c1a
Fast-forward
 app/reranker.py | 2 ++
 1 file changed, 2 insertions(+)
 create mode 100644 app/reranker.py
$ git branch -d feature/reranker
Deleted branch feature/reranker (was 5176652).

$ git config set fetch.prune true
# You have deleted feature/eval-harness on the server in the meantime.
$ git fetch
From ../../server/support-bot
 - [deleted]         (none)     -> origin/feature/eval-harness
$ git branch -vv
  feature/eval-harness edc57ed [origin/feature/eval-harness: gone] Add eval harness entry point
* main                 52d3c1a [origin/main] Merge branch feature/reranker

$ git clone --single-branch server/support-bot.git you/support-bot
Cloning into 'you/support-bot'...
done.
$ cd you/support-bot
$ git config get --all remote.origin.fetch
+refs/heads/main:refs/remotes/origin/main
$ git branch -r
  origin/HEAD -> origin/main
  origin/main
$ git switch release/0.1
fatal: invalid reference: release/0.1
[exit status: 128]

$ git remote set-branches --add origin release/0.1
$ git config get --all remote.origin.fetch
+refs/heads/main:refs/remotes/origin/main
+refs/heads/release/0.1:refs/remotes/origin/release/0.1
$ git fetch
From ../../server/support-bot
 * [new branch]      release/0.1 -> origin/release/0.1
$ git remote set-branches origin "*"
$ git config get --all remote.origin.fetch
+refs/heads/*:refs/remotes/origin/*
$ git fetch
From ../../server/support-bot
 * [new branch]      dependabot/pip/requests-2.33 -> origin/dependabot/pip/requests-2.33

# Asha has rewritten the tip of release/0.1 on the server. Your refspec, without its +:
$ git config set remote.origin.fetch "refs/heads/*:refs/remotes/origin/*"
$ git fetch
From ../../server/support-bot
 ! [rejected] release/0.1 -> origin/release/0.1  (non-fast-forward)
[exit status: 1]
$ git config set remote.origin.fetch "+refs/heads/*:refs/remotes/origin/*"
$ git fetch
From ../../server/support-bot
 + d5379f1...6c2ddc6 release/0.1 -> origin/release/0.1  (forced update)

$ git config set --append remote.origin.fetch "^refs/heads/dependabot/*"
$ git branch -r -d origin/dependabot/pip/requests-2.33
Deleted remote-tracking branch origin/dependabot/pip/requests-2.33 (was 510ee94).
$ git fetch
$ git branch -r
  origin/HEAD -> origin/main
  origin/main
  origin/release/0.1

$ git ls-remote origin "refs/pull/*"
a3b0283892821a8f9fc95bda5760237390817915	refs/pull/7/head
$ git fetch origin pull/7/head:pr-7
From ../../server/support-bot
 * [new ref]         refs/pull/7/head -> pr-7
$ git config set --append remote.origin.fetch "+refs/pull/*/head:refs/remotes/origin/pr/*"
$ git fetch
From ../../server/support-bot
 * [new ref]         refs/pull/7/head -> origin/pr/7
$ git config get --all remote.origin.fetch
+refs/heads/*:refs/remotes/origin/*
^refs/heads/dependabot/*
+refs/pull/*/head:refs/remotes/origin/pr/*

# Two commits made on main: "Start the runbook", then "Add on-call notes".
$ git push origin HEAD~1:main
To ../../server/support-bot.git
   510ee94..73bb3c8  HEAD~1 -> main
$ git push origin HEAD:refs/heads/review/oncall-notes
To ../../server/support-bot.git
 * [new branch]      HEAD -> review/oncall-notes
$ git push origin :review/oncall-notes
To ../../server/support-bot.git
 - [deleted]         review/oncall-notes
$ git status -sb
## main...origin/main [ahead 1]

# One scheme per URL, in the order given:
$ git url-parse -c scheme https://github.com/acme/support-bot.git git@github.com:acme/support-bot.git ssh://git@github.com/acme/support-bot.git file:///srv/git/support-bot.git
https
ssh
ssh
file
$ git url-parse -c host git@github.com:acme/support-bot.git
github.com
$ git url-parse -c path git@github.com:acme/support-bot.git
/acme/support-bot.git
$ git url-parse -c scheme ../../server/support-bot.git
fatal: '../../server/support-bot.git' is not a URL; if you meant a local repository, use a 'file://' URL with an absolute path
[exit status: 128]

# Which program does Git start for the other side of the conversation?
$ GIT_TRACE=1 git fetch 2>&1 | sed -n 's/.*trace: run_command: //p' | head -1
unset GIT_PREFIX; GIT_PROTOCOL=version=2 'git-upload-pack '\''../../server/support-bot.git'\'''
$ GIT_TRACE=1 git push 2>&1 | sed -n 's/.*trace: run_command: //p' | head -1
unset GIT_PREFIX; 'git-receive-pack '\''../../server/support-bot.git'\'''

$ GIT_TRACE_PACKET=1 git fetch 2>&1 | sed -n 's/.*packet: *\(fetch[<>]\)/\1/p'
fetch< version 2
fetch< agent=git/2.55.0-Darwin
fetch< ls-refs=unborn
fetch< fetch=shallow wait-for-done
fetch< server-option
fetch< object-format=sha1
fetch< 0000
fetch> command=ls-refs
fetch> agent=git/2.55.0-Darwin
fetch> object-format=sha1
fetch> 0001
fetch> peel
fetch> symrefs
fetch> unborn
fetch> ref-prefix refs/heads/
fetch> ref-prefix refs/heads/main
fetch> ref-prefix refs/tags/
fetch> ref-prefix HEAD
fetch> 0000
fetch< 719650da56c2910ce851d3c0f47ec270ebb88945 HEAD symref-target:refs/heads/main
fetch< 719650da56c2910ce851d3c0f47ec270ebb88945 refs/heads/main
fetch< 0000
fetch> command=fetch
fetch> agent=git/2.55.0-Darwin
fetch> object-format=sha1
fetch> 0001
fetch> thin-pack
fetch> no-progress
fetch> include-tag
fetch> ofs-delta
fetch> want 719650da56c2910ce851d3c0f47ec270ebb88945
fetch> have 510ee948fb6354959cf03862f0ebe47c58eb2a74
fetch> have 95671d3baba80df6b53e79e6583c1a6e01fdf451
fetch> have f56c1bb279a37dc704979733d4314bd9c1e2893d
fetch> 0000
fetch< acknowledgments
fetch< ACK 510ee948fb6354959cf03862f0ebe47c58eb2a74
fetch< ready
fetch< 0001
fetch< packfile

# One local commit, already rebased onto the fetched origin/main:
$ GIT_TRACE_PACKET=1 git push 2>&1 | sed -n 's/.*packet: *\(push[<>]\)/\1/p' | cut -c1-110
push< 719650da56c2910ce851d3c0f47ec270ebb88945 refs/heads/main\0report-status report-status-v2 delete-refs sid
push< 0000
push> 719650da56c2910ce851d3c0f47ec270ebb88945 b109fc2446651be551de03e7834e6db8804e1cd1 refs/heads/main\0 repo
push> 0000
push< unpack ok
push< ok refs/heads/main
push< 0000

$ git bundle create ../../support-bot.bundle HEAD --branches
$ git bundle verify ../../support-bot.bundle
../../support-bot.bundle is okay
The bundle contains these 3 refs:
510ee948fb6354959cf03862f0ebe47c58eb2a74 HEAD
e553023017ca8545817a0931e13090569b6fe0c4 refs/heads/feature/eval-harness
510ee948fb6354959cf03862f0ebe47c58eb2a74 refs/heads/main
The bundle records a complete history.
The bundle uses this hash algorithm: sha1

$ cd ../..
$ git clone support-bot.bundle airgap/support-bot
Cloning into 'airgap/support-bot'...
$ git -C airgap/support-bot branch -a
* main
  remotes/origin/HEAD -> origin/main
  remotes/origin/feature/eval-harness
  remotes/origin/main
$ git -C airgap/support-bot remote -v
origin	$LAB/ch12/transports/support-bot.bundle (fetch)
origin	$LAB/ch12/transports/support-bot.bundle (push)

$ git log --oneline -1
c19ab53 Set request timeout
$ git push origin main
Everything up-to-date

$ git branch -a --contains HEAD
* hotfix/timeout
$ git status -sb
## hotfix/timeout
$ git log --oneline --branches --not --remotes
c19ab53 Set request timeout

$ git rev-parse HEAD
c19ab53ef3dba868f5f8b8c60d19a9687069f366
$ git ls-remote origin
510ee948fb6354959cf03862f0ebe47c58eb2a74	HEAD
510ee948fb6354959cf03862f0ebe47c58eb2a74	refs/heads/main

Observed behavior : git push printed "Everything up-to-date"; the deploy job cannot find the commit.
Git state         : HEAD is on hotfix/timeout, which has no upstream. The commit is on that branch only.
                    main equals origin/main.
Mechanism         : "git push origin main" is a refspec: send my main to their main. There was nothing
                    to send.
Root cause        : the command named a branch that does not hold the commit. A push transfers the
                    refs you name, not "my work".
Why Git does this : an explicit refspec is obeyed literally; Git has no idea which commit you care about.
Correct fix       : git push -u origin hotfix/timeout, then merge it by the team's process.
Prevention        : read the last lines of push output (<source> -> <destination>); verify with
                    git branch -a --contains <commit>; let deploy scripts verify with git ls-remote.

$ git push -u origin hotfix/timeout
To ../../server/support-bot.git
 * [new branch]      hotfix/timeout -> hotfix/timeout
branch 'hotfix/timeout' set up to track 'origin/hotfix/timeout'.
$ git branch -a --contains HEAD
* hotfix/timeout
  remotes/origin/hotfix/timeout
$ git log --oneline --branches --not --remotes

$ git switch main
Switched to branch 'main'
Your branch is up to date with 'origin/main'.
$ git branch origin/main HEAD~1
$ git rev-parse --short origin/main
warning: refname 'origin/main' is ambiguous.
95671d3
$ git branch -a
  hotfix/timeout
* main
  origin/main
  remotes/origin/HEAD -> remotes/origin/main
  remotes/origin/hotfix/timeout
  remotes/origin/main
$ git branch -D origin/main
Deleted branch origin/main (was 95671d3).

$ git remote set-head origin --delete
$ git for-each-ref --format='delete %(refname)' refs/remotes/origin | git update-ref --stdin
$ git branch -r
$ git status -sb
## main...origin/main [gone]
$ git fetch
From ../../server/support-bot
 * [new branch]      main           -> origin/main
 * [new branch]      hotfix/timeout -> origin/hotfix/timeout
$ git status -sb
## main...origin/main

# Asha has deleted spike/hybrid-search on the server. Your clone has not fetched since.
$ git branch -a --contains origin/spike/hybrid-search
  remotes/origin/spike/hybrid-search
$ git log --oneline -2 origin/spike/hybrid-search
509f067 Return the query as a stub result
249e18e Try hybrid search
$ git fetch --prune
From ../../server/support-bot
 - [deleted]         (none)     -> origin/spike/hybrid-search
$ git reflog show origin/spike/hybrid-search 2>&1 | head -1
fatal: ambiguous argument 'origin/spike/hybrid-search': unknown revision or path not in the working tree.
$ git fsck --unreachable | grep commit
unreachable commit 509f0670ffe15a66ea88e923674de467cf3a58ff
unreachable commit 249e18e16ceb304d7eea2d0b42a167965316b737

$ git fsck --lost-found | grep commit
dangling commit 509f0670ffe15a66ea88e923674de467cf3a58ff
$ git branch rescue/hybrid-search 509f067
$ git log --oneline -2 rescue/hybrid-search
509f067 Return the query as a stub result
249e18e Try hybrid search