Super dicas do comando fg: quando o Ctrl+Z salva sua sessão de terminal

$ ./gradlew build
> Building...

@startuml
skinparam backgroundColor #FEFEFE

actor Développeur as dev
participant "Terminal" as term
participant "Gradle\n( processo )" as gradle

dev -> term : ./gradlew compilação
term -> gradle : Execute o build
gradle -> term : Ocupa o terminal\n(sem prompt)
dev -> term : quer digitar um comando
term --> dev : Terminal bloqueado

note right of dev
O desenvolvedor está
paralisado durante
toda a duração do build
end note
@enduml

@startuml
skinparam backgroundColor #FEFEFE
autonumber

actor Développeur as dev
participant "Terminal" as term
participant "Gradle" as gradle
database "Estado\nprocesso" as state

dev -> term : ./gradlew construir
term -> gradle : Inicia o build
gradle -> state : Em andamento (FG)
dev -> term : Ctrl+Z
term -> state : Suspenso (job [1])
term --> dev : Prompt livre $

dev -> term : git status
term --> dev : árvore de trabalho limpa

dev -> term : fg
term -> state : Retoma (FG)
gradle --> dev : Build bem-sucedido ✓

note right of state
O processo Gradle
Nunca foi morto
Ele retoma exatamente
onde ele havia parado
end note
@enduml

# Dans vim, en mode commande :
:shell
$ cat /path/to/other/file.txt
$ exit
# Retour dans vim

# Dans vim, n'importe quel moment :
Ctrl+Z
[1]+  Stoppé    vim README.md

$ cat /path/to/other/file.txt
# ... lire le fichier ...

$ fg
vim README.md
# Retour exact là où on en était, curseur en place

@startuml
skinparam backgroundColor #FEFEFE
autonumber

actor Développeur as dev
participant "vim" as vim
participant "Shell" as shell

dev -> vim : edição em curso
dev -> vim : Ctrl+Z
vim -> shell : Suspenso (job [1])
dev -> shell : cat autre_fichier.txt
shell --> dev : conteúdo do arquivo
dev -> shell : fg
shell -> vim : Retoma (job [1])
vim --> dev : Cursor exatamente\nna mesma posição

note right of vim
vim restaure
intcomplètement l'état :
posição do cursor,
buffer, pilha de desfazer
end note
@enduml

@startuml
skinparam backgroundColor #FEFEFE
skinparam defaultFontName sans-serif
skinparam componentStyle rectangle

actor Développeur as dev
participant "opencode\n(LLM agent)" as agent
participant "Shell" as shell
participant "git" as git

dev -> agent : Sessão ativa
agent -> agent : Tour de parole\ndu LLM en cours

note over agent
Ctrl+Z chega em pleno meio de uma análise de código
end note

dev -> agent : Ctrl+Z
agent -> shell : Suspendu (job [1])
dev -> git : diferença do git
git --> dev : alterações visíveis
dev -> shell : fg
shell -> agent : Retoma (job [1])
agent --> dev : Reprend exactement\nl'analyse en cours

note right of agent
Nenhuma perda de contexto
O LLM retoma sua resposta
exatamente onde ele estava
end note
@enduml

$ opencode
# ... session en cours, LLM analyse le code ...
^Z
[1]+  Stoppé    opencode

$ git diff HEAD~1
# vérifier les changements récents

$ fg
opencode
# Le LLM reprend là où il s'était arrêté

$ vim config.yml
^Z
[1]+  Stoppé    vim config.yml

$ ./gradlew test
^Z
[2]+  Stoppé    ./gradlew test

$ htop
^Z
[3]+  Stoppé    htop

$ jobs
[1]   Stoppé    vim config.yml
[2]-  Stoppé    ./gradlew test
[3]+  Stoppé    htop

$ fg %2
./gradlew test
# Le build reprend en avant-plan

$ bg %3
[3] htop &
# htop reprend en arrière-plan

@startuml
skinparam backgroundColor #FEFEFE

rectangle "Trabalhos suspensos" as jobs #LightYellow {
  card "[1] vim config.yml" as j1
  card "[2] ./gradlew teste" as j2
  card "[3] htop" as j3
}

rectangle "Ações" as actions #LightGreen {
  card "fg %2\n→ primeiro plano" as a1
  card "bg %3\n→ segundo plano" as a2
  card "fg %1\n→ primeiro plano" as a3
}

jobs --> actions : fg/bg + número do trabalho
actions --> j2 : Retoma
actions --> j3 : em segundo plano

note bottom of jobs
Cada trabalho conserva
seu estado exato
em os suspend/resume
end note
@enduml

@startuml
skinparam backgroundColor #FEFEFE
skinparam defaultFontName sans-serif

rectangle "**Ctrl+Z**\nSIGTSTP" as ctrlz #LightYellow {
  card "Suspende o processo\n(ele ainda está na memória)\nUtilizável com fg/bg" as c1
}

rectangle "**Ctrl+C**\nSIGINT" as ctrlc #LightCoral {
  card "Mata o processo\n(sem possibilidade de retorno)\nPerda de todo o estado" as c2
}

rectangle "** & \n(fundo" as ampersand #LightGreen {
  card "Inicie diretamente\nem segundo plano\nTerminal livre immédiatement" as c3
}

rectangle "**fg**\n(primeiro plano)" as fg_ #SkyBlue {
  card "Traga um job\nsuspenso em primeiro plano\nTerminal ocupado" as c4
}

rectangle "**bg**\n(background)" as bg_ #Lavender {
  card "Retoma um trabalho\nsuspenso em segundo plano\nTerminal libre" as c5
}

ctrlz -right-> fg_ : fg para retomar
ctrlz -right-> bg_ : bg para continuar\nem segundo plano
ctrlc -right-> c2 : Sem retorno\nprocesso morto

note bottom of ctrlz
O processo está **parado** mas **não morto**
end note

note bottom of ampersand
Alternativa: iniciar
./gradlew construir &
diretamente em segundo plano
end note
@enduml

@startuml
skinparam backgroundColor #FEFEFE
skinparam defaultFontName sans-serif

title Ciclo de vida completo de um trabalho shell
state "Não existente" as none
state "Em primeiro plano\n(ocupa o terminal)" as foreground #LightCoral
state "Suspenso\n(Ctrl+Z / SIGTSTP)" as suspended #LightYellow
state "Em segundo plano\n(bg ou &)" as background #LightGreen
state "Concluído\n(exit code 0)" as done #LightGray

[*] --> none
none --> foreground : Digite um comando
foreground --> suspended : Ctrl+Z
foreground --> done : fim normal

suspended --> foreground : fg
suspended --> background : bg
suspended --> done : kill %n

background --> foreground : fg
background --> done : fim normal\n(em segundo plano)
background --> suspended : Ctrl+Z\n(se fg então Ctrl+Z)

done --> [*]

note right of suspended
O estado suspenso é
o pivô de todo o
sistema de jobs
end note
@enduml

@startuml
skinparam backgroundColor #FEFEFE
skinparam defaultFontName sans-serif
skinparam ArrowColor #444444

title "fg — A dica que muda tudo"

rectangle "**Problema**" as problem #LightCoral {
  card "Terminal travado\npor um processo" as p1
  card "Abrir um novo\nterminal = solução pesada" as p2
}

rectangle "**Solução**" as solution #LightGreen {
  card "Ctrl+Z → suspende" as s1
  card "fg → retoma" as s2
  card "bg → em segundo plano" as s3
  card "jobs → ver os suspensos" as s4
}

rectangle "**Vantagens**" as advantages #SkyBlue {
  card "Sem perda de contexto" as a1
  card "Sem reinicialização" as a2
  card "Um único terminal basta" as a3
}

problem -right-> solution : "A solução nativa\nUnix há 40 anos"
solution -right-> advantages : "Resultado"

note bottom of advantages
fg não é uma dica obscura
É um mecanismo fundamental
do shell Unix
end note
@enduml

@startuml
skinparam backgroundColor #FEFEFE
skinparam defaultFontName sans-serif

rectangle "Por que fg é\nsubestimado?" as why #LightCoral {
  card "IDE com terminal\nmulti-abas" as w1
  card "Ferramentas gráficas\nque substituem a CLI" as w2
  card "tmux/screen\nresolvem o problema\nde outra forma" as w3
}

rectangle "Por que fg é\nsuperior?" as superior #LightGreen {
  card "Universal: bash,\nzsh, fish, sh..." as s1
  card "Sem dependência:\nsem instalação" as s2
  card "Duas teclas:\nCtrl+Z e depois fg" as s3
  card "Contexto preservado:\nzero perda de estado" as s4
}

why -right-> superior : "A simplicidade\nsempre vence"
@enduml

@startuml
skinparam backgroundColor #FEFEFE
skinparam defaultFontName sans-serif

participant "Utilizador" as user
participant "Shell" as shell
participant "Processo" as proc

user -> shell : Ctrl+Z
shell -> proc : SIGTSTP (signal 18)
note right of proc : Processo congelado\nna memória

user -> shell : fg
shell -> proc : SIGCONT (signal 19)
note right of proc : Processo retomado\nem primeiro plano

user -> shell : bg
shell -> proc : SIGCONT (signal 19)
note right of proc : Processo retomado\nem segundo plano

user -> shell : Ctrl+C
shell -> proc : SIGINT (signal 2)
note right of proc : Processo concluído\nestado perdido
@enduml