A sessão do Claude Code caiu no meio da tarefa: como retomar de onde parou sem perder o trabalho?

Fala aí, beleza? O terminal fechou no meio da tarefa e a tela voltou limpa, sem histórico, sem nada

Bate aquele gelo na barriga: sumiu tudo?

Calma. Uma boa parte do trabalho nunca esteve na conversa, estava no disco, e continua lá do mesmo jeito. E o fio que parece ter ido embora junto com a tela, o que o modelo já tinha entendido do teu projeto, o que ele já sabia que não devia mexer, o plano que vocês dois combinaram, também não evaporou

O detalhe que salva o dia é este: uma sessão do Claude Code é uma conversa salva vinculada ao diretório do projeto, gravada continuamente em arquivos locais enquanto você trabalha. Dá pra voltar depois de sair, e até depois de rodar /clear

Bora separar o que sobrevive do que realmente se perde?

O que sobrevive à queda da sessão e o que realmente se perde

O sintoma é sempre igual: terminal fechado, tela limpa, e a sensação de que aquelas duas horas evaporaram

A causa é mais chata que grave. O processo morreu, então tudo que estava rodando naquele instante parou ali. Mas o arquivo que o Claude escreveu ou editou já tinha ido pro disco, e disco não se importa se o teu terminal fechou 😀

E a conversa? Ela é gravada continuamente num transcript local, não fica só na memória da tela

Onde a conversa fica salva:

Formação Recomendada

Formação Claude Code

Domine Claude Code do absoluto zero até o avançado

• 116 aulas
• 4 projetos
• 9h 23min

Conhecer formação

O Claude Code guarda os transcripts em JSONL, neste caminho:

~/.claude/projects/<projeto>/<session-id>.jsonl

Aquele <projeto> é o caminho do teu diretório de trabalho com os caracteres não alfanuméricos trocados por hífen

Cada linha do arquivo é um objeto JSON: uma mensagem, um uso de ferramenta ou uma entrada de metadados

Tome cuidado! Esse formato é interno do Claude Code e muda entre versões. Script que lê o JSONL direto tem tudo pra quebrar a cada release, então não monte a tua rotina de recuperação em cima disso

Outro ponto importante: transcripts e histórico não são criptografados em repouso. A única proteção é a permissão de arquivo do sistema operacional. Se a máquina é compartilhada, leve isso em conta antes de despejar segredo dentro da conversa

O que fazer antes de qualquer coisa:

Antes de reabrir sessão, de refazer prompt, de qualquer coisa: olhe o estado dos arquivos

git status
git diff

É isso que separa o feito do não feito. A conversa te conta o que o modelo disse que ia fazer, o diff te conta o que ele fez de verdade

Confie no diff, não na tua lembrança do que estava na tela

Como prevenir: trate o disco como fonte de verdade e a conversa como contexto de apoio. Inverteu isso, você vira refém de uma janela de terminal

Fechei o terminal: qual comando reabre a conversa

Sintoma: você encerrou sem querer, o terminal caiu, ou rodou um /clear e se arrependeu meio segundo depois

Causa: você acha que precisa recomeçar do zero. Não precisa

Retomando a conversa mais recente:

1. Entre no diretório do projeto e rode:

claude --continue

A forma curta é claude -c. Ele retoma a conversa mais recente daquele diretório, sem você precisar decorar ID nenhum

Erro comum deste passo: rodar o comando de outra pasta. O --continue olha o diretório atual, então se você chamou de ~ ele não vai achar a conversa do teu projeto

2. Se você quer escolher qual sessão voltar, abra o seletor interativo:

claude --resume

3. Se você já tem o identificador ou um nome de sessão em mãos, passe direto:

claude --resume <session-id>
claude --resume <nome>

4. Já está dentro de uma sessão aberta e quer pular pra outra? O comando /resume abre esse mesmo seletor sem sair do Claude Code

Erro comum deste passo: insistir no --continue quando ele simplesmente não acha a sessão que você quer

Quando o –continue não serve:

Se liga nisso, porque pega muita gente: o --continue pula sessões em background e pula sessões cujo primeiro prompt foi /loop

Nesses casos ele não é teimosia tua, é comportamento esperado. Vai de --resume e escolhe na mão

Como prevenir: pegue o hábito de sempre abrir o claude a partir da raiz do projeto. Metade dos casos de "sumiu minha sessão" é só terminal na pasta errada

Não sei qual das sessões era a certa

Sintoma: você abre o seletor e tem seis linhas parecidas, todas do mesmo projeto, todas com cara de serem a certa

Causa: sessão acumula. Cada retomada, cada teste, cada ideia abandonada fica lá

A boa notícia é que cada linha do seletor carrega pista suficiente pra você identificar a tarefa interrompida:

Na prática, tempo desde a última atividade mais branch resolve quase sempre. A sessão que caiu é a mais recente, na branch em que você estava

Retomando de qualquer lugar da máquina:

Outra que é mto massa: claude --resume <session-id> funciona de qualquer diretório

O Claude Code procura aquele ID primeiro no diretório do projeto atual e nos git worktrees dele, e só depois vai nos demais projetos da máquina

Ou seja, se você anotou o ID, não precisa nem lembrar em qual pasta aquilo estava

Como prevenir: quando a sessão tem nome definido, o seletor mostra esse nome na linha, e isso te poupa de abrir a sessão errada em dia de tarefa longa

Retomei a sessão e o Claude refez o que já estava pronto

Essa aqui é o coração do problema, e quase ninguém fala dela

Sintoma: você volta pra sessão, cola o mesmo prompt da tarefa original, e o modelo sai reescrevendo arquivo que já estava terminado e testado

Causa: o pedido original descreve um projeto que não existe mais. Quando você escreveu aquele prompt, não havia nada. Agora tem metade da coisa pronta no disco. Repetir o pedido é pedir pro agente construir de novo um mundo que já foi construído

E olha que retomar restaura bastante: com --continue ou --resume, a conversa reabre sob o mesmo session ID, as novas mensagens são anexadas ao histórico existente e o histórico completo volta, incluindo as chamadas de ferramenta e os resultados delas

Mesmo assim, quem decide o que vai acontecer agora é o teu primeiro prompt da retomada

O jeito errado e o jeito certo:

O jeito que causa estrago é este:

Crie o SaaS com landing page, registro, login e dashboard

O jeito que funciona é descrever o ESTADO, não o desejo:

Estado atual: landing page, registro e login já estão prontos e funcionando.
O dashboard existe, mas ainda não lista os registros do usuário.
Não altere nada fora da pasta do dashboard.
Próximo passo: só a listagem dentro do dashboard, mais nada.

Percebe a diferença? O primeiro descreve um projeto vazio. O segundo descreve o projeto que está no teu disco agora

Esse mesmo cuidado vale quando a conversa ficou longa demais e o modelo começa a perder detalhe do começo, que é um assunto vizinho: vale entender quanto contexto o Claude Code aguenta antes de culpar a retomada

Como prevenir: feche cada bloco de trabalho pedindo um resumo do estado atual antes de sair, e leia o diff antes de mandar o primeiro prompt da volta. São dois minutos que economizam meia hora de desfazer

O código ficou pela metade: quando o /rewind ajuda (e quando não)

Sintoma: a interrupção pegou o agente no meio de uma sequência de edições e agora tem arquivo em estado intermediário, sem rodar

Causa: a tarefa parou entre uma edição e outra, e ninguém garantiu que o conjunto ficasse coerente

Solução: o Claude Code cria um checkpoint automaticamente a cada prompt que você envia, capturando o estado do código antes daquele prompt

Pra abrir o menu, rode /rewind ou aperte Esc duas vezes

Lá dentro você escolhe entre restaurar só o código, só a conversa, ou os dois, além das opções de resumir a partir de um ponto. As duas opções de restaurar código só aparecem quando o checkpoint selecionado tem mudanças de arquivo rastreadas pra reverter

Os limites honestos do checkpoint:

Aqui é onde muita gente se ferra achando que tem uma rede de segurança que não tem:

• Só entram as edições feitas pelas ferramentas de edição do Claude: Write, Edit e NotebookEdit
• Mudança feita por comando Bash ou por processo externo não é capturada
• Arquivo que é symlink ou hard link é pulado na restauração
• Edição feita por subagente normalmente não entra nos checkpoints da tua sessão (a exceção citada na documentação é skill bifurcada em primeiro plano), então o rewind não traz essas edições de volta
• Checkpoints e sessões são apagados após 30 dias, seguindo o padrão da opção cleanupPeriodDays

A própria documentação é direta: isso não substitui o git

Se o teu problema é mais travamento do que queda seca, o raciocínio é parecido e vale ver o caso de Claude Code travando no meio da tarefa

Como prevenir: use checkpoint pro que ele é, recuperação rápida dentro da sessão, e não como teu histórico de projeto

Sem ponto de retorno: o hábito de commitar em etapas

Sintoma: a retomada deu errado, o agente bagunçou e você não tem pra onde voltar

Causa: a tarefa longa inteira estava num bloco só, sem nenhum commit no meio. Duas horas de trabalho penduradas em nada

As boas práticas oficiais são chatas de tão simples: comece de um estado limpo do git e commite checkpoints com frequência, pra reverter fácil o que sair errado

E em tarefa autônoma longa, aquela que você deixa rodando e vai fazer outra coisa, a orientação é commitar e enviar depois de cada unidade significativa de trabalho. Assim você tem histórico recuperável e não perde trabalho

O efeito prático disso é bonito: qualquer interrupção cai num ponto conhecido. Não existe mais "até onde ele tinha ido?", existe "o último commit é a verdade, o resto é rascunho"

E quando eu quero testar outro caminho?

Dentro da sessão, o comando /branch ramifica a conversa atual pra você tentar outra direção, e ele tem /fork como alias

Ele te move pra branch nova e preserva a original, que continua acessível pelo /resume

Ramificar com --fork-session ou com /branch copia o histórico pra um novo session ID e deixa a sessão original inalterada, aparecendo como uma linha separada no seletor

Tradução: dá pra apostar numa ideia arriscada sem queimar a conversa que estava funcionando

Como prevenir: git pro histórico permanente e pra colaboração, checkpoint só pra recuperação rápida dentro da sessão. Cada um no seu quadrado

Por que refazer do zero custa mais do que parece

Agora o lado que ninguém coloca na conta: retomada mal feita não é só chata, ela é paga duas vezes

No vídeo em que eu monto um SaaS completo do zero por prompt, rodando o Claude Code com DeepSeek e depois continuando o mesmo projeto no OpenCode, a execução inteira que gerou 4 páginas saiu por cerca de 11 a 12 centavos de dólar

Um teste anterior na minha conta tinha custado 3 centavos, e eu tinha colocado 2 dólares de crédito na plataforma pra brincar

Parece pouco, e é pouco mesmo. Mas o número não é o ponto: o ponto é que cada retomada que refaz o que já estava pronto repete tokens já pagos e tempo já gasto. Multiplica isso por uma semana de trabalho e por um projeto de verdade

O aperto de mão que eu deixo pra próxima sessão:

O que eu faço no vídeo, ainda dentro da sessão que acabou de construir o projeto, é pedir pro próprio Claude escrever um arquivo de documentação na raiz

É um aperto de mão com o próximo agente que for continuar o trabalho

No prompt eu peço visão geral do projeto, stack, estrutura de pastas, banco de dados, autenticação, como rodar, convenções e regras importantes

A ideia é que a próxima sessão continue as funcionalidades sem destruir o que já foi feito. É uma camada de segurança, mesmo num projeto ainda inicial

E aqui vai a autocrítica honesta: o certo é ABRIR esse arquivo e conferir se ficou completo, se não faltou complementar nada, antes de confiar nele pra retomada. Eu mesmo reconheço isso no vídeo 😛

Depois eu fecho e retomo o mesmo projeto em outro agente, conectando o provider com a chave de API. E o primeiro movimento não é pedir código, isso é importante: eu peço pro agente entender o projeto e explicar como ele funciona

O agente descreve certinho o SaaS de geração de slogans, com base nos arquivos e naquela documentação. É exatamente a informação que a sessão anterior deixou que faz a retomada ficar bem estruturada

No fim eu testo criação de conta, login e a geração de slogans, e o negócio funciona, simples mas funcionando

Uma ressalva que eu faço lá e repito aqui: agente alternativo não tem garantia de quem vai manter nem de que vai continuar sendo mantido. Vale saber disso antes de casar com a ferramenta

Conclusão

Sessão que cai não é trabalho perdido, é fio interrompido. São coisas bem diferentes

O arquivo continua no disco, a conversa continua gravada no transcript local, e o comando pra voltar é um só

O caminho prático da próxima vez que acontecer:

1. Entre no diretório do projeto e rode claude --continue (ou claude --resume se precisar escolher a sessão)
2. Antes de escrever qualquer prompt, olhe o git status e o git diff pra saber o que ficou pronto de verdade
3. Reabra descrevendo o estado atual e pedindo só o próximo passo, nunca repetindo o pedido original
4. Se o código ficou pela metade, avalie o /rewind sabendo dos limites dele
5. E adote o commit por unidade de trabalho, pra próxima queda ser irrelevante

Retomar sessão do Claude Code deixa de ser drama no dia em que o teu ponto de retorno não depende mais de uma janela de terminal aberta 🙂

Até o próximo post!