create-pwt 1.0.0

package/template/.claude/skills/task/SKILL.md

@@ -0,0 +1,360 @@
+---
+name: task
+description: Orchestratore task workflow — gestisce interrogazione, esecuzione sub-agent e salvataggio output
+---
+
+# Orchestratore task workflow
+
+Stai eseguendo la task **$ARGUMENTS** del progetto.
+
+## Procedura
+
+### 0. Verifica preferenze (pre-flight)
+
+Leggi `system/preferences.json`. Controlla che i campi richiesti per la fase corrente siano compilati (non `""`).
+
+| Fase | Campi richiesti |
+|---|---|
+| 1 | `identity.name`, `identity.role` |
+| 2 | — *(conventions hanno default validi)* |
+| 3 | `accounts.figma` *(solo se skill design attivo)* |
+| 4 | `stack.frontend.framework`, `stack.backend.approach`, `stack.database.primary` |
+| 5 | `stack.*`, `deploy.frontend`, `deploy.database`, `accounts.github` |
+| 6 | — *(sentry/posthog opzionali)* |
+| 7 | `identity.piva`, `identity.email`, `deploy.frontend`, `deploy.database`, `deploy.github_org_or_user`, `legal.privacy_policy_template`, `legal.cookie_consent`, `accounts.vercel`, `accounts.supabase` |
+| 8 | `accounts.posthog` |
+
+Se uno o più campi richiesti sono vuoti:
+1. Elenca i campi mancanti
+2. Chiedi: "Prima di procedere ho bisogno di alcune informazioni. Le compilo ora?"
+3. **Se SÌ** → poni le domande una alla volta (vedi tabella domande in `.claude/skills/setup/SKILL.md`), aggiorna `system/preferences.json` dopo ogni risposta, poi procedi al punto 1
+4. **Se NO** → scrivi: "Ok. Riprendi con `/task $ARGUMENTS` quando sei pronto." e fermati
+
+---
+
+### 1. Carica contesto
+- Leggi `STATE.json` — identifica il progetto corrente
+- Leggi `system/workflow-v5.json` — carica SOLO la task con `id == "$ARGUMENTS"`
+- Carica gli output elencati in `task.depends_on` (es. `docs/phases/0/0.1-output.md`)
+
+**Se `STATE.json` ha `roadmap_generated == true`:**
+- Leggi `docs/ROADMAP.json` e controlla lo status della task corrente:
+  - `"skipped"` → scrivi: "La task **$ARGUMENTS** è stata esclusa dalla roadmap: _[reason]_. Passo alla prossima task inclusa." Poi avanza `current_task` in STATE.json alla task successiva con status `included` o `simplified` e fermati.
+  - `"simplified"` → procedi normalmente ma aggiungi all'inizio del contesto: "⚡ Modalità semplificata: _[note]_"
+  - `"included"` → procedi normalmente
+
+**Se `task.is_gate == true`:** salta i punti 2 e 3, vai direttamente al punto 2-GATE.
+
+### 2. Loop interrogazione (OBBLIGATORIO — solo se `is_gate: false`)
+Poni tutte le domande in `task.questions`, **una alla volta**, nell'ordine dato.
+
+Regole ferme durante l'interrogazione:
+- Ogni risposta è valida, anche "non so" o "non ho controllato" — annota la lacuna e vai avanti
+- Non cercare informazioni autonomamente
+- Non scrivere file
+- Non generare output o anteprime
+- Non saltare domande anche se pensi di avere già la risposta
+
+### 2-GATE. Verifica gate (solo se `is_gate: true`)
+
+1. Leggi tutti gli output della fase (elencati in `task.depends_on`)
+2. Per ogni voce della `task.checklist`, determina: ✅ soddisfatta / ⚠️ parziale / ❌ mancante
+3. Presenta il risultato in questo formato:
+
+   ```
+   ## Gate X.Y — [Nome fase]
+
+   | # | Criterio | Stato | Note |
+   |---|---|---|---|
+   | 1 | [criterio] | ✅/⚠️/❌ | [eventuale nota] |
+   ...
+
+   **Problemi aperti:** [lista, oppure "nessuno"]
+   **Decisione suggerita:** PROCEDI / BLOCCA
+   ```
+
+4. Chiedi: "**Confermi la decisione?** Rispondi PROCEDI o BLOCCA (oppure dammi feedback su cosa rivedere)."
+   - **BLOCCA** → indica quale task riaprire, poi FERMATI
+   - **PROCEDI** → vai al punto 6-GATE
+
+### 3. Esecuzione tramite task-agent (solo se `is_gate: false`)
+
+**Check ripresa:** se `STATE.json.checkpoint` non è null E `checkpoint.task_id == task corrente`:
+- Se `checkpoint.stato == "done"` → vai direttamente al punto 4 (output già pronto)
+- Se `checkpoint.stato == "partial"` → tratta il checkpoint come appena arrivato, vai al punto 3b (non rilancia da zero — lo stato è già salvato)
+
+**Altrimenti (prima esecuzione o checkpoint di task diversa):**
+Annuncia: "Eseguo task **[id]** — [titolo]..."
+
+#### 3a. Costruisci il prompt e lancia il sub-agent `task-agent`
+
+```
+TASK_ID: <task.id>
+TASK_TITLE: <task.title>
+SKILL: <task.skill oppure "null">
+ITERAZIONE: 1
+CONTESTO_AGGIUNTIVO: nessuno
+
+OUTPUT_DIPENDENZE:
+<Per ogni id in task.depends_on: contenuto completo di docs/phases/<X>/<id>-output.md. Se mancante: "[OUTPUT <id> NON TROVATO]">
+
+RISPOSTE_INTERROGAZIONE:
+<Per ogni domanda posta al punto 2: "- <domanda>: <risposta>">
+
+OUTPUT_SCHEMA:
+<sezioni da task.output_schema.sections, una per riga>
+Formato: <task.output_schema.format>
+Lunghezza: <task.output_schema.length>
+
+DOD:
+<task.dod>
+
+CHECKPOINT_PRECEDENTE:
+nessuno
+```
+
+#### 3b. Gestisci la risposta del sub-agent
+
+Leggi il JSON ricevuto. **Se `iterazione >= 5` E `stato == "partial"`:** mostra avviso:
+> "⚠️ Il sub-agent è bloccato da 5 iterazioni su: [bloccato_su]. Vuoi procedere con l'output parziale disponibile, o annullare?"
+> - **Procedi** → tratta `risultato_parziale` come `output_finale` e vai al punto 4
+> - **Annulla** → imposta `STATE.json.checkpoint = null` e fermati
+
+**Se il sub-agent non risponde con JSON valido:**
+> "⚠️ Il sub-agent ha restituito un output non valido. Vuoi riprovare o procedere manualmente?"
+> - **Riprova** → rilancia il sub-agent con lo stesso prompt (torna al punto 3a se iterazione 1, altrimenti 3c)
+> - **Manuale** → imposta `STATE.json.checkpoint = null` e fermati
+
+**Se `stato == "partial"`:**
+1. Salva il checkpoint in `STATE.json.checkpoint` (aggiorna il file)
+2. Mostra all'utente:
+   ```
+   ## Elaborazione in corso — iterazione <iterazione>
+   **Completato:** <lista checkpoint.completato in bullet>
+   **Informazione necessaria:** <checkpoint.bloccato_su>
+   ---
+   <checkpoint.contesto_necessario>
+   ```
+3. Aspetta risposta → vai al punto 3c
+
+**Se `stato == "done"`:**
+1. Salva il checkpoint in `STATE.json.checkpoint`
+2. Vai al punto 4
+
+#### 3c. Rilancio sub-agent con contesto aggiuntivo
+
+```
+TASK_ID: <task.id>
+TASK_TITLE: <task.title>
+SKILL: <task.skill oppure "null">
+ITERAZIONE: <checkpoint.iterazione + 1>
+CONTESTO_AGGIUNTIVO: <risposta dell'utente>
+
+OUTPUT_DIPENDENZE:
+<stesso contenuto del lancio precedente>
+
+RISPOSTE_INTERROGAZIONE:
+<stesse risposte del lancio precedente>
+
+OUTPUT_SCHEMA:
+<stesso schema>
+
+DOD:
+<stesso dod>
+
+CHECKPOINT_PRECEDENTE:
+<JSON del checkpoint corrente, indentato>
+```
+
+Lancia il sub-agent → torna al punto 3b.
+
+### 4. Validazione (dopo `stato == "done"`)
+
+Recupera `output_finale` da `STATE.json.checkpoint`.
+
+**Se `checkpoint.decisioni_da_approvare` non è vuoto**, mostra prima:
+> "## Decisioni prese durante l'elaborazione
+> <lista decisioni in bullet>
+> Confermi queste scelte o vuoi modificare qualcosa?"
+
+Aspetta conferma o feedback. Se l'utente chiede modifiche → vai al punto 3c con il feedback come `CONTESTO_AGGIUNTIVO`.
+
+**Se confermato (o se `decisioni_da_approvare` è vuoto):**
+> "**Output approvato?** Rispondi SÌ per salvare, oppure dammi feedback per raffinare."
+- **SÌ** → vai al punto 5
+- **Feedback** → vai al punto 3c con il feedback come `CONTESTO_AGGIUNTIVO`
+
+### 5. Salva e chiudi (solo dopo SÌ esplicito)
+
+**Pre-validazione STATE.json** — prima di scrivere il file, verifica mentalmente che il JSON prodotto rispetti `system/schemas/state.schema.json`:
+- `workflow.current_task` deve rispettare il pattern `N.N` (es. `"1.2"`) — non `"1"`, non `"fase1"`)
+- `workflow.status` deve essere esattamente uno tra: `"not_started"`, `"in_progress"`, `"completed"`
+- `workflow.current_phase` deve essere un intero tra 0 e 8
+- `completed_tasks` deve essere un array di stringhe in formato `N.N`
+- Tutti i campi `required` devono essere presenti (vedi schema per lista completa)
+- Se un campo è ambiguo, usa il valore di default definito nello schema, non inventarne uno
+
+1. Salva output in `docs/phases/<phase_id>/<task_id>-output.md`
+1a. Imposta `STATE.json.checkpoint` a `null` (task completata, checkpoint non più necessario)
+2. Aggiorna `STATE.json`: avanza `current_task`, aggiorna `last_session`, aggiungi a `completed_tasks`
+3. Determina la task successiva (quella dopo la corrente in `workflow-v5.json`, o in `docs/ROADMAP.json` se `roadmap_generated == true`).
+   Leggi `task.session_hint` e scrivi il messaggio corrispondente:
+
+   **Se `session_hint == "continue"`:**
+   > "Task **[id] — [titolo]** completata ✓
+   > Continuo con **[next_id] — [next_titolo]**? (sì/no)"
+   - Se sì → esegui `/start` (rileggi STATE.json e avvia la task successiva)
+   - Se no → fermati
+
+   **Se `session_hint == "compact"`:**
+   > "Task **[id] — [titolo]** completata ✓
+   >
+   > Prossima: **[next_id] — [next_titolo]**
+   >
+   > Incolla questo comando per continuare:
+   > ```
+   > /compact task [id] completata. Prossima: [next_id] — [next_titolo].
+   > ```"
+
+   **Se `session_hint == "new_session"`:**
+   > "Task **[id] — [titolo]** completata ✓
+   >
+   > La prossima task (**[next_id] — [next_titolo]**) è impegnativa — consiglio una sessione fresca.
+   >
+   > Chiudi questa chat e apri una nuova sessione, poi scrivi: **`/start`**"
+
+4. **FERMATI.** Non procedere. Non chiedere altro.
+
+### 6-GATE. Salva gate e aggiorna context_snapshot (solo se `is_gate: true`)
+
+**Pre-validazione STATE.json** — prima di scrivere il file, verifica mentalmente che il JSON prodotto rispetti `system/schemas/state.schema.json`:
+- `workflow.current_task` deve rispettare il pattern `N.N` (es. `"1.2"`)
+- `workflow.status` deve essere esattamente uno tra: `"not_started"`, `"in_progress"`, `"completed"`
+- `context_snapshot.phase_N` deve essere compilato con il template typed della fase corrispondente (vedi tabella sotto) — non testo libero
+- Tutti i campi `required` del template di fase devono essere presenti; usare `null` solo per il valore delle fasi non ancora raggiunte
+- Se un campo è ambiguo, usa il valore di default definito nello schema, non inventarne uno
+
+1. Salva l'output del gate in `docs/phases/<phase_id>/<task_id>-gate.md`
+2. Aggiorna `STATE.json.context_snapshot.phase_N` con il template strutturato corrispondente alla fase (vedi tabella sotto). Compila ogni campo in modo conciso — il totale dello snapshot di fase deve stare in meno di 200 token.
+3. Aggiorna `STATE.json`: aggiorna `last_session`, aggiungi a `completed_tasks`
+
+**Se questo è gate 0.4 (fine fase 0):**
+NON avanzare ancora `current_task` a `1.1`. Invece, esegui subito la procedura di generazione roadmap descritta in `.claude/skills/roadmap/SKILL.md` (passi 1→7). Solo dopo che l'utente ha approvato la roadmap (SÌ esplicito), avanza `current_task` a `"1.1"` e fermati.
+
+**Tutti gli altri gate:**
+4. Avanza `current_task` alla task successiva in `STATE.json`
+5. Determina la task successiva (quella dopo il gate corrente). Leggi il suo `session_hint` e scrivi il messaggio corrispondente:
+
+   **Se `session_hint == "continue"`:**
+   > "Gate **[id]** completato ✓
+   > Continuo con **[next_id] — [next_titolo]**? (sì/no)"
+   - Se sì → esegui `/start`
+   - Se no → fermati
+
+   **Se `session_hint == "compact"`:**
+   > "Gate **[id]** completato ✓
+   >
+   > Prossima: **[next_id] — [next_titolo]**
+   >
+   > Incolla questo comando per continuare:
+   > ```
+   > /compact gate [id] completato. Prossima: [next_id] — [next_titolo].
+   > ```"
+
+   **Se `session_hint == "new_session"`:**
+   > "Gate **[id]** completato ✓
+   >
+   > La prossima task (**[next_id] — [next_titolo]**) è impegnativa — consiglio una sessione fresca.
+   >
+   > Chiudi questa chat e apri una nuova sessione, poi scrivi: **`/start`**"
+
+6. **FERMATI.**
+
+#### Template context_snapshot per fase
+
+**Gate 0.4 → `context_snapshot.phase_0`**
+```json
+{
+  "idea": "<elevator pitch in 1 frase>",
+  "target": "<utente primario>",
+  "differenziante": "<1 frase>",
+  "verdict": "GO",
+  "vincoli": ["<vincolo 1>", "<vincolo 2>"]
+}
+```
+
+**Gate 1.6 → `context_snapshot.phase_1`**
+```json
+{
+  "scope_mvp": ["<feature 1>", "<feature 2>"],
+  "stack": "<frontend> + <backend> + <db>",
+  "costi_mensili_stimati": "<€ N>",
+  "rischi_principali": ["<rischio 1>", "<rischio 2>"],
+  "verdict": "GO"
+}
+```
+
+**Gate 2.3 → `context_snapshot.phase_2`**
+```json
+{
+  "milestone": [
+    { "nome": "<nome>", "data": "<YYYY-MM-DD>", "output": "<deliverable>" }
+  ],
+  "dipendenze_critiche": ["<dipendenza 1>"]
+}
+```
+
+**Gate 3.3 → `context_snapshot.phase_3`**
+```json
+{
+  "ui_approach": "<descrizione in 1 frase>",
+  "design_system": "<nome o 'custom'>",
+  "schermate_principali": ["<schermata 1>", "<schermata 2>"]
+}
+```
+
+**Gate 4.4 → `context_snapshot.phase_4`**
+```json
+{
+  "db_entita_principali": ["<entità 1>", "<entità 2>"],
+  "api_count": "<N endpoint>",
+  "blueprint_versione": "<1.0>",
+  "pattern_architetturale": "<es. monolite modulare>"
+}
+```
+
+**Gate 5.4 → `context_snapshot.phase_5`**
+```json
+{
+  "feature_completate": ["<feature 1>", "<feature 2>"],
+  "feature_mancanti": ["<feature 3>"],
+  "debito_tecnico": ["<item 1>"]
+}
+```
+
+**Gate 6.4 → `context_snapshot.phase_6`**
+```json
+{
+  "test_coverage": "<N% oppure 'manuale'>",
+  "bug_critici_aperti": 0,
+  "pronto_per_deploy": true
+}
+```
+
+**Gate 7.5 → `context_snapshot.phase_7`**
+```json
+{
+  "url_produzione": "<https://...>",
+  "data_lancio": "<YYYY-MM-DD>",
+  "canali_lancio": ["<canale 1>"]
+}
+```
+
+**Gate 8.4 → `context_snapshot.phase_8`**
+```json
+{
+  "kpi_principali": { "<metrica>": "<valore>" },
+  "decisione_strategica": "crescita | pivot | sunset",
+  "lessons_learned": ["<insight 1>"]
+}
+```

package/template/CLAUDE.md

@@ -0,0 +1,70 @@
+# Project Workflow System — Claude Context
+
+## Regola fondamentale: UNA TASK PER VOLTA
+
+Completa e valida una task prima di passare alla successiva. Usa `/compact` tra una task e l'altra per liberare il context window — la sessione può contenere più task consecutive.
+
+## Mappa dei file — chi fa cosa
+
+| File | Chi lo crea | Chi lo aggiorna | A cosa serve |
+|---|---|---|---|
+| `CLAUDE.md` | `npm run init` | Sviluppatore (raramente) | Istruzioni per Claude — auto-iniettato |
+| `system/preferences.json` | `npm run init` | Claude (`/setup`) o utente | Preferenze progetto: stack, account, deploy — compilato progressivamente |
+| `system/workflow-v5.json` | `npm run init` | Mai | Template 38 task con domande e criteri |
+| `system/schemas/state.schema.json` | `npm run init` | Mai | JSON Schema per STATE.json — riferimento per validazione pre-salvataggio |
+| `system/schemas/workflow.schema.json` | `npm run init` | Mai | JSON Schema per workflow-v5.json — enum modelli, skill validi, pattern ID |
+| `project.json` | `npm run init` | Claude (raramente) | Anagrafica progetto |
+| `STATE.json` | `npm run init` | Claude (dopo ogni task) | Stato corrente — file più importante |
+| `docs/ROADMAP.json` | Claude (`/roadmap`) | Claude (`/roadmap --update`) | Task selezionate per questo progetto |
+| `docs/ROADMAP.md` | Claude (`/roadmap`) | Claude (`/roadmap --update`) | Versione leggibile della roadmap custom |
+| `docs/phases/<X>/<Y>-output.md` | Claude (ogni task) | Mai dopo validazione | Output validato = documentazione vivente |
+| `.claude/skills/*/SKILL.md` | `npm run init` | Mai | Skill specializzati — 4 user-facing, 9 interni (invocati dall'orchestratore) |
+| `.claude/agents/task-agent.md` | `npm run init` | Mai | Sub-agent esecutore isolato — invocato da `/task` per ogni task non-gate |
+| `docs/BLUEPRINT.xml` | Claude (task 4.3) | Claude (fase 5+) | Sorgente di verità tecnica |
+
+## Come lavorare
+
+Ogni sessione si avvia con:
+```
+/start
+```
+
+`/start` legge `STATE.json` e avvia automaticamente la task giusta — non devi ricordare quale. Al termine di ogni task, Claude fornisce un comando `/compact` precompilato da incollare: dopo la compattazione la sessione riprende automaticamente sulla task successiva.
+
+Lo skill `/task` gestisce l'intero ciclo: caricamento contesto → interrogazione → lancio sub-agent `task-agent` → loop checkpoint → validazione → salvataggio.
+
+Il sub-agent `task-agent` esegue il lavoro in isolamento (proprio context window): skill, web search, MCP. Restituisce un checkpoint JSON. Se blocca su informazioni mancanti (`stato: "partial"`), l'orchestratore chiede all'utente e rilancia. Il checkpoint è persistito in `STATE.json` — le task sono riprendibili cross-sessione.
+
+## Skill disponibili
+
+| Skill | Quando viene usato |
+|---|---|
+| `/task` | Orchestratore — invocato dall'utente per ogni task |
+| `/setup` | Compila `preferences.json` interattivamente (per sezione o tutto) |
+| `/roadmap` | Genera la roadmap custom dopo gate 0.4 (usa `--update` per rigenerare) |
+| `/ricerca` | Ricerca web strutturata (competitor, prezzi servizi) |
+| `/analisi` | Analisi strutturata (GO/NO-GO, rischi, KPI, strategia) |
+| `/legale` | Documenti legali (privacy policy, T&C, checklist GDPR) |
+| `/design` | Flussi utente, wireframe, design system (+ Figma MCP) |
+| `/architettura` | Schema DB, API, architettura (+ Postman MCP) |
+| `/blueprint` | Genera/aggiorna BLUEPRINT.xml |
+| `/qa` | Test plan, security checklist, bug triage |
+| `/deploy` | Checklist deploy, env vars, smoke test, monitoraggio |
+| `/pianificazione` | Milestone, dipendenze, backlog (+ ClickUp MCP) |
+
+Gli skill specializzati vengono invocati automaticamente dall'orchestratore `/task` quando la task corrente ha un campo `skill` valorizzato. L'utente viene informato prima dell'esecuzione.
+
+## Comandi rapidi
+
+- **`/start`** → avvia la sessione — rileva automaticamente la task corrente da `STATE.json`
+- **`/task X.Y`** → avvia una task specifica (utile per rieseguire o saltare)
+- **`/setup`** → compila preferenze progetto interattivamente (o `/setup stack`, `/setup identity`…)
+- **`/setup --import <percorso>`** → importa preferenze da un altro progetto
+- **`/roadmap`** → genera roadmap custom (dopo gate 0.4)
+- **`/roadmap --update`** → rigenera la roadmap se il profilo progetto è cambiato
+- **"Mostra stato"** → leggi e mostra `STATE.json`
+- **"Gate N"** → esegui il gate di chiusura fase N
+
+## Informazioni personali
+
+Vedi `system/preferences.json` per: stack tecnologico, P.IVA, account e ambienti di deploy. Usale come default; il progetto può sovrascriverle in `project.json` → `overrides`.

package/template/README.md

@@ -0,0 +1,59 @@
+# [Nome Progetto]
+
+Progetto gestito con [Project Workflow System](https://github.com/fturci/project-workflow-template).
+
+---
+
+## Avvio rapido
+
+Apri questa cartella in Claude Code, poi scrivi:
+
+```
+/start                   ← avvia o riprendi dalla task corrente (unico comando da ricordare)
+/task X.Y                ← avvia una task specifica (per rieseguire o saltare)
+/setup                   ← compila preferences.json interattivamente
+/roadmap                 ← genera roadmap custom (dopo gate 0.4)
+```
+
+Ogni sessione = una task. Claude interroga, genera, chiede approvazione, salva e si ferma.
+Tra una task e l'altra Claude fornisce il comando da incollare (`/compact` o `/start`).
+
+---
+
+## Struttura
+
+```
+<nome-progetto>/
+├── CLAUDE.md                  ← istruzioni per Claude (non modificare)
+├── README.md                  ← questo file
+├── project.json               ← anagrafica: nome, link, override stack
+├── STATE.json                 ← stato corrente (punto di partenza di ogni sessione)
+├── system/
+│   ├── preferences.json       ← stack, account, deploy (non committare)
+│   └── workflow-v5.json       ← template 38 task — non modificare
+└── docs/
+    ├── BLUEPRINT.xml          ← sorgente tecnica (generato in fase 4)
+    ├── ROADMAP.json           ← task selezionate (generato da /roadmap)
+    ├── ROADMAP.md             ← versione leggibile della roadmap custom
+    └── phases/
+        └── <N>/
+            └── <task_id>-output.md  ← output validato di ogni task
+```
+
+---
+
+## Le 9 fasi
+
+| Fase | Nome | Output principale |
+|---|---|---|
+| 0 | Ideazione e Validazione | Scheda idea + analisi competitor + GO/NO-GO |
+| 1 | Definizione e Fattibilità | Scope MVP + stack + costi + rischi |
+| 2 | Pianificazione | Milestone + dipendenze + piano lavoro |
+| 3 | Design | Flussi utente + wireframe + mockup |
+| 4 | Architettura | Schema DB + API + Blueprint XML |
+| 5 | Implementazione MVP | Feature by feature |
+| 6 | QA e Testing | Test + bug fix + beta |
+| 7 | Release e Lancio | Deploy + landing + privacy + lancio |
+| 8 | Operazioni e Crescita | KPI + feedback + backlog + strategia |
+
+Ogni fase termina con un **gate** — checklist prima di procedere alla fase successiva.

package/template/STATE.json

@@ -0,0 +1,44 @@
+{
+  "_comment": "Stato corrente del progetto. Aggiornato dopo ogni task validata. File principale per il context loading.",
+  "_version": "1.1",
+
+  "project_id": "",
+  "project_name": "",
+
+  "workflow": {
+    "current_phase": 0,
+    "current_task": "0.1",
+    "phase_name": "Ideazione e Validazione",
+    "task_title": "Documentare e strutturare l'idea",
+    "status": "not_started",
+    "last_updated": ""
+  },
+
+  "last_session": {
+    "date": "",
+    "task_worked": "",
+    "outcome": "",
+    "next_action": ""
+  },
+
+  "decisions": [],
+
+  "roadmap_generated": false,
+
+  "completed_tasks": [],
+
+  "checkpoint": null,
+
+  "context_snapshot": {
+    "_comment": "Riassunto ultra-compatto delle decisioni chiave. Max 300 token. Aggiornato ai gate di fase.",
+    "phase_0": null,
+    "phase_1": null,
+    "phase_2": null,
+    "phase_3": null,
+    "phase_4": null,
+    "phase_5": null,
+    "phase_6": null,
+    "phase_7": null,
+    "phase_8": null
+  }
+}

package/template/project.json

@@ -0,0 +1,39 @@
+{
+  "_comment": "Template per ogni nuovo progetto. Copiare in projects/<nome-progetto>/project.json e compilare.",
+  "_version": "1.0",
+
+  "id": "",
+  "name": "",
+  "slug": "",
+  "created_at": "",
+  "status": "active",
+
+  "overview": {
+    "elevator_pitch": "",
+    "problem": "",
+    "solution": "",
+    "target_user": "",
+    "platform": "",
+    "business_model": ""
+  },
+
+  "links": {
+    "github_repo": "",
+    "figma": "",
+    "google_drive": "",
+    "notion_page": "",
+    "staging_url": "",
+    "production_url": "",
+    "landing_page": ""
+  },
+
+  "overrides": {
+    "_comment": "Sovrascrive system/preferences.json solo per questo progetto. Lasciare null per usare il default.",
+    "stack": null,
+    "deploy": null
+  },
+
+  "tools_enabled": [],
+
+  "notes": ""
+}

package/template/system/preferences.json

@@ -0,0 +1,92 @@
+{
+  "_comment": "Preferenze del progetto. Compilato progressivamente con /setup. Non committare se contiene dati sensibili.",
+  "_version": "1.0",
+  "_setup_instructions": "Lascia vuoti i campi che non conosci ancora — Claude te li chiederà quando necessari.",
+
+  "identity": {
+    "name": "",
+    "role": "",
+    "piva": "",
+    "email": "",
+    "website": ""
+  },
+
+  "stack": {
+    "_comment": "Stack tecnologico del progetto. Sovrascrive system/preferences.json per questo progetto.",
+    "frontend": {
+      "framework": "",
+      "language": "",
+      "ui_library": "",
+      "state": "",
+      "forms": "",
+      "animations": ""
+    },
+    "backend": {
+      "approach": "",
+      "orm": "",
+      "validation": ""
+    },
+    "database": {
+      "primary": "",
+      "local_dev": "",
+      "auth": ""
+    },
+    "payments": "",
+    "email": "",
+    "analytics": "",
+    "error_tracking": "",
+    "storage": "",
+    "search": ""
+  },
+
+  "deploy": {
+    "frontend": "",
+    "database": "",
+    "domain_registrar": "",
+    "vercel_org": "",
+    "supabase_org": "",
+    "github_org_or_user": ""
+  },
+
+  "accounts": {
+    "_comment": "Riferimenti agli account usati. NON inserire password o token qui.",
+    "github": "",
+    "vercel": "",
+    "supabase": "",
+    "stripe": "",
+    "resend": "",
+    "posthog": "",
+    "sentry": "",
+    "figma": "",
+    "notion": "",
+    "clickup": ""
+  },
+
+  "conventions": {
+    "repo_naming": "kebab-case",
+    "branch_main": "main",
+    "commit_style": "conventional commits (feat/fix/chore/docs)",
+    "pr_strategy": "squash merge",
+    "env_files": ".env.local (dev), variabili Vercel (prod)",
+    "folder_structure": "src/app (routes), src/components, src/lib, src/hooks, src/types",
+    "component_naming": "PascalCase",
+    "file_naming": "kebab-case",
+    "function_naming": "camelCase"
+  },
+
+  "ai_preferences": {
+    "default_model_interrogation": "claude-haiku-4-5-20251001",
+    "default_model_output": "claude-sonnet-4-6",
+    "default_model_architecture": "claude-opus-4-6",
+    "language": "italiano",
+    "code_language": "inglese",
+    "max_context_tokens_per_session": 1500
+  },
+
+  "legal": {
+    "privacy_policy_template": "",
+    "cookie_consent": "",
+    "tos_needed_by_default": false,
+    "gdpr_applicable": true
+  }
+}