Generally, yes. Every new command run from the shell is a whole new process that is spawned or fork/exec'd (except for those built-in to the shell), and whenever you return to the shell's prompt, this means the previous process has exited1. (Indeed once the shell forks, its main process usually does nothing else but call waitpid() and wait specifically for the child process to exit, before printing a new prompt to stdout.)
The OS doesn't provide any built-in continuity between those invocations; each new git.exe starts fresh at main() and has to read the repository's state from the
.git folder again.
Though, the opposite also applies: if a command doesn't return to the shell's prompt, but instead shows its own prompt (such as python.exe showing a
>>> or diskpart.exe showing
DISKPART>), then that means it is still running – everything that you enter at the
>>> will be read by the same python.exe instance, until you finally exit back to the shell.
One way to find out is by looking at the process list –
tasklist or Task Manager's "Details" will show the basics, but Process Hacker and Sysinternals ProcExp both provide a much clearer tree view of all processes currently running. (Meanwhile, Sysinternals ProcMon on Windows – or forkstat on Linux – can show process start/exit events.)
1 Also note that this is only about the initial process that the shell has spawned – it doesn't necessarily mean that its children have exited. (For example, Git operations will sometimes start a "git gc" process for background maintenance.)
One particularly relevant example would be the "git fsmonitor" process that Git might auto-start on Windows, which acts as a persistent in-memory cache for filesystem metadata – so by design it's meant to continue running after the first command and to allow further Git commands to connect to it somehow (e.g. via local sockets).
Another similar example found on Linux is GnuPG (the "gpg" command), which will start a "gpg-agent" process the first time you run it, and the next "gpg" invocation may connect to the existing instance of gpg-agent when it needs the agent's services.
So although your shell doesn't "reconnect" to the app but spawns a fresh git.exe process every time, the app itself may use some form of IPC to connect to a previously started background service.