diff --git a/docs/plans/2026-08-21-longevity-strato-dati.md b/docs/plans/2026-08-21-longevity-strato-dati.md
new file mode 100644
index 0000000..07e3c18
--- /dev/null
+++ b/docs/plans/2026-08-21-longevity-strato-dati.md
@@ -0,0 +1,1294 @@
+# Longevity — strato dati: piano di implementazione
+
+> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
+
+**Goal:** costruire lo strato dati del fascicolo cliente — i due database, il registro dei test, la registrazione delle misure, l'anagrafica pseudonimizzata e il salvataggio del questionario — testato e senza interfaccia.
+
+**Architecture:** due file SQLite affiancati a quello del sito. `identity.db` tiene il legame fra codice cliente e persona; `longevity.db` tiene misure, questionari e punteggi e non contiene mai un nome. Le misure sono un registro (una riga per valore, da qualunque sorgente) validato contro una tabella di test che è dato e non codice. Un solo modulo apre entrambe le connessioni.
+
+**Tech Stack:** TypeScript, better-sqlite3, vitest. Nessuna dipendenza nuova.
+
+**Spec:** `docs/specs/2026-08-21-longevity-design.md`
+
+## Global Constraints
+
+- Branch **`feat/longevity`**. `main` non si tocca, non si deploya, non si pusha senza che Adriano lo chieda.
+- Nessuna dipendenza npm nuova: better-sqlite3 e vitest ci sono già.
+- Si segue il pattern di `src/lib/db.ts`: funzione `createXDb(path?)`, `journal_mode = WAL`, `foreign_keys = ON`, schema idempotente eseguito all'apertura.
+- Test in `tests/longevity/`, eseguiti con `npm test` (vitest). I test usano `':memory:'`.
+- **Un solo modulo** (`src/lib/longevity/anagrafica.ts`) può importare insieme le due connessioni. Un test lo verifica.
+- **Nessun dato reale di persone nelle fixture.** I casi di prova sono sintetici.
+- Soglia di copertura: **0.40**, dichiarata come costante esportata, mai scritta a mano nei rami.
+- `model_version` iniziale: **`v1.0`**. `quest_version` iniziale: **`v1.0`** (è quella che Nicola ha già messo nel prototipo).
+
+## Perimetro di questo piano
+
+Questo piano costruisce **lo strato dati e basta**: alla fine esiste una libreria testata che sa registrare un cliente, registrare misure da qualunque sorgente, salvare una compilazione di questionario ed esportare i dati pseudonimizzati.
+
+**Fuori da questo piano**, e ognuno avrà il suo: il motore di calcolo degli score (porting delle curve dal Python, con verificatore), le pagine web del questionario e della dashboard, gli import da Wellness Tower/VALD/Calibre.
+
+Il motivo dell'ordine è che tutto il resto legge o scrive questi dati: costruirlo per primo evita che tre pezzi inventino tre modelli diversi.
+
+## Struttura dei file
+
+| File | Responsabilità |
+|---|---|
+| `src/lib/longevity/db.ts` | apertura e schema dei due database |
+| `src/lib/longevity/registro.ts` | registro dei test e tabella pesi: seed e query |
+| `src/lib/longevity/misure.ts` | `registraMisure`, l'unico varco di scrittura |
+| `src/lib/longevity/anagrafica.ts` | **l'unico** modulo che unisce identity e longevity |
+| `src/lib/longevity/questionario-def.ts` | i 20 campi punteggiati come dato |
+| `src/lib/longevity/questionario.ts` | salvataggio di una compilazione |
+| `src/lib/longevity/export.ts` | export pseudonimizzato |
+| `src/lib/auth.ts` | *(modifica)* ruoli `cliente` e `trainer` |
+
+---
+
+### Task 1: Schema dei due database
+
+**Files:**
+- Create: `src/lib/longevity/db.ts`
+- Test: `tests/longevity/db.test.ts`
+
+**Interfaces:**
+- Consumes: niente
+- Produces: `createLongevityDb(path?: string): Database.Database`, `createIdentityDb(path?: string): Database.Database`, `COPERTURA_MINIMA: number` (0.40)
+
+- [ ] **Step 1: Write the failing test**
+
+```ts
+// tests/longevity/db.test.ts
+import { describe, it, expect } from 'vitest';
+import { createLongevityDb, createIdentityDb, COPERTURA_MINIMA } from '../../src/lib/longevity/db';
+
+describe('schema longevity', () => {
+  it('crea le tabelle previste dalla spec', () => {
+    const db = createLongevityDb(':memory:');
+    const nomi = (db.prepare(`SELECT name FROM sqlite_master WHERE type='table'`).all() as { name: string }[])
+      .map((r) => r.name);
+    expect(nomi).toEqual(
+      expect.arrayContaining(['soggetti', 'sessioni', 'misure', 'registro_test', 'pesi', 'profilo_note', 'score'])
+    );
+  });
+
+  it('rifiuta un sesso non previsto', () => {
+    const db = createLongevityDb(':memory:');
+    expect(() =>
+      db.prepare(`INSERT INTO soggetti (client_code, sesso) VALUES ('ISL-0001', 'X')`).run()
+    ).toThrow();
+  });
+
+  it('rifiuta una misura con test_id non nel registro', () => {
+    const db = createLongevityDb(':memory:');
+    db.prepare(`INSERT INTO soggetti (client_code, sesso) VALUES ('ISL-0001', 'F')`).run();
+    db.prepare(`INSERT INTO sessioni (client_code, data, tipo) VALUES ('ISL-0001', '2026-08-21', 'checkup')`).run();
+    expect(() =>
+      db.prepare(
+        `INSERT INTO misure (sessione_id, client_code, test_id, valore_num, fonte)
+         VALUES (1, 'ISL-0001', 'test_inventato', 10, 'manuale')`
+      ).run()
+    ).toThrow();
+  });
+
+  it('uno score insufficiente puo non avere valore', () => {
+    const db = createLongevityDb(':memory:');
+    db.prepare(`INSERT INTO soggetti (client_code, sesso) VALUES ('ISL-0001', 'F')`).run();
+    db.prepare(`INSERT INTO sessioni (client_code, data, tipo) VALUES ('ISL-0001', '2026-08-21', 'checkup')`).run();
+    db.prepare(
+      `INSERT INTO score (client_code, sessione_id, tipo, nome, valore, copertura, stato, model_version)
+       VALUES ('ISL-0001', 1, 'asse', 'Forza & Struttura', NULL, 0.2, 'insufficiente', 'v1.0')`
+    ).run();
+    const row = db.prepare(`SELECT valore, stato FROM score`).get() as { valore: number | null; stato: string };
+    expect(row.valore).toBeNull();
+    expect(row.stato).toBe('insufficiente');
+  });
+
+  it('identity tiene la persona, longevity non la conosce', () => {
+    const id = createIdentityDb(':memory:');
+    const cols = (id.prepare(`PRAGMA table_info(clienti)`).all() as { name: string }[]).map((c) => c.name);
+    expect(cols).toEqual(expect.arrayContaining(['client_code', 'user_id', 'nome', 'cognome', 'data_nascita']));
+
+    const lg = createLongevityDb(':memory:');
+    const tutte = (lg.prepare(`SELECT name FROM sqlite_master WHERE type='table'`).all() as { name: string }[])
+      .flatMap((t) => (lg.prepare(`PRAGMA table_info(${t.name})`).all() as { name: string }[]).map((c) => c.name));
+    expect(tutte).not.toContain('nome');
+    expect(tutte).not.toContain('cognome');
+    expect(tutte).not.toContain('data_nascita');
+  });
+
+  it('la soglia di copertura e 0.40', () => {
+    expect(COPERTURA_MINIMA).toBe(0.4);
+  });
+});
+```
+
+- [ ] **Step 2: Run test to verify it fails**
+
+Run: `npm test -- tests/longevity/db.test.ts`
+Expected: FAIL — "Cannot find module '../../src/lib/longevity/db'"
+
+- [ ] **Step 3: Write minimal implementation**
+
+```ts
+// src/lib/longevity/db.ts
+import Database from 'better-sqlite3';
+import { mkdirSync } from 'node:fs';
+import { dirname } from 'node:path';
+
+/** Sotto questa copertura di peso un elemento calcolato e' 'insufficiente' e non ha valore. */
+export const COPERTURA_MINIMA = 0.4;
+
+const SCHEMA_LONGEVITY = `
+CREATE TABLE IF NOT EXISTS soggetti (
+  client_code   TEXT PRIMARY KEY,
+  sesso         TEXT NOT NULL CHECK (sesso IN ('M','F')),
+  created_at    TEXT NOT NULL DEFAULT (datetime('now'))
+);
+CREATE TABLE IF NOT EXISTS registro_test (
+  test_id       TEXT PRIMARY KEY,
+  etichetta     TEXT NOT NULL,
+  unita         TEXT,
+  tipo_valore   TEXT NOT NULL CHECK (tipo_valore IN ('num','txt')),
+  curva         TEXT,
+  params        TEXT,
+  asse          TEXT,
+  sotto_dominio TEXT,
+  range_min     REAL,
+  range_max     REAL,
+  attivo_da     TEXT NOT NULL,
+  attivo_a      TEXT,
+  note          TEXT
+);
+CREATE TABLE IF NOT EXISTS sessioni (
+  id            INTEGER PRIMARY KEY AUTOINCREMENT,
+  client_code   TEXT NOT NULL REFERENCES soggetti(client_code),
+  data          TEXT NOT NULL,
+  tipo          TEXT NOT NULL CHECK (tipo IN ('checkup','questionario')),
+  eta_alla_data INTEGER,
+  operatore     TEXT,
+  note          TEXT,
+  quest_version TEXT,
+  created_at    TEXT NOT NULL DEFAULT (datetime('now'))
+);
+CREATE INDEX IF NOT EXISTS idx_sessioni_cliente ON sessioni (client_code, data DESC);
+CREATE TABLE IF NOT EXISTS misure (
+  id            INTEGER PRIMARY KEY AUTOINCREMENT,
+  sessione_id   INTEGER NOT NULL REFERENCES sessioni(id) ON DELETE CASCADE,
+  client_code   TEXT NOT NULL REFERENCES soggetti(client_code),
+  test_id       TEXT NOT NULL REFERENCES registro_test(test_id),
+  valore_num    REAL,
+  valore_txt    TEXT,
+  unita         TEXT,
+  fonte         TEXT NOT NULL CHECK (fonte IN
+                  ('manuale','questionario','wellness_tower','vald','calibre','stress_index')),
+  fuori_range   INTEGER NOT NULL DEFAULT 0,
+  created_at    TEXT NOT NULL DEFAULT (datetime('now'))
+);
+CREATE INDEX IF NOT EXISTS idx_misure_cliente_test ON misure (client_code, test_id);
+CREATE INDEX IF NOT EXISTS idx_misure_sessione ON misure (sessione_id);
+CREATE TABLE IF NOT EXISTS pesi (
+  model_version TEXT NOT NULL,
+  livello       TEXT NOT NULL CHECK (livello IN ('asse','macro','fitness_age')),
+  contenitore   TEXT NOT NULL,
+  elemento      TEXT NOT NULL,
+  peso          REAL NOT NULL,
+  PRIMARY KEY (model_version, livello, contenitore, elemento)
+);
+CREATE TABLE IF NOT EXISTS profilo_note (
+  id            INTEGER PRIMARY KEY AUTOINCREMENT,
+  client_code   TEXT NOT NULL REFERENCES soggetti(client_code),
+  sessione_id   INTEGER REFERENCES sessioni(id),
+  campo_id      TEXT NOT NULL,
+  testo         TEXT NOT NULL,
+  created_at    TEXT NOT NULL DEFAULT (datetime('now'))
+);
+CREATE TABLE IF NOT EXISTS score (
+  id            INTEGER PRIMARY KEY AUTOINCREMENT,
+  client_code   TEXT NOT NULL REFERENCES soggetti(client_code),
+  sessione_id   INTEGER NOT NULL REFERENCES sessioni(id),
+  tipo          TEXT NOT NULL CHECK (tipo IN ('asse','macro','fitness_age')),
+  nome          TEXT NOT NULL,
+  valore        REAL,
+  copertura     REAL NOT NULL,
+  stato         TEXT NOT NULL CHECK (stato IN ('ok','insufficiente')),
+  quest_version TEXT,
+  model_version TEXT NOT NULL,
+  calcolato_at  TEXT NOT NULL DEFAULT (datetime('now'))
+);
+CREATE INDEX IF NOT EXISTS idx_score_cliente ON score (client_code, calcolato_at DESC);
+`;
+
+const SCHEMA_IDENTITY = `
+CREATE TABLE IF NOT EXISTS clienti (
+  client_code   TEXT PRIMARY KEY,
+  user_id       INTEGER,
+  nome          TEXT NOT NULL,
+  cognome       TEXT NOT NULL,
+  data_nascita  TEXT,
+  email         TEXT,
+  telefono      TEXT,
+  created_at    TEXT NOT NULL DEFAULT (datetime('now'))
+);
+CREATE UNIQUE INDEX IF NOT EXISTS idx_clienti_user ON clienti (user_id);
+`;
+
+function apri(p: string, schema: string): Database.Database {
+  if (p !== ':memory:') mkdirSync(dirname(p), { recursive: true });
+  const db = new Database(p);
+  db.pragma('journal_mode = WAL');
+  db.pragma('foreign_keys = ON');
+  db.exec(schema);
+  return db;
+}
+
+export function createLongevityDb(path?: string): Database.Database {
+  return apri(path ?? process.env.LONGEVITY_DB_PATH ?? 'data/longevity.db', SCHEMA_LONGEVITY);
+}
+
+export function createIdentityDb(path?: string): Database.Database {
+  return apri(path ?? process.env.IDENTITY_DB_PATH ?? 'data/identity.db', SCHEMA_IDENTITY);
+}
+```
+
+- [ ] **Step 4: Run test to verify it passes**
+
+Run: `npm test -- tests/longevity/db.test.ts`
+Expected: PASS, 6 test
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add src/lib/longevity/db.ts tests/longevity/db.test.ts
+git commit -m "longevity: schema dei due database, identity separato da longevity"
+```
+
+---
+
+### Task 2: Registro dei test e pesi — seed e query
+
+**Files:**
+- Create: `src/lib/longevity/registro.ts`
+- Test: `tests/longevity/registro.test.ts`
+
+**Interfaces:**
+- Consumes: `createLongevityDb` da Task 1
+- Produces:
+  - `type Curva = 'bell' | 'lin_dec' | 'inc_plateau' | 'x10' | 'x10_inv' | 'decstep' | 'incstep'`
+  - `type VoceRegistro = { test_id: string; etichetta: string; unita?: string; tipo_valore: 'num'|'txt'; curva?: Curva; params?: unknown; asse?: string; sotto_dominio?: string; range_min?: number; range_max?: number; attivo_da: string; attivo_a?: string }`
+  - `seedRegistro(db: Database.Database): void`
+  - `seedPesi(db: Database.Database, modelVersion: string): void`
+  - `testAttivi(db: Database.Database, alla: string): VoceRegistro[]`
+  - `esisteTest(db: Database.Database, testId: string): boolean`
+
+- [ ] **Step 1: Write the failing test**
+
+```ts
+// tests/longevity/registro.test.ts
+import { describe, it, expect } from 'vitest';
+import { createLongevityDb } from '../../src/lib/longevity/db';
+import { seedRegistro, seedPesi, testAttivi, esisteTest } from '../../src/lib/longevity/registro';
+
+describe('registro dei test', () => {
+  it('carica i 20 campi punteggiati del questionario', () => {
+    const db = createLongevityDb(':memory:');
+    seedRegistro(db);
+    const q = db.prepare(`SELECT COUNT(*) n FROM registro_test WHERE test_id LIKE 'q_%'`).get() as { n: number };
+    expect(q.n).toBe(20);
+  });
+
+  it('alcol_life porta la soglia 7-14 voluta da Nicola', () => {
+    const db = createLongevityDb(':memory:');
+    seedRegistro(db);
+    const row = db.prepare(`SELECT curva, params FROM registro_test WHERE test_id = 'q_alcol_life'`)
+      .get() as { curva: string; params: string };
+    expect(row.curva).toBe('lin_dec');
+    expect(JSON.parse(row.params)).toEqual({ best: 7, worst: 14 });
+  });
+
+  it('calo_pomeridiano usa la curva invertita, la quinta che al Python manca', () => {
+    const db = createLongevityDb(':memory:');
+    seedRegistro(db);
+    const row = db.prepare(`SELECT curva FROM registro_test WHERE test_id = 'q_calo_pomeridiano'`)
+      .get() as { curva: string };
+    expect(row.curva).toBe('x10_inv');
+  });
+
+  it('un test disattivato non e piu attivo dopo la sua data', () => {
+    const db = createLongevityDb(':memory:');
+    seedRegistro(db);
+    db.prepare(`UPDATE registro_test SET attivo_a = '2026-08-01' WHERE test_id = 'q_sigarette'`).run();
+    const attivi = testAttivi(db, '2026-08-21').map((t) => t.test_id);
+    expect(attivi).not.toContain('q_sigarette');
+    expect(testAttivi(db, '2026-07-01').map((t) => t.test_id)).toContain('q_sigarette');
+  });
+
+  it('esisteTest distingue un test vero da uno inventato', () => {
+    const db = createLongevityDb(':memory:');
+    seedRegistro(db);
+    expect(esisteTest(db, 'q_ore_sonno')).toBe(true);
+    expect(esisteTest(db, 'q_inventato')).toBe(false);
+  });
+
+  it('i pesi di ogni asse sommano a 1', () => {
+    const db = createLongevityDb(':memory:');
+    seedPesi(db, 'v1.0');
+    const righe = db.prepare(
+      `SELECT contenitore, ROUND(SUM(peso), 6) tot FROM pesi
+       WHERE model_version = 'v1.0' AND livello = 'asse' GROUP BY contenitore`
+    ).all() as { contenitore: string; tot: number }[];
+    expect(righe.length).toBe(7);
+    for (const r of righe) expect(r.tot).toBe(1);
+  });
+
+  it('i pesi sono legati alla versione del modello', () => {
+    const db = createLongevityDb(':memory:');
+    seedPesi(db, 'v1.0');
+    seedPesi(db, 'v2.0');
+    const n = db.prepare(`SELECT COUNT(DISTINCT model_version) n FROM pesi`).get() as { n: number };
+    expect(n.n).toBe(2);
+  });
+
+  it('il plank pesa su due assi: va visto, non nascosto', () => {
+    const db = createLongevityDb(':memory:');
+    seedPesi(db, 'v1.0');
+    const righe = db.prepare(
+      `SELECT contenitore FROM pesi WHERE model_version='v1.0' AND livello='asse' AND elemento IN ('core','plank')`
+    ).all() as { contenitore: string }[];
+    expect(righe.map((r) => r.contenitore).sort())
+      .toEqual(['Forza & Struttura', 'Stabilità & Mobilità Funzionale']);
+  });
+});
+```
+
+- [ ] **Step 2: Run test to verify it fails**
+
+Run: `npm test -- tests/longevity/registro.test.ts`
+Expected: FAIL — modulo `registro` non trovato
+
+- [ ] **Step 3: Write minimal implementation**
+
+```ts
+// src/lib/longevity/registro.ts
+import type Database from 'better-sqlite3';
+
+export type Curva = 'bell' | 'lin_dec' | 'inc_plateau' | 'x10' | 'x10_inv' | 'decstep' | 'incstep';
+
+export type VoceRegistro = {
+  test_id: string;
+  etichetta: string;
+  unita?: string;
+  tipo_valore: 'num' | 'txt';
+  curva?: Curva;
+  params?: unknown;
+  asse?: string;
+  sotto_dominio?: string;
+  range_min?: number;
+  range_max?: number;
+  attivo_da: string;
+  attivo_a?: string;
+};
+
+const DA = '2026-01-01';
+
+// I 20 campi punteggiati, presi dal prototipo del cliente (questionario_longevity_score.html).
+// Gli id portano il prefisso q_ per distinguerli dai test fisici; i params sono nella forma
+// dichiarata per ciascuna curva, non nell'array posizionale del prototipo.
+const QUESTIONARIO: VoceRegistro[] = [
+  { test_id: 'q_ore_sonno', etichetta: 'Ore di sonno per notte (media)', unita: 'h', tipo_valore: 'num',
+    curva: 'bell', params: { low: 4, peakLow: 7, peakHigh: 9, high: 12 },
+    asse: 'Recupero & Sistema Nervoso', sotto_dominio: 'questionario_sonno', range_min: 0, range_max: 14, attivo_da: DA },
+  { test_id: 'q_min_addorm', etichetta: 'Minuti per addormentarti', unita: 'min', tipo_valore: 'num',
+    curva: 'decstep', params: { steps: [[15, 100], [30, 75], [60, 50], [999, 25]] },
+    asse: 'Recupero & Sistema Nervoso', sotto_dominio: 'questionario_sonno', range_min: 0, range_max: 180, attivo_da: DA },
+  { test_id: 'q_risvegli', etichetta: 'Risvegli notturni (numero)', tipo_valore: 'num',
+    curva: 'decstep', params: { steps: [[0, 100], [1, 80], [2, 50], [999, 25]] },
+    asse: 'Recupero & Sistema Nervoso', sotto_dominio: 'questionario_sonno', range_min: 0, range_max: 10, attivo_da: DA },
+  { test_id: 'q_riposato', etichetta: 'Quanto ti senti riposato al risveglio', tipo_valore: 'num',
+    curva: 'x10', params: {}, asse: 'Recupero & Sistema Nervoso', sotto_dominio: 'questionario_sonno',
+    range_min: 0, range_max: 10, attivo_da: DA },
+  { test_id: 'q_caffeina', etichetta: 'Caffeina dopo le 16:00 (volte/settimana)', tipo_valore: 'num',
+    curva: 'lin_dec', params: { best: 0, worst: 7 },
+    asse: 'Recupero & Sistema Nervoso', sotto_dominio: 'questionario_sonno', range_min: 0, range_max: 14, attivo_da: DA },
+  { test_id: 'q_sonnolenza_diurna', etichetta: 'Sonnolenza/fatica a concentrarti durante il giorno (volte/settimana)',
+    tipo_valore: 'num', curva: 'lin_dec', params: { best: 0, worst: 7 },
+    asse: 'Recupero & Sistema Nervoso', sotto_dominio: 'questionario_sonno', range_min: 0, range_max: 14, attivo_da: DA },
+
+  { test_id: 'q_energia_media', etichetta: 'Energia media nella giornata, ultima settimana', tipo_valore: 'num',
+    curva: 'x10', params: {}, asse: 'Energia & Regolazione Stress', sotto_dominio: 'questionario_energia_stress',
+    range_min: 0, range_max: 10, attivo_da: DA },
+  { test_id: 'q_esaurimento', etichetta: 'Episodi di esaurimento senza motivo fisico (volte/sett.)', tipo_valore: 'num',
+    curva: 'lin_dec', params: { best: 0, worst: 7 },
+    asse: 'Energia & Regolazione Stress', sotto_dominio: 'questionario_energia_stress', range_min: 0, range_max: 14, attivo_da: DA },
+  { test_id: 'q_calo_pomeridiano', etichetta: 'Quanto forte e il calo di energia dal mattino al pomeriggio',
+    tipo_valore: 'num', curva: 'x10_inv', params: {},
+    asse: 'Energia & Regolazione Stress', sotto_dominio: 'questionario_energia_stress', range_min: 0, range_max: 10, attivo_da: DA },
+
+  { test_id: 'q_sopraffatto', etichetta: 'Sopraffatto da imprevisti (volte/mese)', tipo_valore: 'num',
+    curva: 'decstep', params: { steps: [[2, 100], [5, 70], [10, 40], [999, 20]] },
+    asse: 'Energia & Regolazione Stress', sotto_dominio: 'questionario_energia_stress', range_min: 0, range_max: 30, attivo_da: DA },
+  { test_id: 'q_controllo', etichetta: 'Percezione di controllo sulla tua vita', tipo_valore: 'num',
+    curva: 'x10', params: {}, asse: 'Energia & Regolazione Stress', sotto_dominio: 'questionario_energia_stress',
+    range_min: 0, range_max: 10, attivo_da: DA },
+  { test_id: 'q_sicurezza_gestione', etichetta: 'Ti senti sicuro/a nella tua capacita di gestire i problemi personali',
+    tipo_valore: 'num', curva: 'x10', params: {},
+    asse: 'Energia & Regolazione Stress', sotto_dominio: 'questionario_energia_stress', range_min: 0, range_max: 10, attivo_da: DA },
+  { test_id: 'q_tensione', etichetta: 'Tensione/irritabilita (volte/settimana)', tipo_valore: 'num',
+    curva: 'lin_dec', params: { best: 0, worst: 7 },
+    asse: 'Energia & Regolazione Stress', sotto_dominio: 'questionario_energia_stress', range_min: 0, range_max: 14, attivo_da: DA },
+  { test_id: 'q_pensieri_lavoro', etichetta: 'Ore/giorno di pensieri di lavoro fuori orario', unita: 'h',
+    tipo_valore: 'num', curva: 'lin_dec', params: { best: 0, worst: 4 },
+    asse: 'Energia & Regolazione Stress', sotto_dominio: 'questionario_energia_stress', range_min: 0, range_max: 8, attivo_da: DA },
+
+  { test_id: 'q_attivita', etichetta: 'Giorni/settimana attivita fisica extra ISL', tipo_valore: 'num',
+    curva: 'incstep', params: { steps: [[0, 20], [2, 50], [4, 80], [999, 100]] },
+    asse: 'Stile di Vita & Sonno', sotto_dominio: 'questionario_lifestyle', range_min: 0, range_max: 7, attivo_da: DA },
+  { test_id: 'q_alimentazione', etichetta: 'Qualita percepita alimentazione abituale', tipo_valore: 'num',
+    curva: 'x10', params: {}, asse: 'Stile di Vita & Sonno', sotto_dominio: 'questionario_lifestyle',
+    range_min: 0, range_max: 10, attivo_da: DA },
+  { test_id: 'q_sigarette', etichetta: 'Sigarette al giorno', tipo_valore: 'num',
+    curva: 'decstep', params: { steps: [[0, 100], [5, 60], [10, 40], [20, 20], [999, 0]] },
+    asse: 'Stile di Vita & Sonno', sotto_dominio: 'questionario_lifestyle', range_min: 0, range_max: 40, attivo_da: DA },
+  // Soglia 0-7 = punteggio pieno: scelta deliberata del cliente (basso rischio NIAAA/WHO),
+  // confermata il 21/08. Non e' un refuso per 0=100 -> 7=0.
+  { test_id: 'q_alcol_life', etichetta: 'Unita alcoliche/settimana', tipo_valore: 'num',
+    curva: 'lin_dec', params: { best: 7, worst: 14 },
+    asse: 'Stile di Vita & Sonno', sotto_dominio: 'questionario_lifestyle', range_min: 0, range_max: 30, attivo_da: DA },
+  { test_id: 'q_luce', etichetta: 'Ore/giorno luce naturale/esterno', unita: 'h', tipo_valore: 'num',
+    curva: 'incstep', params: { steps: [[0.5, 60], [1, 90], [999, 100]], zeroVal: 20 },
+    asse: 'Stile di Vita & Sonno', sotto_dominio: 'questionario_lifestyle', range_min: 0, range_max: 8, attivo_da: DA },
+  { test_id: 'q_schermi', etichetta: 'Minuti schermi nell\'ora pre-sonno', unita: 'min', tipo_valore: 'num',
+    curva: 'decstep', params: { steps: [[15, 85], [30, 70], [60, 40], [999, 10]], zeroVal: 100 },
+    asse: 'Stile di Vita & Sonno', sotto_dominio: 'questionario_lifestyle', range_min: 0, range_max: 90, attivo_da: DA },
+];
+
+export function seedRegistro(db: Database.Database): void {
+  const ins = db.prepare(
+    `INSERT OR REPLACE INTO registro_test
+       (test_id, etichetta, unita, tipo_valore, curva, params, asse, sotto_dominio,
+        range_min, range_max, attivo_da, attivo_a, note)
+     VALUES (@test_id, @etichetta, @unita, @tipo_valore, @curva, @params, @asse, @sotto_dominio,
+             @range_min, @range_max, @attivo_da, @attivo_a, @note)`
+  );
+  const tx = db.transaction((voci: VoceRegistro[]) => {
+    for (const v of voci) {
+      ins.run({
+        test_id: v.test_id, etichetta: v.etichetta, unita: v.unita ?? null,
+        tipo_valore: v.tipo_valore, curva: v.curva ?? null,
+        params: v.params === undefined ? null : JSON.stringify(v.params),
+        asse: v.asse ?? null, sotto_dominio: v.sotto_dominio ?? null,
+        range_min: v.range_min ?? null, range_max: v.range_max ?? null,
+        attivo_da: v.attivo_da, attivo_a: v.attivo_a ?? null, note: null,
+      });
+    }
+  });
+  tx(QUESTIONARIO);
+}
+
+// Pesi presi dal motore del cliente (AXIS_SUBDOMAIN_WEIGHTS, MACRO_SCORE_WEIGHTS,
+// FITNESS_AGE_WEIGHTS). I macro con peso 0 non si inseriscono: assenza e zero sono
+// la stessa cosa per la rinormalizzazione, e una riga a zero confonde chi legge.
+const PESI_ASSE: Record<string, Record<string, number>> = {
+  'Forza & Struttura': { handgrip: 0.25, spinta: 0.20, trazione: 0.20, arti_inferiori: 0.20, core: 0.15 },
+  'Composizione Corporea': { grasso: 0.40, muscolo: 0.35, whr: 0.25 },
+  'Cardio-Respiratorio': { vo2max: 0.60, spirometria: 0.20, wellness_tower_cardio: 0.20 },
+  'Recupero & Sistema Nervoso': { hrv: 0.50, pressione: 0.15, hrr: 0.15, questionario_sonno: 0.20 },
+  'Energia & Regolazione Stress': { hrv: 0.50, questionario_energia_stress: 0.50 },
+  'Stabilità & Mobilità Funzionale': { flamingo: 0.35, sit_and_reach: 0.25, plank: 0.20, back_scratch: 0.14, wellness_tower_shoulder: 0.06 },
+  'Stile di Vita & Sonno': { questionario_lifestyle: 1.00 },
+};
+
+const PESI_MACRO: Record<string, Record<string, number>> = {
+  PERFORMANCE: {
+    'Forza & Struttura': 0.25, 'Cardio-Respiratorio': 0.25, 'Composizione Corporea': 0.15,
+    'Stabilità & Mobilità Funzionale': 0.20, 'Recupero & Sistema Nervoso': 0.10,
+    'Energia & Regolazione Stress': 0.05,
+  },
+  ENERGY: {
+    'Energia & Regolazione Stress': 0.30, 'Stile di Vita & Sonno': 0.20,
+    'Recupero & Sistema Nervoso': 0.25, 'Cardio-Respiratorio': 0.15, 'Composizione Corporea': 0.10,
+  },
+  RECOVERY: {
+    'Recupero & Sistema Nervoso': 0.45, 'Energia & Regolazione Stress': 0.15,
+    'Stile di Vita & Sonno': 0.20, 'Stabilità & Mobilità Funzionale': 0.15, 'Forza & Struttura': 0.05,
+  },
+};
+
+const PESI_FITNESS_AGE: Record<string, number> = {
+  cardio: 0.30, handgrip_isolato: 0.20, hrv_isolato: 0.20,
+  forza_resto: 0.15, composizione: 0.10, stabilita: 0.05,
+};
+
+export function seedPesi(db: Database.Database, modelVersion: string): void {
+  const ins = db.prepare(
+    `INSERT OR REPLACE INTO pesi (model_version, livello, contenitore, elemento, peso)
+     VALUES (?, ?, ?, ?, ?)`
+  );
+  const tx = db.transaction(() => {
+    for (const [asse, sd] of Object.entries(PESI_ASSE))
+      for (const [el, p] of Object.entries(sd)) ins.run(modelVersion, 'asse', asse, el, p);
+    for (const [macro, assi] of Object.entries(PESI_MACRO))
+      for (const [el, p] of Object.entries(assi)) ins.run(modelVersion, 'macro', macro, el, p);
+    for (const [el, p] of Object.entries(PESI_FITNESS_AGE))
+      ins.run(modelVersion, 'fitness_age', 'fitness_age', el, p);
+  });
+  tx();
+}
+
+export function testAttivi(db: Database.Database, alla: string): VoceRegistro[] {
+  const righe = db.prepare(
+    `SELECT * FROM registro_test
+     WHERE attivo_da <= ? AND (attivo_a IS NULL OR attivo_a > ?)
+     ORDER BY test_id`
+  ).all(alla, alla) as Record<string, unknown>[];
+  return righe.map((r) => ({
+    ...r,
+    params: r.params ? JSON.parse(r.params as string) : undefined,
+  })) as VoceRegistro[];
+}
+
+export function esisteTest(db: Database.Database, testId: string): boolean {
+  const r = db.prepare(`SELECT 1 FROM registro_test WHERE test_id = ?`).get(testId);
+  return r !== undefined;
+}
+```
+
+- [ ] **Step 4: Run test to verify it passes**
+
+Run: `npm test -- tests/longevity/registro.test.ts`
+Expected: PASS, 8 test
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add src/lib/longevity/registro.ts tests/longevity/registro.test.ts
+git commit -m "longevity: registro dei test e pesi versionati come dato"
+```
+
+---
+
+### Task 3: registraMisure — l'unico varco di scrittura
+
+**Files:**
+- Create: `src/lib/longevity/misure.ts`
+- Test: `tests/longevity/misure.test.ts`
+
+**Interfaces:**
+- Consumes: `createLongevityDb` (Task 1), `esisteTest`, `seedRegistro` (Task 2)
+- Produces:
+  - `type Fonte = 'manuale'|'questionario'|'wellness_tower'|'vald'|'calibre'|'stress_index'`
+  - `type MisuraIn = { test_id: string; valore_num?: number; valore_txt?: string; unita?: string }`
+  - `apriSessione(db, s: { client_code: string; data: string; tipo: 'checkup'|'questionario'; eta_alla_data?: number; operatore?: string; quest_version?: string }): number`
+  - `registraMisure(db, sessioneId: number, fonte: Fonte, misure: MisuraIn[]): { scritte: number; fuoriRange: string[] }`
+
+- [ ] **Step 1: Write the failing test**
+
+```ts
+// tests/longevity/misure.test.ts
+import { describe, it, expect } from 'vitest';
+import { createLongevityDb } from '../../src/lib/longevity/db';
+import { seedRegistro } from '../../src/lib/longevity/registro';
+import { apriSessione, registraMisure } from '../../src/lib/longevity/misure';
+
+function dbPronto() {
+  const db = createLongevityDb(':memory:');
+  seedRegistro(db);
+  db.prepare(`INSERT INTO soggetti (client_code, sesso) VALUES ('ISL-0001', 'F')`).run();
+  return db;
+}
+
+describe('registrazione delle misure', () => {
+  it('scrive le misure di una sessione', () => {
+    const db = dbPronto();
+    const s = apriSessione(db, { client_code: 'ISL-0001', data: '2026-08-21', tipo: 'questionario', quest_version: 'v1.0' });
+    const esito = registraMisure(db, s, 'questionario', [
+      { test_id: 'q_ore_sonno', valore_num: 7.5 },
+      { test_id: 'q_riposato', valore_num: 8 },
+    ]);
+    expect(esito.scritte).toBe(2);
+    const n = db.prepare(`SELECT COUNT(*) n FROM misure WHERE sessione_id = ?`).get(s) as { n: number };
+    expect(n.n).toBe(2);
+  });
+
+  it('rifiuta un test sconosciuto e non scrive niente del lotto', () => {
+    const db = dbPronto();
+    const s = apriSessione(db, { client_code: 'ISL-0001', data: '2026-08-21', tipo: 'checkup' });
+    expect(() =>
+      registraMisure(db, s, 'manuale', [
+        { test_id: 'q_ore_sonno', valore_num: 7 },
+        { test_id: 'test_inventato', valore_num: 1 },
+      ])
+    ).toThrow(/test_inventato/);
+    const n = db.prepare(`SELECT COUNT(*) n FROM misure`).get() as { n: number };
+    expect(n.n).toBe(0);
+  });
+
+  it('un valore fuori dal range atteso si scrive e si marca', () => {
+    const db = dbPronto();
+    const s = apriSessione(db, { client_code: 'ISL-0001', data: '2026-08-21', tipo: 'questionario' });
+    const esito = registraMisure(db, s, 'questionario', [{ test_id: 'q_ore_sonno', valore_num: 26 }]);
+    expect(esito.fuoriRange).toEqual(['q_ore_sonno']);
+    const row = db.prepare(`SELECT fuori_range FROM misure WHERE test_id = 'q_ore_sonno'`).get() as { fuori_range: number };
+    expect(row.fuori_range).toBe(1);
+  });
+
+  it('la sessione porta la versione del questionario', () => {
+    const db = dbPronto();
+    const s = apriSessione(db, { client_code: 'ISL-0001', data: '2026-08-21', tipo: 'questionario', quest_version: 'v1.0' });
+    const row = db.prepare(`SELECT quest_version FROM sessioni WHERE id = ?`).get(s) as { quest_version: string };
+    expect(row.quest_version).toBe('v1.0');
+  });
+
+  it('il client_code della misura viene dalla sessione, non da chi chiama', () => {
+    const db = dbPronto();
+    db.prepare(`INSERT INTO soggetti (client_code, sesso) VALUES ('ISL-0002', 'M')`).run();
+    const s = apriSessione(db, { client_code: 'ISL-0002', data: '2026-08-21', tipo: 'checkup' });
+    registraMisure(db, s, 'manuale', [{ test_id: 'q_riposato', valore_num: 5 }]);
+    const row = db.prepare(`SELECT client_code FROM misure`).get() as { client_code: string };
+    expect(row.client_code).toBe('ISL-0002');
+  });
+});
+```
+
+- [ ] **Step 2: Run test to verify it fails**
+
+Run: `npm test -- tests/longevity/misure.test.ts`
+Expected: FAIL — modulo `misure` non trovato
+
+- [ ] **Step 3: Write minimal implementation**
+
+```ts
+// src/lib/longevity/misure.ts
+import type Database from 'better-sqlite3';
+import { esisteTest } from './registro';
+
+export type Fonte = 'manuale' | 'questionario' | 'wellness_tower' | 'vald' | 'calibre' | 'stress_index';
+
+export type MisuraIn = {
+  test_id: string;
+  valore_num?: number;
+  valore_txt?: string;
+  unita?: string;
+};
+
+export function apriSessione(
+  db: Database.Database,
+  s: {
+    client_code: string; data: string; tipo: 'checkup' | 'questionario';
+    eta_alla_data?: number; operatore?: string; quest_version?: string;
+  }
+): number {
+  const r = db.prepare(
+    `INSERT INTO sessioni (client_code, data, tipo, eta_alla_data, operatore, quest_version)
+     VALUES (?, ?, ?, ?, ?, ?)`
+  ).run(s.client_code, s.data, s.tipo, s.eta_alla_data ?? null, s.operatore ?? null, s.quest_version ?? null);
+  return Number(r.lastInsertRowid);
+}
+
+/**
+ * L'unico punto in cui si scrive nella tabella `misure`.
+ * Un test_id sconosciuto fa fallire l'intero lotto: meglio un errore subito che una
+ * sessione scritta a meta'. Un valore fuori dal range atteso invece si scrive e si
+ * marca — scartarlo perderebbe un dato vero, clamparlo lo falserebbe.
+ */
+export function registraMisure(
+  db: Database.Database,
+  sessioneId: number,
+  fonte: Fonte,
+  misure: MisuraIn[]
+): { scritte: number; fuoriRange: string[] } {
+  const sess = db.prepare(`SELECT client_code FROM sessioni WHERE id = ?`).get(sessioneId) as
+    { client_code: string } | undefined;
+  if (!sess) throw new Error(`sessione ${sessioneId} inesistente`);
+
+  for (const m of misure) {
+    if (!esisteTest(db, m.test_id)) {
+      throw new Error(`test_id non nel registro: ${m.test_id}`);
+    }
+  }
+
+  const range = db.prepare(`SELECT range_min, range_max FROM registro_test WHERE test_id = ?`);
+  const ins = db.prepare(
+    `INSERT INTO misure (sessione_id, client_code, test_id, valore_num, valore_txt, unita, fonte, fuori_range)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?)`
+  );
+  const fuoriRange: string[] = [];
+
+  const tx = db.transaction(() => {
+    for (const m of misure) {
+      const r = range.get(m.test_id) as { range_min: number | null; range_max: number | null };
+      let fuori = 0;
+      if (m.valore_num !== undefined) {
+        if ((r.range_min !== null && m.valore_num < r.range_min) ||
+            (r.range_max !== null && m.valore_num > r.range_max)) {
+          fuori = 1;
+          fuoriRange.push(m.test_id);
+        }
+      }
+      ins.run(sessioneId, sess.client_code, m.test_id,
+        m.valore_num ?? null, m.valore_txt ?? null, m.unita ?? null, fonte, fuori);
+    }
+  });
+  tx();
+
+  return { scritte: misure.length, fuoriRange };
+}
+```
+
+- [ ] **Step 4: Run test to verify it passes**
+
+Run: `npm test -- tests/longevity/misure.test.ts`
+Expected: PASS, 5 test
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add src/lib/longevity/misure.ts tests/longevity/misure.test.ts
+git commit -m "longevity: registraMisure, unico varco con validazione sul registro"
+```
+
+---
+
+### Task 4: Anagrafica — l'unico modulo che unisce identity e longevity
+
+**Files:**
+- Create: `src/lib/longevity/anagrafica.ts`
+- Test: `tests/longevity/anagrafica.test.ts`
+
+**Interfaces:**
+- Consumes: `createLongevityDb`, `createIdentityDb` (Task 1)
+- Produces:
+  - `creaCliente(identity, longevity, dati: { nome: string; cognome: string; sesso: 'M'|'F'; data_nascita?: string; email?: string; telefono?: string; user_id?: number }): string` — restituisce il `client_code`
+  - `codicePerUtente(identity, userId: number): string | null`
+  - `etaAllaData(dataNascita: string, alla: string): number`
+
+- [ ] **Step 1: Write the failing test**
+
+```ts
+// tests/longevity/anagrafica.test.ts
+import { describe, it, expect } from 'vitest';
+import { readFileSync, readdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { createLongevityDb, createIdentityDb } from '../../src/lib/longevity/db';
+import { creaCliente, codicePerUtente, etaAllaData } from '../../src/lib/longevity/anagrafica';
+
+describe('anagrafica pseudonimizzata', () => {
+  it('il nome sta in identity, il sesso in longevity, e i due non si mescolano', () => {
+    const id = createIdentityDb(':memory:');
+    const lg = createLongevityDb(':memory:');
+    const code = creaCliente(id, lg, { nome: 'Mario', cognome: 'Rossi', sesso: 'M', data_nascita: '1988-03-04' });
+
+    const inIdentity = id.prepare(`SELECT nome, cognome FROM clienti WHERE client_code = ?`).get(code) as
+      { nome: string; cognome: string };
+    expect(inIdentity.nome).toBe('Mario');
+
+    const inLongevity = lg.prepare(`SELECT sesso FROM soggetti WHERE client_code = ?`).get(code) as { sesso: string };
+    expect(inLongevity.sesso).toBe('M');
+
+    // in longevity non deve esistere nessuna colonna che contenga il nome
+    const dump = JSON.stringify(lg.prepare(`SELECT * FROM soggetti`).all());
+    expect(dump).not.toContain('Mario');
+    expect(dump).not.toContain('Rossi');
+    expect(dump).not.toContain('1988-03-04');
+  });
+
+  it('assegna codici progressivi e non riusa i vecchi', () => {
+    const id = createIdentityDb(':memory:');
+    const lg = createLongevityDb(':memory:');
+    const a = creaCliente(id, lg, { nome: 'A', cognome: 'A', sesso: 'F' });
+    const b = creaCliente(id, lg, { nome: 'B', cognome: 'B', sesso: 'M' });
+    expect(a).toMatch(/^ISL-\d{4}$/);
+    expect(b).not.toBe(a);
+  });
+
+  it('ritrova il codice a partire dall utente del sito', () => {
+    const id = createIdentityDb(':memory:');
+    const lg = createLongevityDb(':memory:');
+    const code = creaCliente(id, lg, { nome: 'C', cognome: 'C', sesso: 'F', user_id: 42 });
+    expect(codicePerUtente(id, 42)).toBe(code);
+    expect(codicePerUtente(id, 99)).toBeNull();
+  });
+
+  it('calcola l eta alla data della sessione', () => {
+    expect(etaAllaData('1988-03-04', '2026-08-21')).toBe(38);
+    expect(etaAllaData('1988-12-31', '2026-08-21')).toBe(37); // compleanno non ancora passato
+  });
+
+  it('nessun altro modulo apre entrambe le connessioni', () => {
+    const dir = join(process.cwd(), 'src/lib/longevity');
+    const colpevoli: string[] = [];
+    for (const f of readdirSync(dir)) {
+      if (!f.endsWith('.ts') || f === 'anagrafica.ts' || f === 'db.ts') continue;
+      const src = readFileSync(join(dir, f), 'utf8');
+      if (src.includes('createIdentityDb') && src.includes('createLongevityDb')) colpevoli.push(f);
+    }
+    expect(colpevoli).toEqual([]);
+  });
+});
+```
+
+- [ ] **Step 2: Run test to verify it fails**
+
+Run: `npm test -- tests/longevity/anagrafica.test.ts`
+Expected: FAIL — modulo `anagrafica` non trovato
+
+- [ ] **Step 3: Write minimal implementation**
+
+```ts
+// src/lib/longevity/anagrafica.ts
+//
+// QUESTO e' l'unico modulo autorizzato ad aprire insieme identity e longevity.
+// La separazione dei due database e' la garanzia che chi legge i dati clinici non
+// risalga alla persona (richiesta del cliente, 21/08): un secondo punto di giunzione
+// la annullerebbe in silenzio. Un test in tests/longevity/anagrafica.test.ts lo verifica.
+import type Database from 'better-sqlite3';
+
+export function creaCliente(
+  identity: Database.Database,
+  longevity: Database.Database,
+  dati: {
+    nome: string; cognome: string; sesso: 'M' | 'F';
+    data_nascita?: string; email?: string; telefono?: string; user_id?: number;
+  }
+): string {
+  const ultimo = identity.prepare(
+    `SELECT client_code FROM clienti ORDER BY client_code DESC LIMIT 1`
+  ).get() as { client_code: string } | undefined;
+  const n = ultimo ? Number(ultimo.client_code.slice(4)) + 1 : 1;
+  const code = `ISL-${String(n).padStart(4, '0')}`;
+
+  identity.prepare(
+    `INSERT INTO clienti (client_code, user_id, nome, cognome, data_nascita, email, telefono)
+     VALUES (?, ?, ?, ?, ?, ?, ?)`
+  ).run(code, dati.user_id ?? null, dati.nome, dati.cognome,
+        dati.data_nascita ?? null, dati.email ?? null, dati.telefono ?? null);
+
+  longevity.prepare(`INSERT INTO soggetti (client_code, sesso) VALUES (?, ?)`).run(code, dati.sesso);
+
+  return code;
+}
+
+export function codicePerUtente(identity: Database.Database, userId: number): string | null {
+  const r = identity.prepare(`SELECT client_code FROM clienti WHERE user_id = ?`).get(userId) as
+    { client_code: string } | undefined;
+  return r?.client_code ?? null;
+}
+
+/** L'eta' al momento della misura: e' cio' che serve al motore, e non e' un quasi-identificatore. */
+export function etaAllaData(dataNascita: string, alla: string): number {
+  const n = new Date(dataNascita);
+  const d = new Date(alla);
+  let eta = d.getFullYear() - n.getFullYear();
+  const m = d.getMonth() - n.getMonth();
+  if (m < 0 || (m === 0 && d.getDate() < n.getDate())) eta--;
+  return eta;
+}
+```
+
+- [ ] **Step 4: Run test to verify it passes**
+
+Run: `npm test -- tests/longevity/anagrafica.test.ts`
+Expected: PASS, 5 test
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add src/lib/longevity/anagrafica.ts tests/longevity/anagrafica.test.ts
+git commit -m "longevity: anagrafica, unico punto di giunzione fra identita e clinica"
+```
+
+---
+
+### Task 5: Ruoli `cliente` e `trainer`
+
+**Files:**
+- Modify: `src/lib/auth.ts` (type `Role` alla riga 8, array `RULES` alla riga ~56, `canAccessAdminPath`)
+- Test: `tests/longevity/ruoli.test.ts`
+
+**Interfaces:**
+- Consumes: `canAccessAdminPath` esistente
+- Produces: `Role` esteso con `'cliente' | 'trainer'`
+
+- [ ] **Step 1: Write the failing test**
+
+```ts
+// tests/longevity/ruoli.test.ts
+import { describe, it, expect } from 'vitest';
+import { canAccessAdminPath } from '../../src/lib/auth';
+
+describe('accesso alle rotte longevity', () => {
+  it('il cliente entra nel proprio spazio', () => {
+    expect(canAccessAdminPath('cliente', '/longevity/io')).toBe(true);
+  });
+
+  it('il cliente NON entra nel gestionale', () => {
+    expect(canAccessAdminPath('cliente', '/longevity/gestionale')).toBe(false);
+  });
+
+  it('il trainer entra in entrambi', () => {
+    expect(canAccessAdminPath('trainer', '/longevity/io')).toBe(true);
+    expect(canAccessAdminPath('trainer', '/longevity/gestionale')).toBe(true);
+  });
+
+  it('il cliente non entra nelle altre piattaforme ne nel blog', () => {
+    expect(canAccessAdminPath('cliente', '/campus')).toBe(false);
+    expect(canAccessAdminPath('cliente', '/admin/content')).toBe(false);
+    expect(canAccessAdminPath('cliente', '/admin/posts')).toBe(false);
+  });
+
+  it('il ruolo piattaforme non eredita longevity', () => {
+    expect(canAccessAdminPath('piattaforme', '/longevity/gestionale')).toBe(false);
+  });
+
+  it('admin passa sempre', () => {
+    expect(canAccessAdminPath('admin', '/longevity/gestionale')).toBe(true);
+  });
+});
+```
+
+- [ ] **Step 2: Run test to verify it fails**
+
+Run: `npm test -- tests/longevity/ruoli.test.ts`
+Expected: FAIL — `canAccessAdminPath('cliente', '/longevity/gestionale')` restituisce `true` (la regola finale lascia passare i loggati)
+
+- [ ] **Step 3: Write minimal implementation**
+
+In `src/lib/auth.ts`, riga 8, estendere il tipo:
+
+```ts
+export type Role = 'admin' | 'superuser' | 'user' | 'piattaforme' | 'cliente' | 'trainer';
+```
+
+Nell'array `RULES`, aggiungere in fondo (prima della chiusura `];`):
+
+```ts
+  // Longevity: il cliente vede solo il proprio spazio, il gestionale e' del trainer.
+  [/^\/longevity\/gestionale(\/|$)/, ['admin', 'trainer']],
+  [/^\/api\/longevity\/gestionale(\/|$)/, ['admin', 'trainer']],
+  [/^\/longevity(\/|$)/, ['admin', 'trainer', 'cliente']],
+  [/^\/api\/longevity(\/|$)/, ['admin', 'trainer', 'cliente']],
+```
+
+In `canAccessAdminPath`, prima del `return true` finale, aggiungere la stessa clausola che esiste per `piattaforme`:
+
+```ts
+  // cliente e trainer non sono utenti del sito: fuori dalle rotte elencate non passano.
+  if (role === 'cliente' || role === 'trainer') return pathname === '/admin/logout';
+```
+
+- [ ] **Step 4: Run test to verify it passes**
+
+Run: `npm test`
+Expected: PASS — i 6 test nuovi e **tutti quelli esistenti**, in particolare `tests/auth.test.ts` e `tests/auth-piattaforme.test.ts`
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add src/lib/auth.ts tests/longevity/ruoli.test.ts
+git commit -m "longevity: ruoli cliente e trainer con le rispettive rotte"
+```
+
+---
+
+### Task 6: Salvataggio di una compilazione del questionario
+
+**Files:**
+- Create: `src/lib/longevity/questionario.ts`
+- Test: `tests/longevity/questionario.test.ts`
+
+**Interfaces:**
+- Consumes: `apriSessione`, `registraMisure` (Task 3), `seedRegistro` (Task 2)
+- Produces:
+  - `QUEST_VERSION: string` (`'v1.0'`)
+  - `CAMPI_LIBERI: string[]` (`['farmaci','problematiche_attuali','problematiche_pregresse','obiettivi']`)
+  - `salvaCompilazione(db, input: { client_code: string; data: string; eta?: number; risposte: Record<string, number>; liberi?: Record<string, string> }): number`
+
+- [ ] **Step 1: Write the failing test**
+
+```ts
+// tests/longevity/questionario.test.ts
+import { describe, it, expect } from 'vitest';
+import { createLongevityDb } from '../../src/lib/longevity/db';
+import { seedRegistro } from '../../src/lib/longevity/registro';
+import { salvaCompilazione, QUEST_VERSION } from '../../src/lib/longevity/questionario';
+
+function dbPronto() {
+  const db = createLongevityDb(':memory:');
+  seedRegistro(db);
+  db.prepare(`INSERT INTO soggetti (client_code, sesso) VALUES ('ISL-0001', 'F')`).run();
+  return db;
+}
+
+describe('compilazione del questionario', () => {
+  it('salva le risposte punteggiate come misure', () => {
+    const db = dbPronto();
+    const s = salvaCompilazione(db, {
+      client_code: 'ISL-0001', data: '2026-08-21',
+      risposte: { q_ore_sonno: 7.5, q_riposato: 8, q_alcol_life: 3 },
+    });
+    const n = db.prepare(`SELECT COUNT(*) n FROM misure WHERE sessione_id = ? AND fonte = 'questionario'`)
+      .get(s) as { n: number };
+    expect(n.n).toBe(3);
+  });
+
+  it('marchia la compilazione con la versione del questionario', () => {
+    const db = dbPronto();
+    const s = salvaCompilazione(db, { client_code: 'ISL-0001', data: '2026-08-21', risposte: { q_riposato: 6 } });
+    const row = db.prepare(`SELECT tipo, quest_version FROM sessioni WHERE id = ?`).get(s) as
+      { tipo: string; quest_version: string };
+    expect(row.tipo).toBe('questionario');
+    expect(row.quest_version).toBe(QUEST_VERSION);
+  });
+
+  it('i campi liberi vanno in profilo_note, non fra le misure', () => {
+    const db = dbPronto();
+    const s = salvaCompilazione(db, {
+      client_code: 'ISL-0001', data: '2026-08-21',
+      risposte: { q_riposato: 6 },
+      liberi: { farmaci: 'nessuno', obiettivi: 'dormire meglio' },
+    });
+    const note = db.prepare(`SELECT campo_id, testo FROM profilo_note WHERE sessione_id = ? ORDER BY campo_id`)
+      .all(s) as { campo_id: string; testo: string }[];
+    expect(note.map((n) => n.campo_id)).toEqual(['farmaci', 'obiettivi']);
+    const misure = db.prepare(`SELECT test_id FROM misure WHERE sessione_id = ?`).all(s) as { test_id: string }[];
+    expect(misure.map((m) => m.test_id)).toEqual(['q_riposato']);
+  });
+
+  it('ogni compilazione e un record nuovo, non un aggiornamento', () => {
+    const db = dbPronto();
+    salvaCompilazione(db, { client_code: 'ISL-0001', data: '2026-08-21', risposte: { q_riposato: 6 } });
+    salvaCompilazione(db, { client_code: 'ISL-0001', data: '2026-09-21', risposte: { q_riposato: 9 } });
+    const n = db.prepare(`SELECT COUNT(*) n FROM sessioni WHERE tipo = 'questionario'`).get() as { n: number };
+    expect(n.n).toBe(2);
+  });
+
+  it('una risposta con id sconosciuto fa fallire la compilazione intera', () => {
+    const db = dbPronto();
+    expect(() =>
+      salvaCompilazione(db, {
+        client_code: 'ISL-0001', data: '2026-08-21',
+        risposte: { q_riposato: 6, q_domanda_nuova: 3 },
+      })
+    ).toThrow(/q_domanda_nuova/);
+    const n = db.prepare(`SELECT COUNT(*) n FROM sessioni`).get() as { n: number };
+    expect(n.n).toBe(0);
+  });
+});
+```
+
+- [ ] **Step 2: Run test to verify it fails**
+
+Run: `npm test -- tests/longevity/questionario.test.ts`
+Expected: FAIL — modulo `questionario` non trovato
+
+- [ ] **Step 3: Write minimal implementation**
+
+```ts
+// src/lib/longevity/questionario.ts
+import type Database from 'better-sqlite3';
+import { apriSessione, registraMisure } from './misure';
+import { esisteTest } from './registro';
+
+/** Versione del set di domande. Si incrementa quando cambia una domanda. */
+export const QUEST_VERSION = 'v1.0';
+
+/**
+ * Campi testuali che si salvano ma non entrano MAI in una formula
+ * (indicazione esplicita del cliente, punto 7 della specifica).
+ */
+export const CAMPI_LIBERI = ['farmaci', 'problematiche_attuali', 'problematiche_pregresse', 'obiettivi'];
+
+export function salvaCompilazione(
+  db: Database.Database,
+  input: {
+    client_code: string; data: string; eta?: number;
+    risposte: Record<string, number>;
+    liberi?: Record<string, string>;
+  }
+): number {
+  // Validare PRIMA di aprire la sessione: altrimenti un id sbagliato lascia
+  // in giro una sessione vuota.
+  for (const id of Object.keys(input.risposte)) {
+    if (!esisteTest(db, id)) throw new Error(`test_id non nel registro: ${id}`);
+  }
+
+  const sessioneId = apriSessione(db, {
+    client_code: input.client_code,
+    data: input.data,
+    tipo: 'questionario',
+    eta_alla_data: input.eta,
+    quest_version: QUEST_VERSION,
+  });
+
+  registraMisure(
+    db, sessioneId, 'questionario',
+    Object.entries(input.risposte).map(([test_id, valore_num]) => ({ test_id, valore_num }))
+  );
+
+  if (input.liberi) {
+    const ins = db.prepare(
+      `INSERT INTO profilo_note (client_code, sessione_id, campo_id, testo) VALUES (?, ?, ?, ?)`
+    );
+    const tx = db.transaction(() => {
+      for (const [campo, testo] of Object.entries(input.liberi!)) {
+        if (testo.trim() === '') continue;
+        ins.run(input.client_code, sessioneId, campo, testo);
+      }
+    });
+    tx();
+  }
+
+  return sessioneId;
+}
+```
+
+- [ ] **Step 4: Run test to verify it passes**
+
+Run: `npm test -- tests/longevity/questionario.test.ts`
+Expected: PASS, 5 test
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add src/lib/longevity/questionario.ts tests/longevity/questionario.test.ts
+git commit -m "longevity: salvataggio compilazione questionario, versionata"
+```
+
+---
+
+### Task 7: Export pseudonimizzato
+
+**Files:**
+- Create: `src/lib/longevity/export.ts`
+- Test: `tests/longevity/export.test.ts`
+
+**Interfaces:**
+- Consumes: `createLongevityDb` (Task 1)
+- Produces: `esportaMisure(db): { intestazioni: string[]; righe: (string|number|null)[][] }`, `esportaCsv(db): string`
+
+- [ ] **Step 1: Write the failing test**
+
+```ts
+// tests/longevity/export.test.ts
+import { describe, it, expect } from 'vitest';
+import { createLongevityDb } from '../../src/lib/longevity/db';
+import { seedRegistro } from '../../src/lib/longevity/registro';
+import { salvaCompilazione } from '../../src/lib/longevity/questionario';
+import { esportaMisure, esportaCsv } from '../../src/lib/longevity/export';
+
+function dbConDati() {
+  const db = createLongevityDb(':memory:');
+  seedRegistro(db);
+  db.prepare(`INSERT INTO soggetti (client_code, sesso) VALUES ('ISL-0001', 'F')`).run();
+  salvaCompilazione(db, {
+    client_code: 'ISL-0001', data: '2026-08-21', eta: 35,
+    risposte: { q_ore_sonno: 7, q_riposato: 8 },
+    liberi: { farmaci: 'nessuno' },
+  });
+  return db;
+}
+
+describe('export per le statistiche', () => {
+  it('esporta una riga per misura con codice, non con nome', () => {
+    const db = dbConDati();
+    const out = esportaMisure(db);
+    expect(out.intestazioni).toEqual(
+      ['client_code', 'sesso', 'eta', 'data', 'tipo_sessione', 'quest_version', 'test_id', 'valore', 'unita', 'fonte', 'fuori_range']
+    );
+    expect(out.righe.length).toBe(2);
+    expect(out.righe[0][0]).toBe('ISL-0001');
+  });
+
+  it('l export non contiene campi identificativi', () => {
+    const db = dbConDati();
+    const testo = JSON.stringify(esportaMisure(db));
+    for (const vietato of ['nome', 'cognome', 'email', 'telefono', 'data_nascita']) {
+      expect(testo).not.toContain(vietato);
+    }
+  });
+
+  it('i campi liberi restano fuori dall export statistico', () => {
+    const db = dbConDati();
+    expect(JSON.stringify(esportaMisure(db))).not.toContain('nessuno');
+  });
+
+  it('produce un CSV con intestazione e una riga per misura', () => {
+    const db = dbConDati();
+    const righe = esportaCsv(db).trim().split('\n');
+    expect(righe.length).toBe(3); // intestazione + 2 misure
+    expect(righe[0]).toBe('client_code,sesso,eta,data,tipo_sessione,quest_version,test_id,valore,unita,fonte,fuori_range');
+  });
+});
+```
+
+- [ ] **Step 2: Run test to verify it fails**
+
+Run: `npm test -- tests/longevity/export.test.ts`
+Expected: FAIL — modulo `export` non trovato
+
+- [ ] **Step 3: Write minimal implementation**
+
+```ts
+// src/lib/longevity/export.ts
+//
+// L'export per le statistiche legge SOLO longevity.db, che per costruzione non contiene
+// nomi: non serve nessuna funzione di anonimizzazione, e non c'e' niente da ricordarsi.
+// I campi liberi (farmaci, patologie) restano fuori: sono per il coach, non per l'analisi.
+import type Database from 'better-sqlite3';
+
+const INTESTAZIONI = [
+  'client_code', 'sesso', 'eta', 'data', 'tipo_sessione',
+  'quest_version', 'test_id', 'valore', 'unita', 'fonte', 'fuori_range',
+];
+
+export function esportaMisure(db: Database.Database): {
+  intestazioni: string[];
+  righe: (string | number | null)[][];
+} {
+  const righe = db.prepare(
+    `SELECT sg.client_code, sg.sesso, s.eta_alla_data, s.data, s.tipo, s.quest_version,
+            m.test_id, COALESCE(m.valore_num, m.valore_txt) AS valore, m.unita, m.fonte, m.fuori_range
+     FROM misure m
+     JOIN sessioni s ON s.id = m.sessione_id
+     JOIN soggetti sg ON sg.client_code = m.client_code
+     ORDER BY s.data, m.id`
+  ).raw().all() as (string | number | null)[][];
+
+  return { intestazioni: INTESTAZIONI, righe };
+}
+
+export function esportaCsv(db: Database.Database): string {
+  const { intestazioni, righe } = esportaMisure(db);
+  const cella = (v: string | number | null) => {
+    if (v === null) return '';
+    const s = String(v);
+    return /[",\n]/.test(s) ? `"${s.replace(/"/g, '""')}"` : s;
+  };
+  return [intestazioni.join(','), ...righe.map((r) => r.map(cella).join(','))].join('\n') + '\n';
+}
+```
+
+- [ ] **Step 4: Run test to verify it passes**
+
+Run: `npm test`
+Expected: PASS — tutta la suite, vecchia e nuova
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add src/lib/longevity/export.ts tests/longevity/export.test.ts
+git commit -m "longevity: export pseudonimizzato per costruzione"
+```
+
+---
+
+## Cosa esiste alla fine di questo piano
+
+Una libreria testata che sa: aprire i due database, tenere il registro dei test e i pesi versionati, registrare misure da qualunque sorgente validandole, creare un cliente tenendo separata l'identità dalla clinica, salvare una compilazione di questionario con la sua versione, ed esportare i dati già pseudonimizzati.
+
+**Non esiste ancora**: nessuna pagina, nessun punteggio calcolato. Sono i due piani successivi — prima il motore (porting delle curve dal Python con il verificatore), poi le pagine.
+
+## Nota per chi eseguirà il piano successivo
+
+Il registro creato al Task 2 contiene `curva` e `params` per tutti e 20 i campi del questionario, nella forma dichiarata per tipo di curva (`bell`, `lin_dec`, `decstep`, `incstep`, `x10`, `x10_inv`). Il motore leggerà di lì, non da costanti nel codice.
+
+⚠️ `x10_inv` è **la quinta curva che manca al motore Python**: serve a `q_calo_pomeridiano` e nel prototipo è `scale10_inv`, cioè `(10 - valore) × 10`. Il porting deve implementarla, non cercarla nel file del cliente.