Add interactive citizen page with sidebar, display settings, and adaptive CSS

Major rework of the citizen-facing page:
- Chart + sidebar layout (auth/vote/countdown in right sidebar)
- DisplaySettings component (font size, chart density, color palettes)
- Adaptive CSS with clamp() throughout, responsive breakpoints at 480/768/1024
- Baseline charts zoomed on first tier for small consumption detail
- Marginal price chart with dual Y-axes (foyers left, €/m³ right)
- Key metrics banner (5 columns: recettes, palier, prix palier, prix médian, mon prix)
- Client-side p0/impacts computation, draggable median price bar
- Household dots toggle, vote overlay curves
- Auth returns volume_m3, vote captures submitted_at
- Cleaned header nav (removed Accueil/Super Admin for public visitors)
- Terminology: foyer for bills, électeur for votes
- 600m³ added to impact reference volumes
- Realistic seed votes (50 votes, 3 profiles)

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

backend/app/routers/auth.py

@@ -51,6 +51,7 @@ async def citizen_verify(data: CitizenVerify, db: AsyncSession = Depends(get_db)
         access_token=create_citizen_token(household, data.commune_slug),
         role="citizen",
         commune_slug=data.commune_slug,
+        volume_m3=household.volume_m3,
     )
 
 

backend/app/routers/communes.py

@@ -2,13 +2,16 @@ from fastapi import APIRouter, Depends, HTTPException
 from sqlalchemy.ext.asyncio import AsyncSession
 from sqlalchemy import select, delete
 
+from datetime import datetime
+
 from app.database import get_db
 from app.models import Commune, TariffParams, Household, Vote, CommuneContent, AdminUser, admin_commune_table
 from app.schemas import (
     CommuneCreate, CommuneUpdate, CommuneOut,
-    TariffParamsUpdate, TariffParamsOut,
+    TariffParamsUpdate, TariffParamsOut, PublishCurveRequest,
 )
 from app.services.auth_service import get_current_admin, require_super_admin
+from app.engine.pricing import HouseholdData, compute_p0
 
 router = APIRouter()
 
@@ -128,3 +131,49 @@ async def update_params(
     await db.commit()
     await db.refresh(params)
     return params
+
+
+@router.post("/{slug}/params/publish", response_model=TariffParamsOut)
+async def publish_curve(
+    slug: str,
+    data: PublishCurveRequest,
+    db: AsyncSession = Depends(get_db),
+    admin: AdminUser = Depends(get_current_admin),
+):
+    """Admin publishes a Bézier curve as the commune's reference."""
+    result = await db.execute(
+        select(TariffParams).join(Commune).where(Commune.slug == slug)
+    )
+    params = result.scalar_one_or_none()
+    if not params:
+        raise HTTPException(status_code=404, detail="Paramètres introuvables")
+
+    # Compute p0 for this curve
+    hh_result = await db.execute(
+        select(Household).join(Commune).where(Commune.slug == slug)
+    )
+    households_db = hh_result.scalars().all()
+    households = [
+        HouseholdData(volume_m3=h.volume_m3, status=h.status, price_paid_eur=h.price_paid_eur)
+        for h in households_db
+    ]
+
+    p0 = compute_p0(
+        households,
+        recettes=params.recettes, abop=params.abop, abos=params.abos,
+        vinf=data.vinf, vmax=params.vmax, pmax=params.pmax,
+        a=data.a, b=data.b, c=data.c, d=data.d, e=data.e,
+    )
+
+    params.published_vinf = data.vinf
+    params.published_a = data.a
+    params.published_b = data.b
+    params.published_c = data.c
+    params.published_d = data.d
+    params.published_e = data.e
+    params.published_p0 = p0
+    params.published_at = datetime.utcnow()
+
+    await db.commit()
+    await db.refresh(params)
+    return params

backend/app/routers/households.py

@@ -16,6 +16,59 @@ from app.services.import_service import parse_import_file, import_households, ge
 router = APIRouter()
 
 
+@router.get("/communes/{slug}/households/distribution")
+async def household_distribution(
+    slug: str,
+    bucket_size: int = 50,
+    db: AsyncSession = Depends(get_db),
+):
+    """Public: returns consumption distribution as histogram buckets."""
+    result = await db.execute(select(Commune).where(Commune.slug == slug))
+    commune = result.scalar_one_or_none()
+    if not commune:
+        raise HTTPException(status_code=404, detail="Commune introuvable")
+
+    hh_result = await db.execute(
+        select(Household).where(Household.commune_id == commune.id)
+    )
+    households = hh_result.scalars().all()
+
+    if not households:
+        return {"buckets": [], "total": 0, "bucket_size": bucket_size}
+
+    volumes = [h.volume_m3 for h in households]
+    max_vol = max(volumes)
+    num_buckets = int(max_vol // bucket_size) + 1
+
+    buckets = []
+    for i in range(num_buckets):
+        low = i * bucket_size
+        high = (i + 1) * bucket_size
+        count = sum(1 for v in volumes if low <= v < high)
+        if count > 0 or i < num_buckets:
+            buckets.append({"low": low, "high": high, "count": count})
+
+    return {"buckets": buckets, "total": len(households), "bucket_size": bucket_size}
+
+
+@router.get("/communes/{slug}/households/volumes")
+async def household_volumes(
+    slug: str,
+    db: AsyncSession = Depends(get_db),
+):
+    """Public: returns anonymous list of household volumes and statuses for chart display."""
+    result = await db.execute(select(Commune).where(Commune.slug == slug))
+    commune = result.scalar_one_or_none()
+    if not commune:
+        raise HTTPException(status_code=404, detail="Commune introuvable")
+
+    hh_result = await db.execute(
+        select(Household.volume_m3, Household.status).where(Household.commune_id == commune.id)
+    )
+    rows = hh_result.all()
+    return [{"volume_m3": r.volume_m3, "status": r.status} for r in rows]
+
+
 @router.get("/communes/{slug}/households/template")
 async def download_template():
     content = generate_template_csv()

backend/app/routers/votes.py

@@ -103,29 +103,47 @@ async def current_curve(slug: str, db: AsyncSession = Depends(get_db)):
     )
     votes = result.scalars().all()
 
+    # Published curve from admin (if any)
+    published = None
+    if params.published_vinf is not None:
+        published = {
+            "vinf": params.published_vinf,
+            "a": params.published_a,
+            "b": params.published_b,
+            "c": params.published_c,
+            "d": params.published_d,
+            "e": params.published_e,
+            "p0": params.published_p0,
+        }
+
     if not votes:
-        # Return default Bézier curve (a=b=c=d=e=0.5, vinf=vmax/2)
-        default_vinf = params.vmax / 2
+        # Use published curve if available, otherwise default
+        if published:
+            dv, da, db_, dc, dd, de = published["vinf"], published["a"], published["b"], published["c"], published["d"], published["e"]
+        else:
+            dv, da, db_, dc, dd, de = 400, 0.5, 0.5, 0.5, 0.5, 0.5
+
         default_tariff = compute_tariff(
             households,
             recettes=params.recettes, abop=params.abop, abos=params.abos,
-            vinf=default_vinf, vmax=params.vmax, pmax=params.pmax,
-            a=0.5, b=0.5, c=0.5, d=0.5, e=0.5,
+            vinf=dv, vmax=params.vmax, pmax=params.pmax,
+            a=da, b=db_, c=dc, d=dd, e=de,
         )
         _, default_impacts = compute_impacts(
             households,
             recettes=params.recettes, abop=params.abop, abos=params.abos,
-            vinf=default_vinf, vmax=params.vmax, pmax=params.pmax,
-            a=0.5, b=0.5, c=0.5, d=0.5, e=0.5,
+            vinf=dv, vmax=params.vmax, pmax=params.pmax,
+            a=da, b=db_, c=dc, d=dd, e=de,
         )
 
         return {
             "has_votes": False,
             "vote_count": 0,
             "params": tariff_params,
+            "published": published,
             "median": {
-                "vinf": default_vinf, "a": 0.5, "b": 0.5,
-                "c": 0.5, "d": 0.5, "e": 0.5,
+                "vinf": dv, "a": da, "b": db_,
+                "c": dc, "d": dd, "e": de,
             },
             "p0": default_tariff.p0,
             "curve_volumes": default_tariff.curve_volumes,
@@ -166,6 +184,7 @@ async def current_curve(slug: str, db: AsyncSession = Depends(get_db)):
         "has_votes": True,
         "vote_count": len(votes),
         "params": tariff_params,
+        "published": published,
         "median": {
             "vinf": median.vinf,
             "a": median.a,