specrails-desktop 2.8.0 → 2.9.0

package/docs/guide/it/agents/2-profiles-and-the-balanced-default.md

@@ -0,0 +1,45 @@
+# Profili e il default bilanciato
+
+Un **profilo** è una ricetta salvata per un'esecuzione della pipeline. Risponde a tre domande in un unico posto:
+
+1. **Quali agenti** partecipano (il trio di base, più eventuali specialisti o agenti custom).
+2. **Con quale modello** gira ciascun agente.
+3. **Come vengono instradati** i task verso quegli agenti.
+
+Trovi i profili nella sezione **Agenti** di qualsiasi progetto (barra laterale destra → **Agenti** → scheda **Profili**).
+
+## Il default bilanciato
+
+Fin da subito, un progetto si risolve verso un sensato profilo **default**. Include il trio di base — `sr-architect`, `sr-developer`, `sr-reviewer` — e instrada ogni task al developer tramite un'unica regola "cattura-tutto". I modelli sono bilanciati per il lavoro di tutti i giorni: un modello capace dove conta, senza ricorrere all'opzione più costosa a ogni passaggio.
+
+Se nel tuo progetto i modelli degli agenti erano già configurati alla vecchia maniera (nel frontmatter dei file agente), il pulsante **Migra** li legge e costruisce un profilo `default` che rispecchia esattamente il comportamento attuale — nessuna perdita, niente cambia finché non decidi tu di metterci mano.
+
+Il punto chiave: **non sei obbligato a creare un profilo per usare Specrails.** Il default funziona e basta. I profili sono il modo per andare oltre.
+
+## Come viene scelto un profilo per un'esecuzione
+
+Quando avvii un rail, Specrails sceglie un profilo in questo ordine:
+
+1. La tua **scelta esplicita** nell'intestazione del rail (vedi sotto).
+2. La tua **preferenza per sviluppatore** — un profilo che hai contrassegnato come tuo default personale per questo progetto (è locale a te e non viene committato).
+3. Il profilo **`default`** del progetto.
+
+Il profilo viene *fotografato in uno snapshot all'avvio*, così ogni rail di un batch può girare con un profilo diverso, e modificare un profilo in seguito non riscrive mai i job che sono già partiti.
+
+## Selezionare un profilo per ogni rail
+
+La scelta del profilo avviene proprio dove si lancia — nell'**intestazione del rail**, tramite il selettore di profilo.
+
+- Scegli un profilo dal menu a discesa per usarlo **solo per questo avvio**.
+- Usa l'opzione di persistenza per rendere un profilo la scelta stabile del rail da qui in avanti.
+
+È tutto il flusso: scegli un profilo, avvia, fatto. I rail concorrenti nello stesso batch possono portare ciascuno il proprio profilo, così una correzione veloce e una feature impegnativa possono girare fianco a fianco con configurazioni diverse.
+
+## Quando la sezione Agenti tace
+
+I profili sono una funzionalità di Claude. Su un progetto che include un provider diverso da Claude (Codex o Gemini), la sezione Agenti è nascosta e i rail girano senza profili — è il comportamento atteso, non un bug. I profili richiedono inoltre una versione di `specrails-core` abbastanza recente nel progetto; se è più datata, vedrai un banner giallo. I profili che crei vengono comunque **salvati** — semplicemente non influiscono sulla pipeline finché core non viene aggiornato. Aggiorna con il comando indicato nel banner per sbloccarli.
+
+## Dove andare adesso
+
+- [Personalizzare i modelli per agente](customizing-models-per-agent) — costruisci i profili `fast` e `max`.
+- [Agenti custom e il catalogo](custom-agents-catalog) — vedi ed estendi la squadra.

package/docs/guide/it/agents/3-customizing-models-per-agent.md

@@ -0,0 +1,60 @@
+# Personalizzare i modelli per agente
+
+La cosa più utile in assoluto che i profili ti permettono di fare è **scegliere il modello giusto per ogni passaggio**. Un passaggio di pianificazione potrebbe meritare il tuo modello più potente; un passaggio di costruzione di routine potrebbe trovarsi benissimo con qualcosa di più veloce ed economico. I profili ti permettono di esprimere esattamente questo.
+
+È qui che la separazione tra "condiviso" e "per progetto" ripaga:
+
+- Le *definizioni* degli agenti restano condivise in tutta la tua squadra.
+- Il *modello con cui gira ciascun agente* viene configurato **per progetto**, all'interno di un profilo, e riguarda solo il tuo progetto.
+
+Cambia un modello e cambi costo e comportamento per quel progetto — senza toccare la configurazione di nessun altro né le istruzioni di base dell'agente.
+
+## Cambiare il modello usato da un agente
+
+In **Agenti → Profili**, seleziona un profilo e apri il suo editor della catena di agenti. Ogni agente nella catena ha un campo modello. C'è anche un modello **orchestratore** che gestisce il coordinamento di alto livello della pipeline.
+
+I valori dei modelli sono alias — per Claude sono `opus`, `sonnet` e `haiku` (dal più capace → al più veloce). Imposta l'alias che desideri per ogni agente:
+
+- Lascia il modello di un agente **vuoto** per ricadere sul default presente nel file dell'agente.
+- Impostalo esplicitamente per fare l'override solo per questo profilo.
+
+Salva, e il prossimo rail avviato con quel profilo userà i nuovi modelli. I job già in esecuzione mantengono il loro snapshot.
+
+## Creare profili come `fast` e `max`
+
+Lo schema naturale è un paio di profili con nome a cui ricorri a seconda del lavoro:
+
+**Un profilo `fast`** — per modifiche piccole e a basso rischio, dove vuoi velocità e un conto più leggero:
+
+- Architect: un modello medio o veloce — il piano è semplice.
+- Developer: un modello veloce — la modifica è meccanica.
+- Reviewer: tienilo solido, ma puoi sfoltire un po' anche qui.
+
+**Un profilo `max`** — per feature spinose e ad alta posta in gioco, dove vuoi che ogni passaggio sia il più affilato possibile:
+
+- Architect, developer e reviewer: il tuo modello più potente su tutta la linea.
+
+### Due modi per costruirne uno
+
+1. **Duplica e ritocca** *(consigliato).* Seleziona il tuo profilo `default`, **Duplicalo**, dai alla copia un nome in kebab-case come `fast` o `max`, poi regola il modello di ciascun agente. Erediti una catena e un routing già collaudati e cambi solo ciò che intendi cambiare.
+2. **Parti da zero.** Crea un **Profilo vuoto** e assembla la catena da te. Devi comunque includere il trio di base (`sr-architect`, `sr-developer`, `sr-reviewer`) — la pipeline dipende da tutti e tre — ed esattamente una regola di routing terminale "cattura-tutto", che deve essere l'ultima.
+
+I nomi dei profili sono in kebab-case minuscolo (es. `fast`, `max`, `cheap-and-cheerful`).
+
+## Instradare i task verso agenti specifici
+
+Le **regole di routing** di un profilo decidono quale agente gestisce un task taggato. Ogni regola elenca dei tag di task e un agente di destinazione; vince la prima regola i cui tag corrispondono, e un'unica regola `default: true` alla fine cattura tutto il resto. Solo gli agenti effettivamente presenti nella catena del profilo possono essere destinazioni di routing — l'editor lo impone.
+
+Per l'uso quotidiano non toccherai il routing: la regola "cattura-tutto" manda il lavoro al developer ed è corretto così. Ricorri alle regole per tag quando vuoi, ad esempio, che il lavoro taggato `migration` vada a uno specialista.
+
+## Scegliere il profilo all'avvio
+
+Tutto questo converge all'avvio: nell'intestazione del rail, scegli `fast`, `max` o `default` per ogni rail. Un batch può mescolarli — una piccola correzione su `fast`, una grande feature su `max`, entrambe in esecuzione nello stesso momento. Vedi [Profili e il default bilanciato](profiles-and-the-balanced-default) per il flusso di selezione.
+
+## Una nota sulla sicurezza
+
+Eliminare un profilo è sicuro per il lavoro in corso: i job già avviati con esso mantengono il loro snapshot, e gli avvii futuri semplicemente ricadono lungo l'ordine di risoluzione. Sperimenta in libertà.
+
+## Dove andare adesso
+
+- [Agenti custom e il catalogo](custom-agents-catalog) — aggiungi agenti da inserire nelle tue catene.

package/docs/guide/it/agents/4-custom-agents-catalog.md

@@ -0,0 +1,43 @@
+# Agenti custom e il catalogo
+
+I profili decidono *quali agenti girano e con quali modelli*. Ma da dove arrivano gli agenti stessi? Dal **catalogo degli agenti**.
+
+Apri **Agenti → Catalogo** in qualsiasi progetto. È un visualizzatore in sola lettura di ogni agente disponibile per quel progetto, suddiviso in due gruppi:
+
+- **Agenti upstream** — gli agenti forniti con `specrails-core`: il trio di base (`sr-architect`, `sr-developer`, `sr-reviewer`) ed eventuali specialisti come `sr-merge-resolver`.
+- **Agenti custom** — gli agenti che hai aggiunto tu, con nome `custom-*`.
+
+Ogni voce del catalogo mostra a cosa serve l'agente e il suo modello predefinito, così puoi vedere la rosa completa prima di collegare gli agenti a una catena di profilo.
+
+## Aggiungere un agente custom
+
+Gli agenti custom sono semplici file Markdown nel tuo repository, sotto `.claude/agents/`, con nome `custom-<qualcosa>.md`. Il file contiene le istruzioni dell'agente (il suo system prompt) e un piccolo header di frontmatter che include un `model:` predefinito.
+
+Una volta che il file esiste nel progetto, compare nel catalogo come agente custom, e puoi aggiungere il suo id alla catena di agenti di qualsiasi profilo (e instradare i task verso di esso). L'id deve corrispondere al nome del file — una voce per `custom-docs` mappa su `.claude/agents/custom-docs.md`.
+
+Poiché vivono nel tuo repo, gli agenti custom sono **asset di squadra committabili**: committi il file e tutta la tua squadra ottiene l'agente. Questo riflette l'idea centrale che attraversa l'intera sezione Agenti —
+
+> **Le definizioni degli agenti sono condivise (vivono nel repo e viaggiano con `git`). La configurazione dei modelli è per progetto (vive nei profili).**
+
+Il namespace `custom-*` è riservato e protetto: i comandi `init` e `update` di `specrails-core` non toccano mai `.claude/agents/custom-*.md`, così i tuoi agenti custom sopravvivono intatti agli aggiornamenti di core. (La stessa protezione copre i frammenti contribuiti dai plugin, come `custom-serena.md`.)
+
+## Mettere al lavoro un agente custom
+
+Il flusso tipico:
+
+1. Scrivi `.claude/agents/custom-<nome>.md` con le istruzioni e un modello predefinito.
+2. Verifica che compaia in **Agenti → Catalogo** sotto Custom.
+3. In **Agenti → Profili**, aggiungi l'agente alla catena di un profilo (facendo eventualmente l'override del suo modello per quel profilo).
+4. Aggiungi una regola di routing affinché i task con i tag giusti lo raggiungano — oppure affidati all'ordine della catena.
+5. Avvia un rail con quel profilo dall'intestazione del rail.
+
+## Tenere d'occhio le prestazioni dei profili
+
+La sezione Agenti ha anche una scheda **Utilizzo** — una ripartizione per profilo di quanti job sono stati eseguiti con ciascun profilo in una finestra temporale selezionata. È un modo rapido per confermare che la tua suddivisione `fast`/`max` venga davvero usata come intendevi, e per individuare verso quale profilo gravita la tua squadra.
+
+## Riepilogo dell'intera sezione
+
+- Gli **agenti** sono i membri specializzati della squadra — il trio condiviso più gli specialisti e i tuoi agenti custom. ([Conosci gli agenti](meet-the-agents))
+- I **profili** impacchettano quali agenti girano, con quali modelli e come vengono instradati i task — selezionati per ogni rail all'avvio. Il profilo default è la scelta bilanciata di tutti i giorni. ([Profili e il default bilanciato](profiles-and-the-balanced-default))
+- I **modelli** vengono regolati per agente, per progetto, all'interno dei profili — costruisci `fast` e `max` per adattarti al lavoro. ([Personalizzare i modelli per agente](customizing-models-per-agent))
+- **Il catalogo** mostra ogni agente, e il namespace `custom-*` ti permette di far crescere la squadra — definizioni condivise, configurazione per progetto.

package/docs/guide/it/getting-started/1-what-is-specrails.md

@@ -0,0 +1,49 @@
+# Cos'è specrails
+
+Benvenuto in **specrails** — un'app desktop che trasforma un assistente AI per la programmazione in un vero team di sviluppo, al lavoro sui *tuoi* progetti, sulla *tua* macchina.
+
+Invece di copiare e incollare prompt avanti e indietro, descrivi ciò che vuoi sotto forma di **spec**, e specrails la fa scorrere attraverso un'intera pipeline di sviluppo — progettando, costruendo, revisionando e consegnando la modifica — mentre tu la guardi accadere in tempo reale.
+
+## Sviluppo AI guidato dalle spec
+
+Il cuore di specrails è un'idea semplice: **il modo migliore per ottenere buon codice dall'AI è partire da una spec chiara.**
+
+Una *spec* è una descrizione breve e strutturata di un singolo intervento — una funzionalità, una correzione, un refactor. Puoi scriverne una in pochi secondi, oppure darle forma attraverso una chat guidata che ti pone le domande giuste e la redige al posto tuo. Ogni spec diventa un **ticket** sulla board del tuo progetto, proprio come un'attività in un qualsiasi issue tracker.
+
+Da lì, affidi la spec alla pipeline e lasci che sia l'AI a fare il lavoro pesante.
+
+## La pipeline: Architect → Developer → Reviewer → Ship
+
+Quando avvii una spec, specrails la fa passare attraverso quattro fasi, ciascuna interpretata da un agente AI specializzato:
+
+1. **Architect** — legge la tua spec e il codice circostante, poi pianifica la modifica: quali file toccare, quale forma dovrebbe avere la soluzione.
+2. **Developer** — scrive il codice vero e proprio, seguendo il piano.
+3. **Reviewer** — controlla il lavoro per correttezza e qualità, intercettando i problemi prima che lo faccia tu.
+4. **Ship** — finalizza la modifica così che sia pronta per il commit.
+
+Vedi ogni fase mentre viene eseguita, con i log in tempo reale che arrivano direttamente dall'AI. Niente è nascosto — se qualcosa va storto, vedrai esattamente dove.
+
+## Progetti
+
+Tutto in specrails è organizzato intorno ai **progetti**. Un progetto è semplicemente una cartella sul tuo computer che contiene un codebase. Puoi aggiungere tutti i progetti che vuoi e passare dall'uno all'altro all'istante — ognuno conserva le proprie spec, la cronologia dei job, le analytics e le impostazioni.
+
+Specrails non tocca mai codice che non gli hai chiesto di toccare. Lavora all'interno del tuo repository esistente e sei tu a mantenere il controllo su cosa viene committato.
+
+## Scegli il tuo provider AI
+
+Specrails funziona con le principali CLI di programmazione AI:
+
+- **Claude** (Claude Code)
+- **Codex** (Codex CLI)
+- **Gemini** (Gemini CLI)
+
+Scegli quella che già usi — oppure installane più di una e scegline una a seconda dell'attività. Un progetto può funzionare con un singolo provider o con più provider contemporaneamente, così non resti mai vincolato a una scelta.
+
+## Perché ti piacerà
+
+- **Velocità senza caos** — le spec mantengono l'AI concentrata, così ottieni modifiche utili invece di tentativi dispersivi.
+- **Piena visibilità** — log in tempo reale, una vista chiara della pipeline e analytics per progetto ti mostrano esattamente cosa è successo e quanto è costato.
+- **La tua macchina, il tuo codice** — tutto gira in locale sul tuo repository reale.
+- **Un unico posto per tutto** — spec, job, chat, un terminale integrato e il monitoraggio dei costi, tutto in un'unica finestra.
+
+Pronto a partire? Prossima tappa: [Installazione e primo avvio](installing-and-first-run).

package/docs/guide/it/getting-started/2-installing-and-first-run.md

@@ -0,0 +1,42 @@
+# Installazione e primo avvio
+
+Mettere specrails sulla tua macchina richiede un paio di minuti. Ecco l'intera procedura.
+
+## 1. Scarica e installa
+
+Procurati l'installer per la tua piattaforma:
+
+- **macOS (Apple Silicon)** — un file `.dmg`. Aprilo e trascina **specrails** nella cartella Applicazioni.
+- **Windows** — un installer `.exe`. Eseguilo e segui le istruzioni.
+
+> **Attenzione agli avvisi di sicurezza su macOS e Windows**
+>
+> - Su **Windows**, l'installer non è ancora firmato digitalmente, quindi SmartScreen potrebbe mostrare un avviso. Clicca su **Ulteriori informazioni → Esegui comunque** per continuare.
+> - Su **macOS**, l'app è firmata e notarizzata, quindi dovrebbe aprirsi senza intoppi.
+
+## 2. Cosa ti serve (prerequisiti)
+
+Specrails esegue pipeline di sviluppo AI pilotando veri strumenti da riga di comando, quindi servono alcune cose. La buona notizia: l'app desktop **ne include la maggior parte già al suo interno** (Node.js, npm e Git sono integrati nell'app), così su una macchina nuova di solito non c'è nulla da installare.
+
+L'unica cosa che specrails non può includere è la **CLI del provider AI** vera e propria. Te ne servirà almeno una tra:
+
+- **Claude Code**
+- **Codex CLI**
+- **Gemini CLI**
+
+Installa quella che intendi usare, accedi una volta dal terminale e sei a posto. Specrails rileva automaticamente quali provider sono presenti.
+
+> Se mai vedessi uno strumento segnalato come mancante, l'app mostra un link **Ulteriori informazioni** con comandi di installazione pronti da copiare e incollare, su misura per il tuo sistema operativo (Homebrew su macOS, winget su Windows, apt/dnf su Linux). Puoi ricontrollare in qualsiasi momento senza riavviare.
+
+## 3. Primo avvio — la schermata di benvenuto
+
+La prima volta che apri specrails, ti ritroverai su una **schermata di benvenuto** pulita. Non ci sono ancora progetti, quindi l'app ti invita ad aggiungere il primo.
+
+Vedrai:
+
+- Una breve descrizione di cosa fa specrails.
+- Un unico pulsante **Aggiungi il tuo primo progetto**.
+
+Questo è tutto l'onboarding — nessun account da creare, nessuna registrazione. Specrails funziona interamente sulla tua macchina.
+
+Clicca su **Aggiungi il tuo primo progetto** e prosegui con [Aggiungere il tuo primo progetto](adding-your-first-project).

package/docs/guide/it/getting-started/3-adding-your-first-project.md

@@ -0,0 +1,58 @@
+# Aggiungere il tuo primo progetto
+
+Un progetto è semplicemente una cartella sul tuo computer che contiene un codebase. Colleghiamone uno.
+
+## Apri la finestra Aggiungi progetto
+
+Clicca su **Aggiungi il tuo primo progetto** nella schermata di benvenuto (oppure, più avanti, sul pulsante **Aggiungi progetto** nella barra laterale sinistra). Compare una piccola finestra di dialogo.
+
+## Inserisci i dettagli
+
+**Cartella del progetto** *(obbligatoria)*
+
+Indica a specrails la cartella che contiene il tuo codice. Nell'app desktop puoi cliccare sull'icona della cartella per sfogliare e sceglierla visivamente, oppure incollare il percorso completo. Dovrebbe essere la radice del tuo repository — la cartella che contiene il codice e (di solito) una directory `.git`.
+
+**Nome del progetto** *(facoltativo)*
+
+Un'etichetta amichevole mostrata nella barra laterale. Se la lasci vuota, specrails usa il nome della cartella.
+
+**Provider**
+
+Scegli quale o quali provider AI dovrà usare questo progetto. Specrails ti mostra quelli che ha rilevato sulla tua macchina:
+
+- 🤖 **Claude**
+- ⚡ **Codex**
+- ✨ **Gemini**
+
+I provider che non ha trovato appaiono in grigio e contrassegnati come *non trovati* — installane uno e accedi, poi riapri la finestra. Per impostazione predefinita ogni provider disponibile è preselezionato, ma puoi deselezionarli fino a tenere solo quello che ti serve. Se ne scegli più di uno, il **primo** diventa il provider predefinito del progetto; potrai poi scegliere quale usare a seconda dell'attività.
+
+> Un controllo rapido viene eseguito in background per confermare che gli strumenti richiesti siano presenti. Se manca qualcosa di essenziale, il pulsante **Aggiungi** resta disabilitato e un link **Ulteriori informazioni** ti fornisce i comandi di installazione esatti.
+
+Clicca su **Aggiungi** per continuare.
+
+## Una configurazione che si completa in pochi secondi
+
+Se la cartella ha già specrails configurato, hai finito — il progetto compare istantaneamente nella tua barra laterale.
+
+Se invece è un progetto nuovo, parte una breve **procedura guidata di configurazione**. Si articola in tre passaggi:
+
+1. **Configura** — conferma le impostazioni di base per ciascun provider che hai scelto.
+2. **Installa** — specrails configura il progetto automaticamente. Si tratta dell'installazione *rapida*: agenti template pronti all'uso, predisposti nel giro di pochi secondi. Vedrai un log in tempo reale durante l'esecuzione.
+3. **Fatto** — un riepilogo che conferma che è tutto pronto.
+
+Per un progetto multi-provider, l'installazione viene eseguita una volta per provider, uno dopo l'altro, e il passaggio Fatto mostra una scheda per ciascuno.
+
+## Cosa viene installato
+
+La configurazione è volutamente leggera e **non invasiva**. Specrails aggiunge una piccola quantità di configurazione al tuo progetto così che la pipeline sappia come funzionare:
+
+- Una cartella `.specrails/` che contiene i profili degli agenti e le impostazioni locali del progetto.
+- Definizioni di agenti sotto `.claude/agents/` che alimentano la pipeline Architect → Developer → Reviewer → Ship.
+
+Tutto qui — specrails non riscriverà il tuo codice sorgente durante la configurazione, e questi file possono tranquillamente essere committati se vuoi condividere la configurazione con il tuo team.
+
+> **Preferisci la configurazione approfondita?** L'app propone di proposito l'installazione rapida basata su template. Se preferisci il flusso arricchito dall'AI (analisi del codebase e personas di agenti personalizzate), puoi eseguire `npx specrails-core@latest init` dalla cartella del tuo progetto in un terminale.
+
+## Ci sei
+
+Una volta terminata la configurazione, specrails ti porta direttamente nella dashboard del tuo progetto. È il momento del tour — vai a [Il tour della dashboard](the-dashboard-tour).

package/docs/guide/it/getting-started/4-the-dashboard-tour.md

@@ -0,0 +1,53 @@
+# Il tour della dashboard
+
+Con un progetto aggiunto, ora hai davanti la tua **dashboard del progetto** — il quartier generale per trasformare le spec in codice consegnato. Ecco come orientarti.
+
+## Il quadro generale
+
+La finestra è divisa in tre zone:
+
+- **Barra laterale sinistra** — l'elenco dei tuoi progetti. Clicca su un progetto qualsiasi per passarci all'istante; tutto il resto della finestra si aggiorna di conseguenza. Anche il pulsante **Aggiungi progetto** si trova qui.
+- **Area principale** — la dashboard del progetto attivo: le tue spec e la pipeline che le esegue.
+- **Barra laterale destra** — la navigazione tra le sezioni del progetto corrente.
+
+## La dashboard principale
+
+È qui che avviene il lavoro. La dashboard mostra:
+
+- **Le tue spec** — i ticket che hai creato, organizzati per stato (da Backlog/Da fare fino a Completato). Puoi visualizzarle come elenco, come griglia o come schede tipo post-it, a seconda di cosa preferisci.
+- **Un modo per aggiungere una spec** — avvia un nuovo intervento. Puoi scrivere una spec rapida direttamente, oppure aprire una chat guidata **Explore** che ti aiuta a darle forma attraverso la conversazione e redige il ticket al posto tuo.
+- **I rail** — sono le corsie in cui le spec vengono costruite. Trascina una spec su un rail e avviala per farla passare attraverso la pipeline Architect → Developer → Reviewer → Ship. Più rail possono essere eseguiti contemporaneamente, così puoi lavorare a più cose in parallelo.
+
+Quando una spec è in esecuzione, ne vedrai l'avanzamento nella pipeline e i log in tempo reale — l'output istantaneo dell'AI mentre progetta, scrive il codice e revisiona la tua modifica.
+
+## La barra laterale destra: le sezioni del progetto
+
+La barra laterale destra è il tuo centralino per il progetto corrente. Passaci sopra il cursore per espanderla, oppure fissala aperta. Le sezioni che troverai:
+
+- **Dashboard** — la board delle spec e i rail (dove ti trovavi poco fa).
+- **Job** — ogni esecuzione della pipeline per questo progetto, passata e presente, con stato, durata e la possibilità di approfondire il dettaglio e i log di ciascuna esecuzione.
+- **Analytics** — quanto ti sta costando l'uso dell'AI. La spesa suddivisa per giorno, per attività, per modello e per ticket — così niente sorprese.
+- **Agenti** — i profili degli agenti del tuo progetto: quali agenti vengono eseguiti nella pipeline e quali modelli AI usano. *(Solo per i progetti basati su Claude.)*
+- **Codice** — un browser di file in sola lettura con riepiloghi AI in linguaggio semplice, e dei chip che indicano quali file l'AI ha toccato. Ottimo per chi non è sviluppatore ma vuole seguire ciò che accade.
+- **Integrazioni** — componenti aggiuntivi opzionali, come collegare le tue spec a una board **Jira** o abilitare strumenti extra per l'AI.
+- **Impostazioni** — opzioni per progetto (telemetria, budget, configurazione dei provider e altro ancora).
+
+> Alcune sezioni compaiono solo quando hanno senso per i provider che hai scelto — per esempio, **Agenti** è specifica di Claude. Se non vedi una sezione, semplicemente non si applica alla configurazione di questo progetto.
+
+## La barra di stato
+
+Una sottile striscia corre lungo il bordo inferiore della finestra. È piccola ma utile:
+
+- **Indicatore di connessione** (a sinistra) — un pallino colorato e un'etichetta che mostrano che l'app è attiva: verde per *connesso*, ambra durante la *riconnessione*, blu durante la *sincronizzazione* subito dopo una riconnessione. Raramente ne avrai bisogno, ma è rassicurante quando serve.
+- **Spesa totale** (a destra) — un totale aggiornato di quanto hai speso, così il costo è sempre a portata di sguardo.
+- **Interruttore del terminale** (all'estrema destra) — apre il pannello del terminale integrato. Premi **Cmd+J** (macOS) o **Ctrl+J** (Windows/Linux) per aprirlo o chiuderlo in qualsiasi momento. È una shell completa, aperta direttamente nella cartella del tuo progetto.
+
+## Qualche scorciatoia utile
+
+- **Cmd/Ctrl+B** — fissa o comprimi le barre laterali.
+- **Cmd/Ctrl+J** — apri o chiudi il pannello del terminale.
+- **Cmd/Ctrl+K** — apri la ricerca.
+
+## Dove andare adesso
+
+Questo è il quadro generale. Da qui, la prima mossa naturale è **aggiungere una spec** e avviarla su un rail — guarda la pipeline scorrere dall'inizio alla fine, poi controlla le **Analytics** per vedere quanto è costata. Benvenuto a bordo.

package/docs/guide/it/insights/1-analytics-and-cost-tracking.md

@@ -0,0 +1,78 @@
+# Analytics e monitoraggio dei costi
+
+Ogni volta che Specrails esegue una CLI AI per tuo conto — un job della pipeline, una spec rapida, una sessione Explore, un raffinamento AI, un riepilogo di file — registra cosa è successo: quale modello è stato eseguito, quanti token sono entrati e usciti, quanto tempo è servito e quanto è costato. La sezione **Analytics** trasforma tutto questo in un'unica dashboard, così sai sempre dove sta andando la tua spesa AI.
+
+Aprila dalla barra laterale destra (è etichettata **Analytics**). Tutto ciò che vedi è circoscritto al progetto in cui ti trovi: cambia progetto e i numeri lo seguono.
+
+## Cosa conta come spesa
+
+Specrails tiene traccia di cinque tipi di attività AI, chiamati *origini*. A ciascuna è associato un colore coerente in tutti i grafici, così puoi riconoscerla a colpo d'occhio:
+
+- **Job** — un rail della pipeline che esegue Architect → Developer → Reviewer → Ship.
+- **Quick** — una spec generata tramite il percorso rapido di Add Spec.
+- **Explore** — una conversazione Explore in cui dai forma a una spec chiacchierando.
+- **Raffinamento** — un raffinamento assistito dall'AI su un agente o su un file.
+- **Riepiloghi file** — i riepiloghi in linguaggio semplice che alimentano il Code explorer.
+
+Un paio di cose, di proposito, *non* vengono tracciate: sia la chat nella barra laterale sia il setup wizard avviano CLI AI, ma non compaiono mai nella tua spesa. Così la dashboard riflette lavoro reale e ripetibile, non chiacchiere occasionali.
+
+## Leggere la dashboard
+
+La pagina è composta da una manciata di blocchi, dall'alto verso il basso:
+
+### Il meter di consumo (Hero)
+
+Il grande numero in cima è la tua spesa totale per il periodo selezionato, con un delta **vs prec.** che ti permette di capire al volo se la tendenza è in salita o in discesa rispetto alla finestra precedente. Se hai appena iniziato a usare un progetto, lo stato vuoto ti dice quando è cominciato il tracciamento ("Tracciamento iniziato il YYYY-MM-DD") — non c'è alcun recupero dei dati storici, quindi il meter conosce solo le esecuzioni avvenute mentre eri su questa versione.
+
+### Timeline giornaliera
+
+Un grafico a barre impilate della spesa per giorno, suddivisa per origine. I giorni senza attività sono mostrati come zero anziché saltati, così la forma della tua settimana resta onesta. È il modo più rapido per vedere *quando* è stato eseguito un batch costoso.
+
+### Quick vs Explore
+
+Una scheda affiancata che confronta i tuoi due stili di creazione delle spec. Se hai eseguito meno di cinque sessioni Explore, mostra un gentile invito all'azione invece di medie fuorvianti — i campioni piccoli non danno confronti affidabili.
+
+### Per modello
+
+I tuoi modelli più costosi per spesa (fino a dieci). Clicca un modello qualsiasi per filtrare l'intera dashboard solo su quel modello — comodo quando vuoi sapere quanto ti sta costando davvero un particolare modello di fascia alta.
+
+### Dispersione Costo vs Turni
+
+Ogni punto è un'invocazione, che mette in relazione il costo con il numero di turni. I valori anomali — le esecuzioni costose e con molti turni — saltano subito all'occhio. (La dispersione mostra i tuoi 500 punti più recenti per restare reattiva.)
+
+### Top ticket
+
+I dieci ticket più costosi su *tutte* le origini messe insieme, così un ticket che è costato poco in Explore e molto in un job mostra il suo totale reale. I ticket eliminati e le esecuzioni non attribuite hanno i loro contenitori dedicati, così nulla scompare silenziosamente dai totali.
+
+### Tabella delle invocazioni grezze
+
+La verità di base: una riga per invocazione. Questo blocco ha i propri filtri secondari, che agiscono solo sulla tabella, così puoi approfondire senza disturbare i grafici sopra.
+
+## Filtri
+
+L'intestazione fissa in cima porta i due filtri principali — **periodo** e **origine** — ed entrambi vengono salvati nell'URL della pagina. Questo significa che puoi aggiungere ai segnalibri o condividere una vista filtrata ("ultimi 30 giorni, solo job") e si riaprirà esattamente come l'avevi lasciata. I filtri della tabella grezza sono separati e restano locali a quel blocco.
+
+Una nota sull'accuratezza: le esecuzioni fallite e interrotte vengono tenute fuori dalle *medie di costo* (distorcerebbero i numeri per esecuzione), ma contano comunque nel conteggio totale delle esecuzioni e nel tasso di fallimento. Così le medie restano pulite e il quadro sull'affidabilità resta completo.
+
+## Costo per ticket
+
+Non devi venire alla pagina Analytics per vedere quanto è costata una spec. Apri un ticket qualsiasi e, se ha una spesa associata, vedrai un riepilogo su una riga proprio sotto il titolo:
+
+> $0.42 · 6 turni · 1m 12s attivi · dettaglio
+
+Cliccaci e atterri sulla pagina Analytics già filtrata su quel ticket. È il percorso più rapido da "quanto mi è costata questa funzionalità?" al dettaglio completo.
+
+## Esportare i tuoi dati
+
+Quando ti servono i numeri fuori dall'app — un foglio di calcolo, un report finanziario, la tua analisi — usa il menu a tendina **Export**. Offre quattro formati:
+
+- **CSV riepilogo** — un file multi-sezione con totali, timeline giornaliera, per origine, per modello e top ticket.
+- **JSON riepilogo** — lo stesso riepilogo, strutturato.
+- **CSV raw** — ogni riga di invocazione (fino a 10.000; segnala se ha dovuto troncare).
+- **JSON raw** — le stesse righe grezze, strutturate.
+
+Le esportazioni rispettano i filtri di periodo e origine che hai attualmente applicato, e i file vengono nominati in modo da ordinarsi in modo sensato: `<project>-analytics-<period>-<date>.csv`. Il pulsante è disabilitato quando non c'è nulla da esportare, e riceverai un chiaro toast di errore se un download fallisce.
+
+## Sempre aggiornato
+
+Non devi ricaricare. Quando una nuova invocazione viene registrata in qualsiasi punto del progetto, la dashboard aperta si aggiorna in silenzio un istante dopo, così il meter di consumo tiene il passo con il lavoro man mano che si completa.

package/docs/guide/it/insights/2-the-integrated-terminal.md

@@ -0,0 +1,46 @@
+# Il terminale integrato
+
+Specrails ha un vero terminale incorporato — il pannello che scorre verso l'alto dal fondo della finestra, proprio come quello di VS Code o Cursor. Esegue la tua shell reale, nella directory reale del tuo progetto, così puoi lanciare `git`, `npm`, i test o qualunque altra cosa senza uscire dall'app.
+
+## Aprirlo e chiuderlo
+
+Il modo più rapido è la tastiera: **Cmd+J** (macOS) o **Ctrl+J** (Windows/Linux) apre e chiude il pannello, e mette a fuoco il terminale nel momento in cui compare, così puoi iniziare a digitare subito. Puoi anche usare il chevron nella barra di stato.
+
+Il pannello ha tre stati:
+
+- **Nascosto** — riposto via.
+- **Ripristinato** — il normale pannello ad altezza dimezzata.
+- **Massimizzato** — occupa l'area di lavoro quando ti serve spazio per leggere l'output.
+
+Comprimere il pannello (il chevron) **non** ferma nulla — le tue shell continuano a girare in background. L'unica cosa che termina davvero una sessione è chiuderla (l'icona del cestino, o la ✕ del singolo tab).
+
+## Più sessioni
+
+Puoi eseguire diversi terminali contemporaneamente nello stesso progetto — fino a dieci. Ciascuno ottiene il proprio tab; puoi rinominarli così "dev server" e "test" non si confondono. Partono tutti nella cartella del tuo progetto e caricano il profilo della tua shell (`.zshrc`, `.bashrc` e così via), quindi i tuoi alias e il PATH sono esattamente quelli che ti aspetti.
+
+Ecco la parte importante: i tuoi terminali **sopravvivono ai cambi di progetto e di tab**. Specrails tiene viva e intatta ogni sessione dietro le quinte — scrollback, processi in esecuzione, tutto — così passare a Analytics e tornare indietro non resetta la tua shell né interrompe un comando di lunga durata. Le sessioni terminano solo quando le chiudi esplicitamente (o quando rimuovi l'intero progetto).
+
+## Per progetto, ricordato
+
+Se il pannello è aperto, quanto in alto lo hai trascinato, quali tab esistono — tutto questo viene ricordato **per progetto**. Torna a un progetto ed è configurato come lo avevi lasciato.
+
+## Le funzionalità premium
+
+Questa non è una console essenziale. Il terminale arriva con le comodità che ti aspetteresti da uno di prima categoria:
+
+- **Rendering veloce e nitido** tramite WebGL (con un fallback automatico così non si rompe mai), gestione completa della larghezza Unicode e legature dei font.
+- **Cerca nello scrollback** con **Cmd+F** — ottimo per trovare quell'errore sepolto 500 righe più su.
+- **Zoom del font** con **Cmd+=**, **Cmd+-** e **Cmd+0** per ripristinare.
+- **Scorciatoie per gli appunti** — Cmd+C / Cmd+V per copiare e incollare, Cmd+K per pulire — più un menu contestuale con il tasto destro.
+- **Trascina e rilascia i percorsi dei file** (nell'app desktop): rilascia un file sul terminale e il suo percorso viene inserito, opportunamente quotato per la tua shell.
+- **Ridimensionamento fluido** — trascinare l'altezza del pannello o comprimere la barra laterale non fa tremolare l'output.
+- **Immagini in linea** — i terminali che emettono immagini in stile Sixel o iTerm2 le mostrano direttamente sul posto.
+- **Integrazione con la shell** — Specrails sa dove inizia e finisce ogni comando, così può tenere traccia della cronologia dei comandi e avvisarti quando un comando di lunga durata si completa (una notifica desktop, con un fallback nel browser). Se per qualche motivo la tua shell non può essere strumentata, degrada in silenzio e te lo dice una volta.
+
+## Impostazioni
+
+Le preferenze del terminale vivono su due livelli: un'impostazione predefinita a livello di app e un'override opzionale per progetto. L'impostazione per progetto ha la precedenza quando è presente, così puoi mantenere un aspetto coerente globale ritoccando il singolo progetto che ha bisogno di qualcosa di diverso.
+
+## Disattivarlo
+
+Il terminale è attivo per impostazione predefinita. Se preferisci non averlo, può essere disabilitato tramite i flag `VITE_FEATURE_TERMINAL_PANEL` (client) o `SPECRAILS_TERMINAL_PANEL` (server) — imposta uno dei due su `false`. La maggior parte delle persone lo lascerà semplicemente attivo.

package/docs/guide/it/insights/3-code-explorer.md

@@ -0,0 +1,50 @@
+# Code explorer
+
+La sezione **Code** ti offre una finestra amichevole e in sola lettura sul tuo repository — pensata in particolare per chi vuole capire cosa ha costruito l'AI senza dover vivere in un editor. Hai un albero dei file a sinistra, un visualizzatore di codice a destra e, sopra il codice, un riepilogo in linguaggio semplice di cosa fa davvero ogni file.
+
+In questa versione è rigorosamente in sola lettura: nulla di ciò che fai qui modifica i tuoi file. Pensala come una sala di lettura, non un'officina.
+
+Aprila dalla barra laterale destra (**Code**) e, come tutto il resto, è circoscritta al progetto corrente.
+
+## L'albero dei file
+
+Il riquadro di sinistra è un albero virtualizzato dei file del tuo progetto — veloce anche su repo di grandi dimensioni. Rispetta il tuo `.gitignore` e una deny-list integrata, così vedi i file che contano, non un mare di artefatti di build e `node_modules`.
+
+Accanto ai file noterai dei **marcatori di provenienza** — piccoli indicatori che ti dicono che un file è stato *toccato dall'AI*. È questo il cuore del Code explorer: Specrails registra quali file ogni job della pipeline ha creato o modificato, e li ricollega al ticket che ha avviato il lavoro. Così puoi rispondere, a colpo d'occhio, a "l'ha scritto l'AI, o l'ho fatto io?".
+
+In cima all'albero c'è un filtro:
+
+- **Toccati dall'AI** (predefinito) — solo i file che l'AI ha modificato.
+- **Tutti i file** — l'albero completo.
+
+La tua scelta viene ricordata per progetto, così se ti interessano soprattutto le modifiche scritte dall'AI le vedrai per prime ogni volta.
+
+## Il visualizzatore di codice
+
+Clicca un file e si apre in un visualizzatore completo (basato su Monaco, lo stesso motore di VS Code) con un'evidenziazione della sintassi adeguata che si abbina al tema dell'app che hai scelto. Un paio di limiti ragionevoli mantengono tutto fluido: i file binari vengono educatamente rifiutati e i file molto grandi (oltre 2 MB) non vengono caricati.
+
+Il file corrente viene salvato nell'URL della pagina, così puoi aggiungere ai segnalibri o condividere un link diretto a un file specifico.
+
+Poiché la modifica non fa parte di questa versione, il visualizzatore offre un pulsante **Modifica in un editor esterno** che copia il percorso assoluto del file — incollalo nell'editor che preferisci e riparti da lì.
+
+## Riepiloghi AI
+
+Sopra il codice vedrai un **riepilogo in linguaggio semplice** del file — a cosa serve, cosa fa — scritto in modo che anche chi non è uno sviluppatore possa seguirlo. Vengono generati per te e messi in cache, così aprire un file che hai già guardato è istantaneo.
+
+I riepiloghi sono attenti a restare aggiornati: sono legati al contenuto del file, così quando un file cambia davvero il riepilogo viene rigenerato, mentre i file invariati non vengono ri-riassunti inutilmente. Se modifichi tu stesso un file, il suo riepilogo viene contrassegnato come obsoleto anziché rigenerato in silenzio — resti tu a decidere quando aggiornarlo. C'è un'azione di **rigenerazione** per quando vuoi una nuova versione a richiesta.
+
+Un paio di garanzie tengono i costi ragionevoli: la generazione dei riepiloghi avviene entro un **budget mensile** (qualche dollaro per impostazione predefinita, configurabile nelle Impostazioni), e ci sono limiti su quanti riepiloghi un singolo job può avviare. Se un riepilogo viene saltato, l'app ti dice perché — budget raggiunto, un limite per job, o semplicemente il file non trovato.
+
+Puoi anche scegliere la **lingua dei riepiloghi** (inglese o spagnolo) nelle impostazioni globali, nell'area *Code section*.
+
+## Collegare il codice alle spec
+
+Il legame di provenienza funziona in entrambe le direzioni. All'interno del Code explorer, cliccare il chip di un ticket su un file apre il dettaglio di quel ticket. E dall'altro lato, la vista di **dettaglio del ticket** ha una sezione *File toccati da questo ticket* — clicca un file lì e salti dritto nel Code explorer con quel file aperto. Chiude il cerchio tra "ecco la spec che abbiamo scritto" ed "ecco il codice che ne è uscito".
+
+## Cosa non fa (ancora)
+
+Per fissare le aspettative con chiarezza, questa prima versione lascia di proposito fuori alcune cose: la modifica all'interno dell'app, i riepiloghi per simbolo o a livello di directory, una vista diff narrativa e il "chiedi all'AI di questo file" in forma conversazionale. La provenienza attribuisce un file solo al suo ticket principale. Sono il genere di cose che potrebbero crescere nel tempo.
+
+## Disattivarlo
+
+Il Code explorer è attivo per impostazione predefinita. Può essere disabilitato con i flag `VITE_FEATURE_CODE_EXPLORER` (client) o `SPECRAILS_CODE_EXPLORER` (server) — imposta uno dei due su `false`. Disattivarlo lascia tutti i tuoi dati registrati e i riepiloghi al sicuro su disco, intatti, nel caso tu voglia riattivarlo.

package/docs/guide/it/integrations/1-ai-providers.md

@@ -0,0 +1,64 @@
+# Provider AI (Claude, Codex, Gemini)
+
+Specrails non è legato a una sola AI. Ogni parte dell'app che dialoga con un'AI — Explore Spec, Quick spec, i rail, la chat, AI Edit, il pulsante "Open AI CLI" del terminale — può funzionare con uno qualsiasi dei tre provider di prima classe. Scegli tu quali usare in un progetto, e puoi addirittura cambiare provider task per task.
+
+## I tre provider
+
+| Provider | CLI | Realizzato da | Note |
+|---|---|---|---|
+| **Claude** | `claude` | Anthropic | Il più completo. È l'unico provider per gli Agenti (profili), i rail Ultracode e il Contract Refine. |
+| **Codex** | `codex` | OpenAI | Richiede codex `0.128.0+`. Legge i suoi server MCP dal file globale `~/.codex/config.toml`. |
+| **Gemini** | `gemini` | Google | Richiede gemini `0.11.0+`. Usa la telemetria nativa e un file di istruzioni `GEMINI.md`. |
+
+Tutti e tre sono **abilitati di default**. Un provider compare in **Add Project** ogni volta che la sua CLI è installata e presente nel tuo `PATH`. Quindi il primo passo è sempre lo stesso: installa la CLI che vuoi usare e accedi con essa, esattamente come descritto nella documentazione di quello strumento. Una volta che `claude --version` (o `codex`, o `gemini`) funziona nel tuo terminale, Specrails può usarla.
+
+## Installare un provider per un progetto
+
+Quando aggiungi un progetto, la procedura guidata di setup ti chiede quale provider (o quali provider) installare. Scegline uno, completa il passo di installazione e hai finito. Da quel momento il progetto *ha* semplicemente quel provider — non dovrai più pensarci. Spec, rail, chat e analisi funzionano tutti allo stesso modo, indipendentemente da quale hai scelto.
+
+Se una CLI che vuoi usare non viene proposta in Add Project, quasi sempre è perché la CLI non è installata oppure non è presente nel tuo `PATH`. Installala e poi riapri Add Project.
+
+## Installare più provider in un solo progetto
+
+Puoi installare **più di un** provider nello stesso progetto — per esempio Claude *e* Gemini. In **Add Project** l'elenco dei provider diventa una serie di caselle di spunta: seleziona tutti quelli che ti servono. Il primo che selezioni diventa il provider **primario** (predefinito) del progetto; gli altri restano disponibili come alternative.
+
+Qualche cosa utile da sapere sui progetti multi-provider:
+
+- **Con un solo provider tutto si comporta esattamente come prima.** Se un progetto ha un unico provider, non vedrai mai un selettore di provider da nessuna parte — l'app resta pulita e semplice.
+- **La barra laterale destra mostra solo le sezioni supportate da tutti i provider installati.** Poiché gli Agenti (profili) sono un concetto esclusivo di Claude, la sezione **Agenti** scompare nel momento in cui un progetto include un provider diverso da Claude. Tutto il resto (Spec, Code, Analisi, Integrazioni, Terminale, Chat) rimane.
+- **La scelta dei provider è bloccata dopo la creazione.** In questa versione scegli i tuoi provider quando aggiungi il progetto e non possono essere modificati in seguito dalle Impostazioni. Se ti serve un mix diverso, crea un nuovo progetto.
+
+## Scegliere un provider per ogni invocazione
+
+Il vero vantaggio di un progetto multi-provider è poter scegliere l'AI giusta per ciascun task — senza toccare alcuna impostazione globale. Ovunque venga eseguita un'AI compare un piccolo selettore di provider (solo quando il progetto ne ha più di uno):
+
+- **Add Spec** — un selettore di motore ti permette di esplorare o generare in modalità Quick una spec con il provider che preferisci.
+- **Intestazione del rail** — scegli il motore per quello specifico rail prima di avviarlo.
+- **Terminale** — il pulsante "Open AI CLI" (Sparkles) apre un menu dei provider così puoi entrare in una qualsiasi CLI installata nella cartella di quel progetto.
+
+La tua scelta viene ricordata per progetto, con il provider primario come default, così non devi riselezionarla ogni volta.
+
+## Cosa può fare solo Claude
+
+Alcune funzioni sono per natura specifiche di Claude, quindi vengono nascoste o saltate quando è in uso un altro provider:
+
+- **Agenti (profili)** — il catalogo degli agenti per progetto e il routing dei modelli. Nascosti in qualsiasi progetto che includa un provider diverso da Claude.
+- **Rail Ultracode** — vengono sempre eseguiti su Claude.
+- **Contract Refine** — il passaggio aggiuntivo "Contract Layer" su una spec confermata viene eseguito solo quando il provider della conversazione è Claude.
+- **Modalità avanzate di Add Spec** (SMASH / Contract Layer) — nascoste per i motori diversi da Claude.
+
+Tutto il resto — Explore, Quick spec, l'intera pipeline dei rail, AI Edit, chat, analisi dei costi — funziona con tutti e tre.
+
+## Tracciamento dei costi tra i provider
+
+La pagina **Analisi** traccia ogni invocazione fatturabile, indipendentemente dal provider. Sui progetti multi-provider aggiunge dei chip di filtro per motore così puoi confrontare la spesa per provider. Claude riporta il proprio costo esatto; per Codex e Gemini, Specrails stima il costo da un listino integrato, quindi i numeri sono approssimazioni vicine al reale più che importi effettivamente addebitati.
+
+## Risoluzione dei problemi
+
+- **Un provider che ho installato non viene proposto.** Verifica che la CLI sia presente nel tuo `PATH` (prova `claude --version` / `codex --version` / `gemini --version` in un terminale nuovo). L'app sonda le CLI dei provider tramite il `PATH` di sistema.
+- **I server MCP di Codex non si caricano in chat.** Codex legge i server MCP dal file globale `~/.codex/config.toml` — registrali lì con `codex mcp add`.
+- **Disabilitazione d'emergenza.** Un provider può essere disattivato a livello di app tramite una variabile d'ambiente (`SPECRAILS_CODEX_BETA=0` o `SPECRAILS_GEMINI_BETA=0`). Questo nasconde il provider solo dalla *selezione*; raramente è necessario.
+
+## Vedi anche
+
+Le guide dedicate ai provider approfondiscono ciascuna CLI: la guida di Codex e la guida di Gemini coprono ognuna il setup, cosa funziona e le particolarità specifiche del provider.