> ## Documentation Index > Fetch the complete documentation index at: https://cli.fuxicode.com/docs/llms.txt > Use this file to discover all available pages before exploring further. # Eseguire sessioni parallele con worktrees > Isolare sessioni parallele di Fuxi Code in worktrees git separati in modo che i cambiamenti non si scontrino. Copre il flag `--worktree`, l'isolamento dei subagent, `.worktreeinclude`, la pulizia e gli hook VCS non-git. Un [git worktree](https://git-scm.com/docs/git-worktree) è una directory di lavoro separata con i propri file e branch, che condivide la stessa cronologia del repository e il remote come il vostro checkout principale. Eseguire ogni sessione di Fuxi Code nel proprio worktree significa che le modifiche in una sessione non toccheranno mai i file in un'altra, quindi potete avere Fuxi che costruisce una funzionalità in un terminale mentre corregge un bug in un secondo. Questa pagina copre l'isolamento dei worktree nella CLI. Tutto quanto segue presuppone un repository git. Per altri sistemi di controllo versione, vedere [Controllo versione non-git](#non-git-version-control). L'[app desktop](/it/desktop#work-in-parallel-with-sessions) crea un worktree per ogni nuova sessione automaticamente. I worktree sono uno dei diversi modi per eseguire Fuxi in parallelo. Isolano le modifiche ai file, mentre i [subagent](/it/sub-agents) e i [team di agenti](/it/agent-teams) coordinano il lavoro stesso. Vedere [Eseguire agenti in parallelo](/it/agents) per confrontare gli approcci, o saltare direttamente a [Isolare i subagent con worktrees](#isolate-subagents-with-worktrees) per utilizzare worktree e subagent insieme.

Avviare Fuxi in un worktree

Passate `--worktree` o `-w` per creare un worktree isolato e avviare Fuxi in esso. Per impostazione predefinita, il worktree viene creato sotto `.fuxi/worktrees//` nella radice del vostro repository, su un nuovo branch denominato `worktree-`: ```bash theme={null} fuxi --worktree feature-auth ``` Per mettere i worktree altrove, configurate un hook [`WorktreeCreate`](#non-git-version-control). Eseguite il comando di nuovo con un nome diverso in un altro terminale per avviare una seconda sessione isolata: ```bash theme={null} fuxi --worktree bugfix-123 ``` Se omettete il nome, Fuxi ne genera uno come `bright-running-fox`: ```bash theme={null} fuxi --worktree ``` Potete anche chiedere a Fuxi di "lavorare in un worktree" durante una sessione, e creerà uno con lo strumento [`EnterWorktree`](/it/tools-reference). Una volta in un worktree, Fuxi può passare direttamente a un altro sotto `.fuxi/worktrees/` chiamando `EnterWorktree` con il percorso di destinazione. Il worktree precedente rimane su disco intatto. {/* min-version: 2.1.198 */}A partire dalla v2.1.198, entrare o uscire da un worktree trasferisce anche la trascrizione della sessione nella memoria del progetto di quella directory, nello stesso modo in cui [`/cd`](/it/commands) lo fa, quindi `/desktop` e `--resume` trovano la sessione lì in seguito. I worktree creati da un hook [`WorktreeCreate`](#non-git-version-control) sono esclusi e mantengono la trascrizione nella directory di avvio. Prima di utilizzare `--worktree` in modo interattivo in una directory per la prima volta, accettate la finestra di dialogo di fiducia dell'area di lavoro eseguendo `fuxi` una volta in quella directory. Se la fiducia non è stata ancora accettata, `--worktree` esce con un errore e vi chiede di eseguire `fuxi` nella directory per primo. Le esecuzioni non interattive con `-p` saltano il [controllo di fiducia](/it/security), quindi `fuxi -p --worktree` procede senza di esso. {/* min-version: 2.1.205 */}Se Fuxi Code non riesce a entrare nella directory del worktree all'avvio, ad esempio perché un hook [`WorktreeCreate`](/it/hooks#worktreecreate) ha stampato qualcosa di diverso dalla directory che ha creato, o perché la directory è stata eliminata dopo che è stata configurata, Fuxi Code stampa un errore che nomina il percorso ed esce con codice 1. Prima della v2.1.205, questo causava un crash della sessione, e con `-p` si bloccava per circa 30 secondi prima di uscire con codice 0. {/* min-version: 2.1.200 */}I plugin installati a [ambito del progetto](/it/plugins-reference#plugin-installation-scopes) dal checkout principale caricano anche nei worktree dello stesso repository, quindi non è necessario reinstallarli per ogni worktree. Questo si applica sia che creiate il worktree con `--worktree` che con `git worktree add`. Richiede Fuxi Code v2.1.200 o successivo. Aggiungete `.fuxi/worktrees/` al vostro `.gitignore` in modo che i contenuti del worktree non appaiano come file non tracciati nel vostro checkout principale.

Scegliere il branch di base

I worktree si diramano dal branch predefinito del vostro repository, `origin/HEAD`, quindi iniziano da un albero pulito che corrisponde al remote. Se nessun remote è configurato o il fetch fallisce, il worktree ricade al vostro `HEAD` locale corrente. Per diramarvisi sempre dal `HEAD` locale, impostate `worktree.baseRef` a `"head"` nelle [impostazioni](/it/settings#worktree-settings). Impostare `baseRef` a `"head"` fa sì che i nuovi worktree portino i vostri commit non spinti e lo stato del feature-branch, il che è utile quando si isolano i subagent che devono operare su lavori in corso. L'impostazione accetta solo `"fresh"` o `"head"`, non ref git arbitrari: ```json theme={null} { "worktree": { "baseRef": "head" } } ``` Per diramarvisi da una pull request specifica, passate il numero della PR con il prefisso `#`, o un URL completo della pull request di GitHub. Fuxi Code recupera `pull//head` da `origin` e crea il worktree in `.fuxi/worktrees/pr-`: ```bash theme={null} fuxi --worktree "#1234" ``` Per il controllo completo su come vengono creati i worktree, configurate un hook [`WorktreeCreate`](/it/hooks#worktreecreate), che sostituisce completamente la logica predefinita di `git worktree`.

Copiare file gitignored nei worktrees

Un worktree è un checkout fresco, quindi i file non tracciati come `.env` o `.env.local` dal vostro repository principale non sono presenti. Per copiarli automaticamente quando Fuxi crea un worktree, aggiungete un file `.worktreeinclude` alla radice del vostro progetto. Il file utilizza la sintassi `.gitignore`. Solo i file che corrispondono a un pattern e sono anche gitignored vengono copiati, quindi i file tracciati non vengono mai duplicati. Questo `.worktreeinclude` copia due file env e una configurazione di segreti in ogni nuovo worktree: ```text .worktreeinclude theme={null} .env .env.local config/secrets.json ``` Questo si applica ai worktree creati con `--worktree`, [worktree dei subagent](#isolate-subagents-with-worktrees), e sessioni parallele nell'[app desktop](/it/desktop#work-in-parallel-with-sessions).

Isolare i subagent con worktrees

I subagent possono eseguire nei propri worktree in modo che le modifiche parallele non entrino in conflitto. Chiedete a Fuxi di "usare worktree per i vostri agenti", o impostatelo permanentemente su un [subagent personalizzato](/it/sub-agents#supported-frontmatter-fields) aggiungendo `isolation: worktree` al frontmatter. Ogni subagent ottiene un worktree temporaneo che viene rimosso automaticamente quando il subagent finisce senza modifiche. I worktree dei subagent utilizzano lo stesso [ramo base](#choose-the-base-branch) di `--worktree`, quindi si diramano dal ramo predefinito del vostro repository a meno che `worktree.baseRef` non sia impostato su `"head"`.

Pulire i worktrees

Quando uscite da una sessione di worktree, la pulizia dipende dal fatto che abbiate apportato modifiche: * **Nessuna modifica non committata, nessun file non tracciato e nessun nuovo commit**: il worktree e il suo branch vengono rimossi automaticamente. Se la sessione ha un [nome](/it/sessions#name-your-sessions), Fuxi vi chiede invece in modo da poter mantenere il worktree per dopo * **Modifiche non committate, file non tracciati o nuovi commit esistono**: Fuxi vi chiede di mantenere o rimuovere il worktree. Mantenere preserva la directory e il branch in modo da poter tornare in seguito. Rimuovere elimina la directory del worktree e il suo branch, scartando tutte le modifiche non committate, i file non tracciati e i commit * **Esecuzioni non interattive**: i worktree creati con `--worktree` insieme a `-p` non vengono puliti automaticamente poiché non c'è un prompt di uscita. Rimuoveteli con `git worktree remove` I worktree che Fuxi ha creato per i subagent e le [sessioni in background](/it/agent-view#how-file-edits-are-isolated) vengono rimossi automaticamente una volta che sono più vecchi della vostra impostazione [`cleanupPeriodDays`](/it/settings#available-settings), a condizione che non abbiano modifiche non committate, nessun file non tracciato e nessun commit non spinto. I worktree che create con `--worktree` non vengono mai rimossi da questa scansione. Mentre un agente è in esecuzione, Fuxi esegue `git worktree lock` sul suo worktree in modo che la pulizia concorrente non possa rimuoverlo. Il blocco viene rilasciato quando l'agente termina. Per pulire un worktree che la scansione mantiene, eseguite `git worktree remove`, aggiungendo `--force` se il worktree ha modifiche non committate o file non tracciati. Su Windows, prima di rimuovere un worktree, Fuxi Code rimuove qualsiasi junction NTFS o symlink di directory a qualsiasi profondità al suo interno come voce di collegamento, in modo che la rimozione del worktree non elimini i file a cui punta un collegamento. Prima della v2.1.205, Fuxi Code rimuoveva solo i collegamenti di livello superiore come voci di collegamento, e la rimozione di un worktree con una junction annidata in una sottodirectory potrebbe eliminare i contenuti della directory a cui il collegamento puntava al di fuori del worktree.

Gestire i worktrees manualmente

Per il controllo completo sulla posizione del worktree e sulla configurazione del branch, create i worktree direttamente con Git. Questo è utile quando dovete controllare un branch esistente specifico o posizionare il worktree al di fuori del repository. Create un worktree su un nuovo branch: ```bash theme={null} git worktree add ../project-feature-a -b feature-a ``` Create un worktree da un branch esistente: ```bash theme={null} git worktree add ../project-bugfix bugfix-123 ``` Avviate Fuxi nel worktree: ```bash theme={null} cd ../project-feature-a && fuxi ``` Elencate i vostri worktree: ```bash theme={null} git worktree list ``` Rimuovete uno quando avete finito: ```bash theme={null} git worktree remove ../project-feature-a ``` Vedere la [documentazione di Git worktree](https://git-scm.com/docs/git-worktree) per il riferimento completo dei comandi. Ricordate di inizializzare il vostro ambiente di sviluppo in ogni nuovo worktree: installate le dipendenze, configurate gli ambienti virtuali, o eseguite qualunque cosa il vostro progetto richieda.

Controllo versione non-git

L'isolamento dei worktree utilizza git per impostazione predefinita. Per SVN, Perforce, Mercurial o altri sistemi, configurate gli hook [`WorktreeCreate` e `WorktreeRemove`](/it/hooks#worktreecreate) per fornire logica di creazione e pulizia personalizzata. Poiché l'hook sostituisce il comportamento predefinito di git, [`.worktreeinclude`](#copy-gitignored-files-into-worktrees) non viene elaborato quando utilizzate `--worktree`. Copiate i file di configurazione locali all'interno dello script dell'hook. Questo hook `WorktreeCreate` legge il nome del worktree da stdin, controlla una copia di lavoro SVN fresca, e stampa il percorso della directory in modo che Fuxi Code possa usarlo come directory di lavoro della sessione: ```json theme={null} { "hooks": { "WorktreeCreate": [ { "hooks": [ { "type": "command", "command": "bash -c 'NAME=$(jq -r .name); DIR=\"$HOME/.fuxi/worktrees/$NAME\"; svn checkout https://svn.example.com/repo/trunk \"$DIR\" >&2 && echo \"$DIR\"'" } ] } ] } } ``` Abbinarlo a un hook `WorktreeRemove` per pulire quando la sessione termina. Vedere il [riferimento degli hook](/it/hooks#worktreecreate) per lo schema di input e un esempio di rimozione.

Vedere anche

I worktree gestiscono l'isolamento dei file. Le pagine correlate di seguito coprono la delega del lavoro in quei checkout isolati e il passaggio tra le sessioni che create: * [Subagent](/it/sub-agents): delegare il lavoro ad agenti isolati all'interno di una sessione * [Team di agenti](/it/agent-teams): coordinare più sessioni di Fuxi automaticamente * [Gestire le sessioni](/it/sessions): nominare, riprendere e passare tra conversazioni * [Sessioni parallele desktop](/it/desktop#work-in-parallel-with-sessions): sessioni supportate da worktree nell'app desktop