Claude Code --resume e --continue: riprendere le sessioni senza ripartire da zero

🧭 Cos'è una sessione e perché non riparto da zero

Una sessione di Claude Code è semplicemente una conversazione salvata e legata a una cartella di progetto. Mentre lavoro, l'assistente la scrive su disco in continuazione: posso uscire, lanciare /clear, spegnere il computer, e quella conversazione resta lì pronta da riprendere. Il salvataggio è automatico, non devo ricordarmi di esportare nulla.

Il dettaglio che cambia tutto è che le sessioni sono per cartella. Claude Code non tiene un unico calderone globale: ogni progetto ha la sua storia, così quando riprendo l'ultima conversazione ottengo quella di questo repo, non l'ultima cosa fatta altrove. È la stessa logica con cui ragiono quando divido il lavoro tra più worktree Git.

Ci sono diversi modi per rientrare in una sessione, dal terminale o da dentro una conversazione già attiva. Li uso tutti, ma quelli che digito ogni giorno sono due: --continue e --resume.

# riprende la sessione più recente in questa cartella
claude --continue          # forma breve: claude -c

# apre il session picker interattivo
claude --resume            # forma breve: claude -r

# riprende direttamente una sessione per nome
claude --resume auth-refactor

# da dentro una sessione attiva: cambia conversazione
/resume

🔁 --continue o --resume: la scelta che faccio ogni giorno

--continue (forma breve -c) è quello che uso quasi sempre: riprende la sessione più recente della cartella in cui mi trovo, senza ID né configurazione. Digito claude --continue e sono di nuovo dentro l'ultima conversazione, con tutto il contesto al suo posto. Zero cose da ricordare: è il gesto con cui inizio la giornata su un progetto.

Posso anche fargli fare qualcosa subito: claude -c "i test passano ora?" riprende l'ultima sessione e le manda già il prompt. È comodo quando riapro apposta per chiudere un compito lasciato a metà, senza passare da un'interazione in più.

--resume (forma breve -r) entra in gioco quando l'ultima sessione non è quella che voglio. Senza argomenti apre il session picker, l'elenco interattivo delle conversazioni; con un nome — claude --resume auth-refactor — riprende direttamente quella. È lo strumento per quando ho più fili aperti in parallelo o devo ripescare una conversazione di qualche giorno fa.

🎛️ Il session picker: ritrovare la conversazione giusta

Quando lancio claude --resume senza argomenti — o /resume da dentro una sessione — si apre il picker: una lista in cui ogni riga mostra il nome della sessione, se l'ho dato, altrimenti il riassunto o il primo prompt, insieme al tempo dall'ultima attività, al numero di messaggi e al branch Git. Da qui mi muovo con le frecce e riprendo con Invio.

La parte che mi fa risparmiare tempo sono le scorciatoie per allargare la ricerca. Di default vedo le sessioni del worktree corrente: premo Ctrl+A per vederle tutte, di ogni progetto della macchina, Ctrl+W per allargare ai worktree del repo e Ctrl+B per filtrare quelle del branch su cui sto. Con Spazio sbircio il contenuto di una conversazione prima di aprirla.

Un trucco che uso spesso: incollo nel picker l'URL di una pull request — GitHub, GitLab o Bitbucket — e lui trova la sessione che l'ha creata. È il modo più veloce per tornare al lavoro dietro una PR senza ricordare quando l'avevo aperta.

🏷️ Dare un nome alle sessioni per ritrovarle

La singola abitudine che rende tutto il resto più semplice è dare un nome alle sessioni. Una sessione anonima la ritrovo solo dal riassunto o dal primo prompt; una che ho chiamato auth-refactor la riapro per nome senza nemmeno passare dal picker. È l'investimento a rendimento più alto nella gestione delle sessioni, e costa una parola. In team, poi, riprendo persino la conversazione legata a una pull request.

Assegno un nome in momenti diversi, ognuno comodo a modo suo:

• All'avvio, con claude -n auth-refactor: la sessione nasce già etichettata.
• Durante la sessione, con /rename auth-refactor: il nome compare anche sulla barra del prompt.
• Dal session picker, evidenziando una riga e premendo Ctrl+R.
• Accettando un piano in plan mode: Claude Code deriva il nome dal piano, se non l'ho già impostato io.

# nome all'avvio
claude -n auth-refactor

# rinomina durante la sessione
/rename auth-refactor

# riprende la sessione legata a una pull request
claude --from-pr 1234

🌿 Branch e --fork-session: sperimentare senza perdere il filo

A volte sono a un buon punto e voglio provare una strada diversa — un'altra libreria, un approccio più rischioso — senza buttare via la conversazione che mi ha portato fin lì. Per questo esiste il branch: crea una copia della sessione fino a quel punto e mi ci sposta dentro, lasciando l'originale intatto.

Lo faccio in due modi: da dentro la sessione con /branch prova-streaming, oppure dalla riga di comando combinando --continue o --resume con --fork-session. In entrambi i casi ottengo una nuova sessione con la sua storia, mentre quella di partenza resta nel picker, raggruppata insieme ai suoi rami. L'originale non si tocca.

Un avviso che mi sono segnato dopo averci sbattuto la testa: il fork copia la conversazione, non i file. Se il ramo modifica il codice, quelle modifiche sono reali e le vede qualsiasi sessione che lavora nella stessa cartella. Per biforcare e poter tornare indietro sui file serve il checkpointing, non il branch.

# da dentro la sessione: copia la storia e ci entra
/branch prova-streaming

# dalla CLI: riprende la più recente e la biforca
claude --continue --fork-session

# l'originale resta intatto: ci torno col suo nome
claude --resume <nome-originale>

⚠️ I limiti da conoscere: headless, transcript e terminali doppi

Le sessioni avviate con claude -p (la modalità non interattiva) o con l'Agent SDK non compaiono nel picker. Non sono perse, però: se conosco la loro session ID le riprendo con claude --resume <session-id>, a patto di lanciarlo dalla stessa cartella in cui erano partite — la ricerca dell'ID è limitata al progetto corrente e ai suoi worktree.

Da lì posso anche interrogarle senza aprire la TUI: claude -p --resume <session-id> "riassumi cosa abbiamo cambiato" manda un follow-up e mi restituisce la risposta, comodo dentro gli script. Se invece un run non deve lasciare traccia, --no-session-persistence lo esegue senza salvare la sessione.

Due cose da non dimenticare. I transcript stanno in ~/.claude/projects/, in formato JSONL, e il loro schema è interno: meglio non parsarli a mano ma usare /export. E se riprendo la stessa sessione in due terminali senza biforcare, i messaggi dei due si mescolano nello stesso file — una staffetta involontaria che confonde il contesto.

# transcript salvati per progetto, in JSONL
~/.claude/projects/<progetto>/<session-id>.jsonl

# follow-up non interattivo su una sessione esistente
claude -p --resume <session-id> "riassumi cosa abbiamo cambiato"

# un run headless che non salva la sessione
claude -p --no-session-persistence "..."

✅ Il flusso che seguo per non perdere il lavoro

Messi insieme, questi comandi diventano un'abitudine sola: non chiudo mai un lavoro sperando di ricordarmelo, lo lascio in una sessione che so ritrovare. Il mini-flusso che seguo, in ordine:

• Do un nome alle sessioni importanti con claude -n appena partono: è ciò che le rende ripescabili.
• Riprendo con *-c* per il lavoro quotidiano su un solo filo, e passo a --resume solo quando ne ho più di uno aperto.
• Biforco prima di osare: un --fork-session non costa nulla e mi salva la strada buona se l'esperimento non regge.
• Aggancio le PR con --from-pr, così la sessione e la sua revisione restano insieme.
• Esporto con */export* quando una conversazione vale la pena di essere archiviata oltre i 30 giorni di retention predefiniti.

Altri articoli del blog