> ## Documentation Index
> Fetch the complete documentation index at: https://docs.devin.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# Memorie & Regole

> Preserva il contesto tra le conversazioni di Cascade con memorie generate automaticamente e regole definite dall'utente a livello globale, di workspace e di sistema per i team aziendali.

`Memories` è il sistema per condividere e preservare il contesto tra le conversazioni.

In Devin Desktop, questo avviene tramite due meccanismi: **Memorie**, generate automaticamente da Cascade, e **Regole**, definite manualmente dall'utente a livello globale, di workspace o di sistema.

<div id="memories-rules-workflows-or-skills">
  ## Memorie, Regole, Workflow o Skills?
</div>

Devin Desktop offre diversi modi per personalizzare Cascade. Usa questa tabella per scegliere quello più adatto:

| Funzionalità                                   | Cosa fa                                                                       | Come si attiva                                                                     | Quando usarla                                                                                               |
| ---------------------------------------------- | ----------------------------------------------------------------------------- | ---------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------- |
| **[Regole](#rules)**                           | Indicano a Cascade *come comportarsi* (ad es. "usa bun, non npm")             | `always_on`, `glob`, `model_decision` o `manual` ([vedi sotto](#activation-modes)) | Convenzioni di codice, guide di stile, vincoli di progetto                                                  |
| **[AGENTS.md](/it/desktop/cascade/agents-md)** | Regole basate sulla posizione, senza configurazione                           | Automatico — root = sempre attivo, sottodirectory = glob                           | Convenzioni specifiche della directory senza frontmatter                                                    |
| **[Workflow](/it/desktop/cascade/workflows)**  | Template di prompt per attività ripetibili in più passaggi                    | **Solo manuale** tramite il comando slash `/[workflow-name]`                       | Distribuzioni, revisione delle PR, checklist di rilascio                                                    |
| **[Skills](/it/desktop/cascade/skills)**       | Procedure in più passaggi raggruppate con file di supporto (script, template) | Invocate dinamicamente dal modello oppure tramite `@mention`                       | Attività complesse in cui Cascade ha bisogno di file di riferimento — **vale la pena investire qui**        |
| **[Memorie](#memories)**                       | Contesto che Cascade genera automaticamente durante le conversazioni          | Recupero automatico quando pertinente                                              | Lascia che Cascade ricordi informazioni occasionali; per conoscenze durature, preferisci Regole o AGENTS.md |

<Tip>
  **Raccomandazione:** Per conoscenze che vuoi che Cascade riutilizzi in modo affidabile, scrivile come una Regola o aggiungile a `AGENTS.md` nel tuo repo, invece di affidarti alle Memorie generate automaticamente. Le Regole sono sottoposte a controllo di versione, condivisibili con il tuo team e ti offrono un controllo esplicito sull'attivazione.
</Tip>

<div id="how-to-manage-memories">
  ## Come gestire le memorie
</div>

È possibile accedere alle Memorie e alle Regole e configurarle in qualsiasi momento facendo clic sull’icona `Customizations` nel menu laterale in alto a destra di Cascade, oppure tramite “Devin - Settings” nell’angolo in basso a destra. Per modificare una memoria esistente, è sufficiente farvi clic e poi fare clic sul pulsante `Edit`.

<video autoPlay controls muted loop playsInline className="aspect-video" src="https://mintcdn.com/cognitionai/hxeMffzXgF_RWx-U/desktop/assets/windsurf/cascade/memories-rules.mp4?fit=max&auto=format&n=hxeMffzXgF_RWx-U&q=85&s=f264942bd2e40966555454624f1958b4" data-path="desktop/assets/windsurf/cascade/memories-rules.mp4" />

<div id="memories">
  ## Memorie
</div>

Nel corso della conversazione, Cascade può generare e archiviare automaticamente memorie se incontra informazioni contestuali che ritiene utili da ricordare.

Inoltre, puoi chiedere a Cascade di creare una memoria in qualsiasi momento. Ti basta chiedere a Cascade di "creare una memoria di ...".

Le memorie generate automaticamente da Cascade sono associate al workspace in cui sono state create e vengono archiviate localmente in `~/.codeium/windsurf/memories/`. Cascade le richiama quando ritiene che siano pertinenti. Le memorie generate in un workspace non sono disponibili in un altro e non vengono salvate con un commit nel tuo repository.

<Tip>La creazione e l'uso delle memorie generate automaticamente NON consumano crediti.</Tip>

<Note>
  Le memorie generate automaticamente risiedono solo sul tuo computer. Se vuoi che Cascade ricordi qualcosa in modo duraturo — e lo condivida con il tuo team — chiedi invece a Cascade di scriverlo in una [Regola](#rules) in `.devin/rules/` (o nel legacy `.windsurf/rules/`) oppure nel file `AGENTS.md` della tua repo.
</Note>

<div id="rules">
  ## Regole
</div>

Gli utenti possono definire esplicitamente le proprie regole da far seguire a Cascade.

Le regole possono essere definite a livello globale, di workspace o di sistema e possono anche essere ricavate dai file [AGENTS.md](/it/desktop/cascade/agents-md).

| Ambito                                                 | Posizione                                                                                   | Note                                                                                                                                                                                                                           |
| ------------------------------------------------------ | ------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| Globale                                                | `~/.codeium/windsurf/memories/global_rules.md`                                              | Un unico file, applicato a tutti i workspace. Sempre attivo. Massimo 6.000 caratteri.                                                                                                                                          |
| Workspace                                              | `.devin/rules/*.md` (preferito) o `.windsurf/rules/*.md` (fallback)                         | Un file per ogni regola, ciascuno con la propria [modalità di attivazione](#activation-modes). Massimo 12.000 caratteri per file. Viene ancora letto anche il file legacy singolo `.windsurfrules` nella radice del workspace. |
| [AGENTS.md](/it/desktop/cascade/agents-md)             | Qualsiasi directory nel workspace                                                           | Elaborato dallo stesso motore delle regole: a livello radice = sempre attivo, sottodirectory = auto-glob per quella directory.                                                                                                 |
| [Sistema (Enterprise)](#system-level-rules-enterprise) | Specifico del sistema operativo (ad es. `/etc/devin/rules/`, legacy `/etc/windsurf/rules/`) | Distribuito dall'IT, in sola lettura per gli utenti finali.                                                                                                                                                                    |

<div id="rules-discovery">
  ## Individuazione delle regole
</div>

Devin Desktop individua automaticamente le regole in più posizioni per offrire un'organizzazione flessibile. La directory `.devin/` è la posizione preferita e ha la precedenza, mentre `.windsurf/` viene mantenuta come fallback per la retrocompatibilità:

* **Workspace corrente e sottodirectory**: tutte le directory `.devin/rules` (e legacy `.windsurf/rules`) all'interno del workspace corrente e delle relative sottodirectory
* **Struttura del repository Git**: per i repository Git, Devin Desktop risale anche fino alla directory radice del repository per trovare le regole nelle directory padre
* **Supporto per più workspace**: quando sono aperte più cartelle nello stesso workspace, le regole vengono deduplicate e visualizzate con il percorso relativo più breve

<div id="rules-storage-locations">
  ### Posizioni di archiviazione delle regole
</div>

Le regole possono essere archiviate in una di queste posizioni (`.devin/` è preferito e ha la precedenza su `.windsurf/`):

* `.devin/rules` o `.windsurf/rules` nella directory del workspace corrente
* `.devin/rules` o `.windsurf/rules` in qualsiasi sottodirectory del workspace
* `.devin/rules` o `.windsurf/rules` nelle directory padre fino alla directory radice Git (per i repository Git)

Quando crei una nuova regola, questa verrà salvata nella directory `.devin/rules` del workspace corrente, non necessariamente nella directory radice Git.

Per iniziare a usare `Rules`, fai clic sull'icona `Customizations` nel menu a scorrimento in alto a destra in Cascade, quindi apri il pannello `Rules`. Qui puoi fare clic sul pulsante `+ Global` o `+ Workspace` per creare nuove regole rispettivamente a livello globale o di workspace.

<Tip>Puoi trovare modelli di regole di esempio curati dal team di Devin Desktop all'indirizzo [https://windsurf.com/editor/directory](https://windsurf.com/editor/directory) per iniziare più rapidamente.</Tip>

I file delle regole del workspace sono limitati a 12.000 caratteri ciascuno. Il file delle regole globali è limitato a 6.000 caratteri.

<div id="activation-modes">
  ### Modalità di attivazione
</div>

Ogni regola del workspace dichiara una modalità di attivazione nel frontmatter tramite il campo `trigger`. Questo controlla **quando** il contenuto della regola viene fornito a Cascade e **quanta parte della finestra di contesto occupa**:

| Modalità                  | valore `trigger:` | Come viene passato a Cascade                                                                                                                           | Costo di contesto                                   |
| ------------------------- | ----------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------ | --------------------------------------------------- |
| **Sempre attiva**         | `always_on`       | Il contenuto completo della regola è incluso nel prompt di sistema in ogni messaggio.                                                                  | Ogni messaggio                                      |
| **Decisione del modello** | `model_decision`  | Solo la `description` viene mostrata nel prompt di sistema. Cascade legge il file completo della regola quando decide che la descrizione è pertinente. | Descrizione sempre; contenuto completo su richiesta |
| **Glob**                  | `glob`            | La regola viene applicata quando Cascade legge o modifica un file che corrisponde al pattern `globs` (ad es. `*.js`, `src/**/*.ts`).                   | Solo quando vengono toccati file corrispondenti     |
| **Manuale**               | `manual`          | La regola **non** è nel prompt di sistema. La attivi digitando `@rule-name` nella casella di input di Cascade.                                         | Solo quando viene richiamata con @                  |

<Note>
  Il file delle regole globali (`global_rules.md`) e i file `AGENTS.md` nella directory root non usano frontmatter — sono sempre attivi.
</Note>

Esempio di regola del workspace con frontmatter:

```markdown theme={null}
---
trigger: glob
globs: **/*.test.ts
---

All test files must use `describe`/`it` blocks and mock external API calls.
```

<div id="best-practices">
  ### Buone pratiche
</div>

Per aiutare Cascade a seguire efficacemente le tue regole, segui queste buone pratiche:

* Mantieni le regole semplici, concise e specifiche. Regole troppo lunghe o vaghe potrebbero confondere Cascade.
* Non è necessario aggiungere regole generiche (ad es. "scrivi buon codice"), perché sono già incorporate nei dati di addestramento di Cascade.
* Struttura le tue regole con elenchi puntati, elenchi numerati e markdown. Per Cascade sono più facili da seguire rispetto a un lungo paragrafo. Ad esempio:

```
# Coding Guidelines 
- My project's programming language is python
- Use early returns when possible
- Always add documentation when creating new functions and classes
```

* I tag XML possono essere un modo efficace per esprimere e raggruppare regole simili. Ad esempio:

```
<coding_guidelines>
- My project's programming language is python
- Use early returns when possible
- Always add documentation when creating new functions and classes
</coding_guidelines>
```

<div id="system-level-rules-enterprise">
  ## Regole di sistema (Enterprise)
</div>

Le organizzazioni Enterprise possono implementare regole di sistema che si applicano globalmente a tutti i workspace e non possono essere modificate dagli utenti finali senza autorizzazioni amministrative. Questa soluzione è ideale per imporre standard di codifica validi per tutta l'organizzazione, policy di sicurezza e requisiti di conformità.

Le regole di sistema vengono caricate da directory specifiche del sistema operativo. La directory `Devin` è quella preferita e ha la precedenza, mentre la directory legacy `Windsurf` viene mantenuta come fallback:

**macOS:**

```
/Library/Application Support/Devin/rules/*.md
/Library/Application Support/Windsurf/rules/*.md   # fallback legacy
```

**Linux/WSL:**

```
/etc/devin/rules/*.md
/etc/windsurf/rules/*.md   # fallback legacy
```

**Windows:**

```
C:\ProgramData\Devin\rules\*.md
C:\ProgramData\Windsurf\rules\*.md   # legacy fallback
```

Inserisci i file delle regole (come file `.md`) nella directory appropriata per il tuo sistema operativo. Il sistema caricherà automaticamente tutti i file `.md` presenti in queste directory.

<div id="how-system-rules-work">
  ### Come funzionano le regole di sistema
</div>

Le regole di sistema vengono integrate con le regole del workspace e quelle globali, fornendo a Cascade ulteriore contesto senza sovrascrivere le regole definite dagli utenti. Questo consente alle organizzazioni di stabilire standard di base, pur permettendo ai team di aggiungere personalizzazioni specifiche per il progetto.

Nell'interfaccia utente di Devin Desktop, le regole di sistema vengono visualizzate con l'etichetta "System" e non possono essere eliminate dagli utenti finali.

<Note>
  **Importante**: le regole di sistema devono essere gestite dal team IT o dal team di sicurezza della tua organizzazione. Assicurati che i tuoi team interni gestiscano la distribuzione, gli aggiornamenti e la conformità in base alle policy della tua organizzazione. A questo scopo, puoi utilizzare strumenti e flussi di lavoro standard come Mobile Device Management (MDM) o Configuration Management.
</Note>