feat: payments plans, phase auto-cascade, transcripts, manual timer

- Pagamenti: totale ereditato dalla somma accepted_total delle offerte
  attive (con override) + selettore schema rate 1/2/3 step; nuova colonna
  payments.percent per rescalare gli importi preservando label/stato
- Fasi & Task: recomputePhaseStatus auto-cascade (task -> fase) su
  updateTaskStatus/addTask, fix UI stale, etichette Da iniziare/In corso/Completata
- Pagina pubblica: colori fasi (grigio/blu/#1A463C) + fasi collassabili
- Transcript del cliente visibili in tab Documenti admin e dashboard pubblica
- Timer: inserimento manuale (+30/+60, minuti liberi, data) + elimina entry
- CLAUDE.md: procedura Deploy & DB Access; push su main automatico

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

src/app/admin/clients/[id]/actions.ts

@@ -162,15 +162,45 @@ export async function addTask(phaseId: string, id: string, formData: FormData) {
     sort_order: maxOrder + 1,
     status: "todo",
   });
+  // Cascade: a new todo task keeps phase active/upcoming — recompute to be safe
+  await recomputePhaseStatus(phaseId);
   const { path } = await resolveEntity(id);
   revalidatePath(path);
 }
 
+// ── PHASE STATUS CASCADE ──────────────────────────────────────────────────────
+// Recomputes phase status from its tasks:
+//   all done  → done
+//   any in_progress or done (but not all done) → active
+//   all todo (or no tasks) → upcoming
+export async function recomputePhaseStatus(phaseId: string): Promise<void> {
+  const phaseTasks = await db
+    .select({ status: tasks.status })
+    .from(tasks)
+    .where(eq(tasks.phase_id, phaseId));
+
+  let newStatus: "upcoming" | "active" | "done" = "upcoming";
+  if (phaseTasks.length > 0) {
+    const allDone = phaseTasks.every((t) => t.status === "done");
+    const anyActive = phaseTasks.some(
+      (t) => t.status === "in_progress" || t.status === "done"
+    );
+    if (allDone) newStatus = "done";
+    else if (anyActive) newStatus = "active";
+  }
+  await db.update(phases).set({ status: newStatus }).where(eq(phases.id, phaseId));
+}
+
 export async function updateTaskStatus(taskId: string, id: string, status: string) {
   await requireAdmin();
   const allowed = ["todo", "in_progress", "done"];
   if (!allowed.includes(status)) throw new Error("Stato non valido");
   await db.update(tasks).set({ status }).where(eq(tasks.id, taskId));
+
+  // Cascade: recompute parent phase status from all its tasks
+  const taskRow = await db.select({ phase_id: tasks.phase_id }).from(tasks).where(eq(tasks.id, taskId)).limit(1);
+  if (taskRow[0]) await recomputePhaseStatus(taskRow[0].phase_id);
+
   const { path } = await resolveEntity(id);
   revalidatePath(path);
 }
@@ -240,6 +270,35 @@ export async function updatePaymentStatus(paymentId: string, id: string, status:
   revalidatePath(path);
 }
 
+// Rescales payment amounts when the total changes.
+// If the payment has a `percent` field, use it (new plan rows).
+// Legacy rows (percent null) fall back to equal split across all rows.
+async function rescalePayments(projectId: string, newTotal: number): Promise<void> {
+  const projectPayments = await db
+    .select({ id: payments.id, percent: payments.percent })
+    .from(payments)
+    .where(eq(payments.project_id, projectId));
+
+  if (projectPayments.length === 0) return;
+
+  const hasPercent = projectPayments.some((p) => p.percent !== null);
+
+  if (hasPercent) {
+    // New plan: rescale each row by its stored percent
+    for (const p of projectPayments) {
+      const pct = p.percent !== null ? parseFloat(String(p.percent)) : 0;
+      const newAmount = ((newTotal * pct) / 100).toFixed(2);
+      await db.update(payments).set({ amount: newAmount }).where(eq(payments.id, p.id));
+    }
+  } else {
+    // Legacy: equal split across all rows (backward compat)
+    const share = (newTotal / projectPayments.length).toFixed(2);
+    for (const p of projectPayments) {
+      await db.update(payments).set({ amount: share }).where(eq(payments.id, p.id));
+    }
+  }
+}
+
 export async function updateAcceptedTotal(id: string, formData: FormData) {
   await requireAdmin();
   const raw = (formData.get("accepted_total") as string)?.trim();
@@ -253,28 +312,17 @@ export async function updateAcceptedTotal(id: string, formData: FormData) {
     .limit(1);
 
   if (asProject[0]) {
-    // Project context: update projects.accepted_total + this project's payment stubs
+    // Project context: update projects.accepted_total + rescale this project's payments
     await db.update(projects).set({ accepted_total: val.toFixed(2) }).where(eq(projects.id, id));
-    const half = (val / 2).toFixed(2);
-    const projectPayments = await db.select({ id: payments.id })
-      .from(payments).where(eq(payments.project_id, id));
-    for (const p of projectPayments) {
-      await db.update(payments).set({ amount: half }).where(eq(payments.id, p.id));
-    }
+    await rescalePayments(id, val);
     revalidatePath(`/admin/projects/${id}`);
   } else {
-    // Client context: update clients.accepted_total + all project payment stubs
+    // Client context: update clients.accepted_total + rescale all project payments
     await db.update(clients).set({ accepted_total: val.toFixed(2) }).where(eq(clients.id, id));
     const projectRows = await db.select({ id: projects.id })
       .from(projects).where(eq(projects.client_id, id));
-    if (projectRows.length > 0) {
-      const projectIds = projectRows.map((p) => p.id);
-      const half = (val / 2).toFixed(2);
-      const paymentsRows = await db.select()
-        .from(payments).where(inArray(payments.project_id, projectIds));
-      for (const p of paymentsRows) {
-        await db.update(payments).set({ amount: half }).where(eq(payments.id, p.id));
-      }
+    for (const proj of projectRows) {
+      await rescalePayments(proj.id, val);
     }
     revalidatePath(`/admin/clients/${id}`);
   }