Calcola davvero le serie di presenze e sblocca badge e obiettivo.

I tre contatori (serieAllenamenti, seriePartite, serieConferme) e streak erano
zero fisso in useRosa(): la sezione Serie di presenze del profilo mostrava sempre
progresso nullo, i badge legati alla costanza erano impossibili da sbloccare e
l'obiettivo Continuita di squadra restava a 0/12.

serieConsecutiva() e serieConferme() (src/lib/presenze.ts) derivano le serie dagli
eventi passati e da risposte_presenze gia in cache, senza query aggiuntive.

Migration m9: nuova colonna risposto_il con l'istante della prima risposta, resa
immutabile da un trigger, confrontata con eventi_app.creato_il per le conferme
entro 24 ore. Serviva perche aggiornato_il registra l'ultima modifica, quindi chi
rispondeva subito e cambiava idea dopo risultava lento.

Corregge anche la barra di progresso, che misurava valore/prossimo e tornava
indietro a ogni traguardo raggiunto (2/3 = 67%, poi 3/6 = 50%).

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

test/unit/eventi.test.ts

@@ -14,6 +14,7 @@ const riga: RigaEvento = {
   campionato: true,
   casa: true,
   pagelle_chiuse: false,
+  creato_il: "2026-08-20T09:00:00Z",
 };
 
 // --- daRiga: i NULL del database diventano valori sicuri ---------------------
@@ -29,6 +30,7 @@ assert.deepEqual(daRiga(riga), {
   campionato: true,
   casa: true,
   pagelleChiuse: false,
+  creatoIl: "2026-08-20T09:00:00Z",
 });
 
 const vuota = daRiga({

test/unit/presenze.test.ts

@@ -0,0 +1,95 @@
+/** Check delle serie di presenze: `bun test/unit/presenze.test.ts`. */
+import assert from "node:assert/strict";
+import type { Evento } from "@/lib/eventi";
+import {
+  serieConferme,
+  serieConsecutiva,
+  type MappaPresenze,
+  type MappaTempiRisposta,
+} from "@/lib/presenze";
+
+const ev = (id: string, tipo: Evento["tipo"], data: string, convocati: string[] = []): Evento => ({
+  id,
+  tipo,
+  titolo: id,
+  luogo: "",
+  data,
+  ora: "20:00",
+  note: "",
+  convocati,
+  campionato: false,
+  casa: true,
+  pagelleChiuse: false,
+});
+
+const OGGI = "2026-09-04";
+
+// Passati in ordine sparso: a1 sì, a2 no, a3 sì, a4 sì. La serie riparte dopo il buco.
+const eventi: Evento[] = [
+  ev("a3", "allenamento", "2026-08-20"),
+  ev("a1", "allenamento", "2026-08-06"),
+  ev("p1", "partita", "2026-08-10"),
+  ev("a2", "allenamento", "2026-08-13"),
+  ev("a4", "allenamento", "2026-08-27"),
+  ev("a5", "allenamento", "2026-09-10"), // futuro: non conta ancora
+];
+
+const presenze: MappaPresenze = {
+  a1: { g1: "presente" },
+  a2: { g1: "assente" },
+  a3: { g1: "ritardo" },
+  a4: { g1: "presente" },
+  p1: { g1: "presente" },
+  a5: { g1: "presente" },
+};
+
+assert.equal(serieConsecutiva("g1", eventi, presenze, "allenamento", OGGI), 2, "riparte dal buco");
+assert.equal(serieConsecutiva("g1", eventi, presenze, "partita", OGGI), 1);
+assert.equal(
+  serieConsecutiva("g1", eventi, presenze, undefined, OGGI),
+  2,
+  "senza tipo conta partite e allenamenti insieme, sempre in ordine di data",
+);
+
+// Nessuna risposta vale come buco.
+assert.equal(serieConsecutiva("g2", eventi, presenze, "allenamento", OGGI), 0);
+
+// Chi non è convocato non spezza la serie di nessun altro.
+const conConvocati = [...eventi, ev("a6", "allenamento", "2026-08-30", ["g9"])];
+assert.equal(serieConsecutiva("g1", conConvocati, presenze, "allenamento", OGGI), 2);
+
+// --- serie conferme: risposta entro 24h dalla convocazione --------------------
+const convocati = (id: string, data: string, creatoIl?: string): Evento => ({
+  ...ev(id, "allenamento", data),
+  ...(creatoIl === undefined ? {} : { creatoIl }),
+});
+
+const conConvocazione: Evento[] = [
+  convocati("c1", "2026-08-06", "2026-08-01T10:00:00Z"),
+  convocati("c2", "2026-08-13", "2026-08-08T10:00:00Z"),
+  convocati("c3", "2026-08-20", "2026-08-15T10:00:00Z"),
+  convocati("c4", "2026-08-27"), // evento generato dal client: nessuna convocazione tracciata
+  convocati("c5", "2026-09-10", "2026-09-05T10:00:00Z"), // futuro
+];
+
+const tempi: MappaTempiRisposta = {
+  c1: { g1: "2026-08-01T11:00:00Z" }, // un'ora dopo
+  c2: { g1: "2026-08-10T10:00:00Z" }, // due giorni dopo: buco
+  c3: { g1: "2026-08-16T09:59:00Z" }, // appena dentro le 24h
+  c5: { g1: "2026-09-05T10:30:00Z" },
+};
+
+assert.equal(serieConferme("g1", conConvocazione, tempi, OGGI), 1, "il ritardo su c2 azzera");
+assert.equal(
+  serieConferme("g1", conConvocazione.slice(0, 1), tempi, OGGI),
+  1,
+  "una risposta rapida vale 1",
+);
+assert.equal(
+  serieConferme("g1", [conConvocazione[0]!, conConvocazione[3]!, conConvocazione[2]!], tempi, OGGI),
+  2,
+  "un evento senza istante di convocazione viene saltato, non spezza la serie",
+);
+assert.equal(serieConferme("g2", conConvocazione, tempi, OGGI), 0, "chi non risponde è a zero");
+
+console.log("presenze: ok");

test/unit/serie.test.ts

@@ -28,7 +28,14 @@ assert.equal(aDue.messaggio, "Manca solo una volta al prossimo traguardo!");
 
 const sulTraguardo = statoSerie(allenamenti, g({ serieAllenamenti: 3 }));
 assert.equal(sulTraguardo.prossimo, 6, "raggiunto un traguardo si punta al successivo");
-assert.equal(sulTraguardo.progresso, 50);
+assert.equal(sulTraguardo.progresso, 0, "nuovo livello: la barra riparte dal traguardo preso");
+
+// La barra non torna mai indietro dentro lo stesso livello.
+const dentroIlLivello = [3, 4, 5].map((v) => statoSerie(allenamenti, g({ serieAllenamenti: v })));
+assert.deepEqual(
+  dentroIlLivello.map((s) => s.progresso),
+  [0, 33, 67],
+);
 
 const veterano = statoSerie(allenamenti, g({ serieAllenamenti: 7 }));
 assert.equal(veterano.messaggio, "Che continuità: ancora 3 e sali di livello.");