diff --git a/docs/plans/2026-03-11-tableau-de-bord-travail.md b/docs/plans/2026-03-11-tableau-de-bord-travail.md
new file mode 100644
index 0000000..884c4be
--- /dev/null
+++ b/docs/plans/2026-03-11-tableau-de-bord-travail.md
@@ -0,0 +1,1644 @@
+# Tableau de bord temps de travail — Plan d'implémentation
+
+> **For Claude:** REQUIRED SUB-SKILL: Use superpowers:executing-plans to implement this plan task-by-task.
+
+**Goal:** Application web Flask auto-hébergée pour tracer le temps de travail quotidien, les déplacements domicile-travail (CO2, frais réels fiscaux) et le solde congés/RTT.
+
+**Architecture:** Flask avec SQLAlchemy/SQLite pour la persistance, HTMX pour les interactions dynamiques sans JS custom, Tailwind CSS (CDN) pour le style mobile-first. Configuration véhicules/trajets/barème fiscal dans un fichier TOML rechargé au démarrage.
+
+**Tech Stack:** Python 3.12+, Flask, SQLAlchemy, tomllib (stdlib), pytest, pytest-flask, Gunicorn, HTMX, Tailwind CSS CDN
+
+---
+
+## Référence design
+
+Voir `docs/plans/2026-03-11-tableau-de-bord-travail-design.md` pour le détail complet.
+
+**Types de journées :** `WORK | TT | GARDE | ASTREINTE | FORMATION | RTT | CONGE | MALADE | FERIE`
+
+**Référence horaire :** 7h45/jour, 38h45/semaine, GARDE = 10h (9h-19h)
+
+**Types sans déplacement :** `TT, MALADE, CONGE, RTT, FERIE`
+
+---
+
+## Structure cible
+
+```
+tableau-de-bord/
+├── app/
+│   ├── __init__.py
+│   ├── models.py
+│   ├── config_loader.py
+│   ├── business/
+│   │   ├── __init__.py
+│   │   ├── time_calc.py
+│   │   ├── travel_calc.py
+│   │   └── leave_calc.py
+│   └── routes/
+│       ├── __init__.py
+│       ├── dashboard.py
+│       ├── entries.py
+│       └── reports.py
+│   └── templates/
+│       ├── base.html
+│       ├── dashboard.html
+│       ├── entry_form.html
+│       ├── entry_list.html
+│       └── reports.html
+├── tests/
+│   ├── conftest.py
+│   ├── test_config_loader.py
+│   ├── test_time_calc.py
+│   ├── test_travel_calc.py
+│   └── test_leave_calc.py
+├── config.toml
+├── requirements.txt
+└── run.py
+```
+
+---
+
+## Task 1 : Setup du projet
+
+**Files:**
+- Create: `requirements.txt`
+- Create: `run.py`
+- Create: `app/__init__.py`
+- Create: `tests/conftest.py`
+
+**Step 1: Créer `requirements.txt`**
+
+```
+flask>=3.0
+flask-sqlalchemy>=3.1
+pytest>=8.0
+pytest-flask>=1.3
+gunicorn>=22.0
+```
+
+**Step 2: Créer `run.py`**
+
+```python
+from app import create_app
+
+app = create_app()
+
+if __name__ == "__main__":
+    app.run(debug=True)
+```
+
+**Step 3: Créer `app/__init__.py`**
+
+```python
+from flask import Flask
+from flask_sqlalchemy import SQLAlchemy
+import tomllib
+import os
+
+db = SQLAlchemy()
+
+
+def create_app(config_path=None):
+    app = Flask(__name__, instance_relative_config=True)
+
+    os.makedirs(app.instance_path, exist_ok=True)
+
+    app.config["SQLALCHEMY_DATABASE_URI"] = f"sqlite:///{os.path.join(app.instance_path, 'worklog.db')}"
+    app.config["SQLALCHEMY_TRACK_MODIFICATIONS"] = False
+    app.config["SECRET_KEY"] = os.environ.get("SECRET_KEY", "dev-secret-change-in-prod")
+
+    # Load TOML config
+    if config_path is None:
+        config_path = os.path.join(os.path.dirname(app.root_path), "config.toml")
+    if os.path.exists(config_path):
+        with open(config_path, "rb") as f:
+            app.config["TOML"] = tomllib.load(f)
+    else:
+        app.config["TOML"] = {}
+
+    db.init_app(app)
+
+    from app.routes.dashboard import bp as dashboard_bp
+    from app.routes.entries import bp as entries_bp
+    from app.routes.reports import bp as reports_bp
+    app.register_blueprint(dashboard_bp)
+    app.register_blueprint(entries_bp)
+    app.register_blueprint(reports_bp)
+
+    with app.app_context():
+        db.create_all()
+
+    return app
+```
+
+**Step 4: Créer `tests/conftest.py`**
+
+```python
+import pytest
+from app import create_app, db as _db
+import tempfile, os
+
+
+@pytest.fixture
+def app(tmp_path):
+    config_path = tmp_path / "config.toml"
+    config_path.write_text("""
+[vehicles.voiture]
+name = "Peugeot 308"
+fuel = "diesel"
+co2_per_km = 142
+cv = 5
+
+[vehicles.velo]
+name = "Vélo"
+fuel = "none"
+co2_per_km = 0
+
+[journeys.voiture_seule]
+name = "Voiture seule"
+distances = { voiture = 25 }
+
+[journeys.voiture_velo]
+name = "Voiture + Vélo"
+distances = { voiture = 14, velo = 8 }
+
+[journeys.velo_seul]
+name = "Vélo seul"
+distances = { velo = 24 }
+
+[bareme_kilometrique.2025.cv_5.tranches]
+data = [
+  { km_max = 3000, taux = 0.548, forfait = 0 },
+  { km_max = 6000, taux = 0.316, forfait = 699 },
+  { km_max = 0,    taux = 0.364, forfait = 0 },
+]
+""", encoding="utf-8")
+
+    application = create_app(config_path=str(config_path))
+    application.config["TESTING"] = True
+    application.config["SQLALCHEMY_DATABASE_URI"] = "sqlite:///:memory:"
+
+    with application.app_context():
+        _db.create_all()
+        yield application
+        _db.drop_all()
+
+
+@pytest.fixture
+def client(app):
+    return app.test_client()
+```
+
+**Step 5: Installer les dépendances**
+
+```bash
+pip install -r requirements.txt
+```
+
+**Step 6: Vérifier que Flask démarre**
+
+```bash
+python run.py
+```
+Expected: serveur démarré sur http://127.0.0.1:5000
+
+**Step 7: Commit**
+
+```bash
+git add requirements.txt run.py app/ tests/
+git commit -m "feat: initial Flask project setup with factory pattern"
+```
+
+---
+
+## Task 2 : Configuration TOML + fichier exemple
+
+**Files:**
+- Create: `config.toml`
+- Create: `app/config_loader.py`
+- Create: `tests/test_config_loader.py`
+
+**Step 1: Créer `config.toml`**
+
+```toml
+[vehicles.voiture]
+name = "Peugeot 308"
+fuel = "diesel"
+co2_per_km = 142
+cv = 5
+
+[vehicles.velo]
+name = "Vélo"
+fuel = "none"
+co2_per_km = 0
+
+[journeys.voiture_seule]
+name = "Voiture seule"
+distances = { voiture = 25 }
+
+[journeys.voiture_velo]
+name = "Voiture + Vélo"
+distances = { voiture = 14, velo = 8 }
+
+[journeys.velo_seul]
+name = "Vélo seul"
+distances = { velo = 24 }
+
+# Barème kilométrique officiel.
+# km_max = 0 signifie "pas de limite" (dernière tranche).
+# Formule : frais = km * taux + forfait
+
+[bareme_kilometrique.2025.cv_5]
+[[bareme_kilometrique.2025.cv_5.tranches]]
+km_max = 3000
+taux = 0.548
+forfait = 0
+
+[[bareme_kilometrique.2025.cv_5.tranches]]
+km_max = 6000
+taux = 0.316
+forfait = 699
+
+[[bareme_kilometrique.2025.cv_5.tranches]]
+km_max = 0
+taux = 0.364
+forfait = 0
+
+[bareme_kilometrique.2025.cv_6_7]
+[[bareme_kilometrique.2025.cv_6_7.tranches]]
+km_max = 3000
+taux = 0.655
+forfait = 0
+
+[[bareme_kilometrique.2025.cv_6_7.tranches]]
+km_max = 6000
+taux = 0.374
+forfait = 836
+
+[[bareme_kilometrique.2025.cv_6_7.tranches]]
+km_max = 0
+taux = 0.435
+forfait = 0
+```
+
+**Step 2: Créer `app/config_loader.py`**
+
+```python
+from flask import current_app
+
+
+def get_vehicles():
+    """Retourne le dict des véhicules depuis la config TOML."""
+    return current_app.config.get("TOML", {}).get("vehicles", {})
+
+
+def get_journeys():
+    """Retourne le dict des profils de trajet depuis la config TOML."""
+    return current_app.config.get("TOML", {}).get("journeys", {})
+
+
+def get_bareme(year: int, cv: int) -> list[dict]:
+    """
+    Retourne les tranches du barème kilométrique pour une année et une puissance fiscale.
+    cv : puissance fiscale (ex: 5 → clé 'cv_5', 6 ou 7 → clé 'cv_6_7')
+    Retourne [] si non trouvé.
+    """
+    bareme = current_app.config.get("TOML", {}).get("bareme_kilometrique", {})
+    year_data = bareme.get(str(year), {})
+
+    if cv <= 5:
+        key = "cv_5"
+    elif cv <= 7:
+        key = "cv_6_7"
+    elif cv <= 9:
+        key = "cv_8_9"
+    else:
+        key = "cv_10_11"
+
+    return year_data.get(key, {}).get("tranches", [])
+
+
+def day_types_without_journey():
+    """Types de journées sans déplacement domicile-travail."""
+    return {"TT", "MALADE", "CONGE", "RTT", "FERIE"}
+```
+
+**Step 3: Écrire les tests `tests/test_config_loader.py`**
+
+```python
+def test_get_vehicles_returns_configured_vehicles(app):
+    with app.app_context():
+        from app.config_loader import get_vehicles
+        vehicles = get_vehicles()
+        assert "voiture" in vehicles
+        assert vehicles["voiture"]["co2_per_km"] == 142
+
+
+def test_get_journeys_returns_profiles(app):
+    with app.app_context():
+        from app.config_loader import get_journeys
+        journeys = get_journeys()
+        assert "voiture_seule" in journeys
+        assert journeys["voiture_seule"]["distances"]["voiture"] == 25
+
+
+def test_get_bareme_returns_tranches(app):
+    with app.app_context():
+        from app.config_loader import get_bareme
+        tranches = get_bareme(2025, 5)
+        assert len(tranches) == 3
+        assert tranches[0]["taux"] == 0.548
+
+
+def test_day_types_without_journey(app):
+    with app.app_context():
+        from app.config_loader import day_types_without_journey
+        types = day_types_without_journey()
+        assert "TT" in types
+        assert "WORK" not in types
+```
+
+**Step 4: Lancer les tests**
+
+```bash
+pytest tests/test_config_loader.py -v
+```
+Expected: 4 PASSED
+
+**Step 5: Commit**
+
+```bash
+git add config.toml app/config_loader.py tests/test_config_loader.py
+git commit -m "feat: TOML config loader for vehicles, journeys, and tax scales"
+```
+
+---
+
+## Task 3 : Modèles SQLAlchemy
+
+**Files:**
+- Create: `app/models.py`
+
+**Step 1: Créer `app/models.py`**
+
+```python
+from app import db
+from datetime import date, time, datetime
+from enum import Enum as PyEnum
+import sqlalchemy as sa
+import sqlalchemy.orm as so
+
+
+class DayType(PyEnum):
+    WORK = "WORK"
+    TT = "TT"
+    GARDE = "GARDE"
+    ASTREINTE = "ASTREINTE"
+    FORMATION = "FORMATION"
+    RTT = "RTT"
+    CONGE = "CONGE"
+    MALADE = "MALADE"
+    FERIE = "FERIE"
+
+
+class WorkEntry(db.Model):
+    __tablename__ = "work_entries"
+
+    id: so.Mapped[int] = so.mapped_column(primary_key=True)
+    date: so.Mapped[date] = so.mapped_column(sa.Date, unique=True, nullable=False)
+    journey_profile_id: so.Mapped[str | None] = so.mapped_column(sa.String(64), nullable=True)
+    day_type: so.Mapped[str] = so.mapped_column(sa.String(16), nullable=False, default="WORK")
+    comment: so.Mapped[str | None] = so.mapped_column(sa.Text, nullable=True)
+    created_at: so.Mapped[datetime] = so.mapped_column(sa.DateTime, default=datetime.utcnow)
+    updated_at: so.Mapped[datetime] = so.mapped_column(
+        sa.DateTime, default=datetime.utcnow, onupdate=datetime.utcnow
+    )
+
+    time_slots: so.Mapped[list["TimeSlot"]] = so.relationship(
+        back_populates="entry", cascade="all, delete-orphan", order_by="TimeSlot.start_time"
+    )
+
+    def total_minutes(self) -> int:
+        """Somme des plages horaires en minutes."""
+        total = 0
+        for slot in self.time_slots:
+            start = slot.start_time.hour * 60 + slot.start_time.minute
+            end = slot.end_time.hour * 60 + slot.end_time.minute
+            # Gère le passage minuit (ex: 22h-00h)
+            if end <= start:
+                end += 24 * 60
+            total += end - start
+        return total
+
+    def total_hours_str(self) -> str:
+        """Retourne le temps total formaté en 'Xh YYmin'."""
+        minutes = self.total_minutes()
+        return f"{minutes // 60}h{minutes % 60:02d}"
+
+
+class TimeSlot(db.Model):
+    __tablename__ = "time_slots"
+
+    id: so.Mapped[int] = so.mapped_column(primary_key=True)
+    entry_id: so.Mapped[int] = so.mapped_column(sa.ForeignKey("work_entries.id"), nullable=False)
+    start_time: so.Mapped[time] = so.mapped_column(sa.Time, nullable=False)
+    end_time: so.Mapped[time] = so.mapped_column(sa.Time, nullable=False)
+
+    entry: so.Mapped["WorkEntry"] = so.relationship(back_populates="time_slots")
+
+
+class LeaveBalance(db.Model):
+    __tablename__ = "leave_balance"
+
+    id: so.Mapped[int] = so.mapped_column(primary_key=True)
+    year: so.Mapped[int] = so.mapped_column(sa.Integer, unique=True, nullable=False)
+    conges_total: so.Mapped[int] = so.mapped_column(sa.Integer, default=28)
+    rtt_total: so.Mapped[int] = so.mapped_column(sa.Integer, default=18)
+```
+
+**Step 2: Vérifier la création des tables**
+
+```bash
+python -c "from app import create_app, db; app = create_app(); app.app_context().push(); db.create_all(); print('Tables OK')"
+```
+Expected: `Tables OK`
+
+**Step 3: Commit**
+
+```bash
+git add app/models.py
+git commit -m "feat: SQLAlchemy models for WorkEntry, TimeSlot, LeaveBalance"
+```
+
+---
+
+## Task 4 : Business logic — calcul du temps
+
+**Files:**
+- Create: `app/business/__init__.py`
+- Create: `app/business/time_calc.py`
+- Create: `tests/test_time_calc.py`
+
+**Step 1: Créer `app/business/__init__.py`** (vide)
+
+**Step 2: Écrire les tests `tests/test_time_calc.py`**
+
+```python
+from app.business.time_calc import (
+    minutes_to_str,
+    work_minutes_reference,
+    week_balance_minutes,
+)
+from datetime import date
+
+
+def test_minutes_to_str_basic():
+    assert minutes_to_str(465) == "7h45"
+
+
+def test_minutes_to_str_zero():
+    assert minutes_to_str(0) == "0h00"
+
+
+def test_work_minutes_reference_normal_day():
+    # WORK, TT, FORMATION, GARDE non-weekend = 7h45 = 465 min
+    assert work_minutes_reference("WORK") == 465
+    assert work_minutes_reference("TT") == 465
+    assert work_minutes_reference("FORMATION") == 465
+
+
+def test_work_minutes_reference_garde():
+    # GARDE = 10h = 600 min
+    assert work_minutes_reference("GARDE") == 600
+
+
+def test_work_minutes_reference_absence():
+    # RTT, CONGE, MALADE, FERIE = 0 (pas de temps à faire)
+    assert work_minutes_reference("RTT") == 0
+    assert work_minutes_reference("CONGE") == 0
+    assert work_minutes_reference("MALADE") == 0
+    assert work_minutes_reference("FERIE") == 0
+
+
+def test_week_balance_positive():
+    # 40h travaillées vs 38h45 référence = +75 min
+    balance = week_balance_minutes(actual_minutes=2400, reference_minutes=2325)
+    assert balance == 75
+
+
+def test_week_balance_negative():
+    balance = week_balance_minutes(actual_minutes=2200, reference_minutes=2325)
+    assert balance == -125
+```
+
+**Step 3: Lancer les tests pour vérifier qu'ils échouent**
+
+```bash
+pytest tests/test_time_calc.py -v
+```
+Expected: ImportError ou FAILED
+
+**Step 4: Créer `app/business/time_calc.py`**
+
+```python
+def minutes_to_str(minutes: int) -> str:
+    """Convertit des minutes en chaîne 'Xh YY'."""
+    sign = "-" if minutes < 0 else ""
+    minutes = abs(minutes)
+    return f"{sign}{minutes // 60}h{minutes % 60:02d}"
+
+
+# Minutes de référence par type de journée
+_REFERENCE_MINUTES = {
+    "WORK": 465,       # 7h45
+    "TT": 465,
+    "FORMATION": 465,
+    "GARDE": 600,      # 10h (9h-19h)
+    "ASTREINTE": 0,    # variable selon time_slots
+    "RTT": 0,
+    "CONGE": 0,
+    "MALADE": 0,
+    "FERIE": 0,
+}
+
+
+def work_minutes_reference(day_type: str) -> int:
+    """Retourne le nombre de minutes de référence pour un type de journée."""
+    return _REFERENCE_MINUTES.get(day_type, 465)
+
+
+def week_balance_minutes(actual_minutes: int, reference_minutes: int) -> int:
+    """Retourne l'écart en minutes entre temps réel et référence."""
+    return actual_minutes - reference_minutes
+```
+
+**Step 5: Lancer les tests**
+
+```bash
+pytest tests/test_time_calc.py -v
+```
+Expected: 7 PASSED
+
+**Step 6: Commit**
+
+```bash
+git add app/business/ tests/test_time_calc.py
+git commit -m "feat: time calculation business logic"
+```
+
+---
+
+## Task 5 : Business logic — calcul déplacements (km, CO2, frais réels)
+
+**Files:**
+- Create: `app/business/travel_calc.py`
+- Create: `tests/test_travel_calc.py`
+
+**Step 1: Écrire les tests `tests/test_travel_calc.py`**
+
+```python
+from app.business.travel_calc import (
+    compute_km_for_entry,
+    compute_co2_grams,
+    compute_frais_reels,
+)
+
+
+VEHICLES = {
+    "voiture": {"co2_per_km": 142, "cv": 5},
+    "velo": {"co2_per_km": 0},
+}
+
+JOURNEYS = {
+    "voiture_seule": {"distances": {"voiture": 25}},
+    "voiture_velo": {"distances": {"voiture": 14, "velo": 8}},
+    "velo_seul": {"distances": {"velo": 24}},
+}
+
+TRANCHES_CV5 = [
+    {"km_max": 3000, "taux": 0.548, "forfait": 0},
+    {"km_max": 6000, "taux": 0.316, "forfait": 699},
+    {"km_max": 0,    "taux": 0.364, "forfait": 0},
+]
+
+
+def test_compute_km_voiture_seule():
+    km = compute_km_for_entry("voiture_seule", JOURNEYS)
+    assert km == {"voiture": 25}
+
+
+def test_compute_km_voiture_velo():
+    km = compute_km_for_entry("voiture_velo", JOURNEYS)
+    assert km == {"voiture": 14, "velo": 8}
+
+
+def test_compute_km_no_journey():
+    km = compute_km_for_entry(None, JOURNEYS)
+    assert km == {}
+
+
+def test_compute_co2_voiture():
+    co2 = compute_co2_grams({"voiture": 25}, VEHICLES)
+    assert co2 == 25 * 142  # 3550g
+
+
+def test_compute_co2_velo():
+    co2 = compute_co2_grams({"velo": 24}, VEHICLES)
+    assert co2 == 0
+
+
+def test_frais_reels_tranche1():
+    # 2000 km → tranche 1 → 2000 * 0.548 = 1096€
+    result = compute_frais_reels(2000, TRANCHES_CV5)
+    assert abs(result - 1096.0) < 0.01
+
+
+def test_frais_reels_tranche2():
+    # 4000 km → tranche 2 → 4000 * 0.316 + 699 = 1963€
+    result = compute_frais_reels(4000, TRANCHES_CV5)
+    assert abs(result - 1963.0) < 0.01
+
+
+def test_frais_reels_tranche3():
+    # 7000 km → tranche 3 → 7000 * 0.364 = 2548€
+    result = compute_frais_reels(7000, TRANCHES_CV5)
+    assert abs(result - 2548.0) < 0.01
+```
+
+**Step 2: Lancer pour vérifier l'échec**
+
+```bash
+pytest tests/test_travel_calc.py -v
+```
+Expected: ImportError
+
+**Step 3: Créer `app/business/travel_calc.py`**
+
+```python
+def compute_km_for_entry(journey_profile_id: str | None, journeys: dict) -> dict[str, int]:
+    """
+    Retourne un dict {vehicle_id: km} pour un profil de trajet donné.
+    Retourne {} si pas de profil (TT, CONGE, etc.).
+    """
+    if not journey_profile_id:
+        return {}
+    profile = journeys.get(journey_profile_id, {})
+    return dict(profile.get("distances", {}))
+
+
+def compute_co2_grams(km_by_vehicle: dict[str, int], vehicles: dict) -> float:
+    """Calcule le CO2 total en grammes pour un dict {vehicle_id: km}."""
+    total = 0.0
+    for vehicle_id, km in km_by_vehicle.items():
+        vehicle = vehicles.get(vehicle_id, {})
+        co2 = vehicle.get("co2_per_km", 0)
+        total += km * co2
+    return total
+
+
+def compute_frais_reels(total_km_voiture: float, tranches: list[dict]) -> float:
+    """
+    Calcule les frais réels fiscaux selon le barème kilométrique.
+    Formule : km * taux + forfait pour la tranche applicable.
+    km_max = 0 signifie "pas de limite" (dernière tranche).
+    """
+    if not tranches or total_km_voiture <= 0:
+        return 0.0
+
+    for tranche in tranches:
+        km_max = tranche["km_max"]
+        if km_max == 0 or total_km_voiture <= km_max:
+            return total_km_voiture * tranche["taux"] + tranche.get("forfait", 0)
+
+    # Fallback : dernière tranche
+    last = tranches[-1]
+    return total_km_voiture * last["taux"] + last.get("forfait", 0)
+```
+
+**Step 4: Lancer les tests**
+
+```bash
+pytest tests/test_travel_calc.py -v
+```
+Expected: 7 PASSED
+
+**Step 5: Commit**
+
+```bash
+git add app/business/travel_calc.py tests/test_travel_calc.py
+git commit -m "feat: travel calculation (km, CO2, frais réels fiscaux)"
+```
+
+---
+
+## Task 6 : Business logic — solde congés/RTT
+
+**Files:**
+- Create: `app/business/leave_calc.py`
+- Create: `tests/test_leave_calc.py`
+
+**Step 1: Écrire les tests `tests/test_leave_calc.py`**
+
+```python
+from app.business.leave_calc import compute_leave_used, get_or_create_balance
+from app.models import WorkEntry, LeaveBalance
+from app import db
+from datetime import date
+
+
+def test_compute_leave_used_conges(app):
+    with app.app_context():
+        entries = [
+            WorkEntry(date=date(2025, 1, 6), day_type="CONGE"),
+            WorkEntry(date=date(2025, 1, 7), day_type="CONGE"),
+            WorkEntry(date=date(2025, 1, 8), day_type="RTT"),
+            WorkEntry(date=date(2025, 1, 9), day_type="WORK"),
+        ]
+        for e in entries:
+            db.session.add(e)
+        db.session.commit()
+
+        used = compute_leave_used(2025)
+        assert used["conges"] == 2
+        assert used["rtt"] == 1
+
+
+def test_get_or_create_balance_creates_default(app):
+    with app.app_context():
+        balance = get_or_create_balance(2025)
+        assert balance.year == 2025
+        assert balance.conges_total == 28
+        assert balance.rtt_total == 18
+
+
+def test_get_or_create_balance_returns_existing(app):
+    with app.app_context():
+        existing = LeaveBalance(year=2025, conges_total=25, rtt_total=15)
+        db.session.add(existing)
+        db.session.commit()
+
+        balance = get_or_create_balance(2025)
+        assert balance.conges_total == 25
+        assert balance.rtt_total == 15
+```
+
+**Step 2: Lancer pour vérifier l'échec**
+
+```bash
+pytest tests/test_leave_calc.py -v
+```
+Expected: ImportError
+
+**Step 3: Créer `app/business/leave_calc.py`**
+
+```python
+from app import db
+from app.models import WorkEntry, LeaveBalance
+import sqlalchemy as sa
+from datetime import date
+
+
+def compute_leave_used(year: int) -> dict[str, int]:
+    """
+    Calcule dynamiquement les congés et RTT utilisés pour une année donnée.
+    Retourne {"conges": N, "rtt": N}.
+    """
+    start = date(year, 1, 1)
+    end = date(year, 12, 31)
+
+    conges = db.session.scalar(
+        sa.select(sa.func.count()).where(
+            WorkEntry.date.between(start, end),
+            WorkEntry.day_type == "CONGE",
+        )
+    ) or 0
+
+    rtt = db.session.scalar(
+        sa.select(sa.func.count()).where(
+            WorkEntry.date.between(start, end),
+            WorkEntry.day_type == "RTT",
+        )
+    ) or 0
+
+    return {"conges": conges, "rtt": rtt}
+
+
+def get_or_create_balance(year: int) -> LeaveBalance:
+    """Récupère ou crée un solde de congés pour l'année donnée."""
+    balance = db.session.scalar(
+        sa.select(LeaveBalance).where(LeaveBalance.year == year)
+    )
+    if balance is None:
+        balance = LeaveBalance(year=year)
+        db.session.add(balance)
+        db.session.commit()
+    return balance
+```
+
+**Step 4: Lancer les tests**
+
+```bash
+pytest tests/test_leave_calc.py -v
+```
+Expected: 3 PASSED
+
+**Step 5: Lancer tous les tests**
+
+```bash
+pytest -v
+```
+Expected: tous PASSED
+
+**Step 6: Commit**
+
+```bash
+git add app/business/leave_calc.py tests/test_leave_calc.py
+git commit -m "feat: leave balance calculation (congés/RTT)"
+```
+
+---
+
+## Task 7 : Routes + templates de base
+
+**Files:**
+- Create: `app/routes/__init__.py`
+- Create: `app/routes/dashboard.py`
+- Create: `app/routes/entries.py`
+- Create: `app/routes/reports.py`
+- Create: `app/templates/base.html`
+
+**Step 1: Créer `app/routes/__init__.py`** (vide)
+
+**Step 2: Créer `app/templates/base.html`**
+
+```html
+<!DOCTYPE html>
+<html lang="fr">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>{% block title %}Tableau de bord{% endblock %}</title>
+    <script src="https://cdn.tailwindcss.com"></script>
+    <script src="https://unpkg.com/htmx.org@1.9.12"></script>
+</head>
+<body class="bg-gray-100 min-h-screen">
+    <nav class="bg-blue-700 text-white px-4 py-3 flex items-center justify-between">
+        <a href="/" class="font-bold text-lg">⏱ Temps de travail</a>
+        <div class="flex gap-4 text-sm">
+            <a href="/entries/new" class="hover:underline">+ Saisir</a>
+            <a href="/entries" class="hover:underline">Historique</a>
+            <a href="/reports" class="hover:underline">Rapports</a>
+        </div>
+    </nav>
+    <main class="max-w-2xl mx-auto px-4 py-6">
+        {% with messages = get_flashed_messages(with_categories=true) %}
+          {% for category, message in messages %}
+            <div class="mb-4 p-3 rounded {% if category == 'error' %}bg-red-100 text-red-800{% else %}bg-green-100 text-green-800{% endif %}">
+              {{ message }}
+            </div>
+          {% endfor %}
+        {% endwith %}
+        {% block content %}{% endblock %}
+    </main>
+</body>
+</html>
+```
+
+**Step 3: Créer `app/routes/dashboard.py`** (stub)
+
+```python
+from flask import Blueprint, render_template
+from datetime import date, timedelta
+import sqlalchemy as sa
+from app import db
+from app.models import WorkEntry, LeaveBalance
+from app.business.time_calc import minutes_to_str, work_minutes_reference
+from app.business.travel_calc import compute_km_for_entry, compute_co2_grams
+from app.business.leave_calc import compute_leave_used, get_or_create_balance
+from app.config_loader import get_vehicles, get_journeys
+
+bp = Blueprint("dashboard", __name__)
+
+
+@bp.route("/")
+def index():
+    today = date.today()
+    year = today.year
+
+    # Semaine courante (lun-dim)
+    monday = today - timedelta(days=today.weekday())
+    sunday = monday + timedelta(days=6)
+    week_entries = db.session.scalars(
+        sa.select(WorkEntry).where(WorkEntry.date.between(monday, sunday))
+    ).all()
+
+    week_actual = sum(e.total_minutes() for e in week_entries)
+    week_ref = sum(work_minutes_reference(e.day_type) for e in week_entries)
+    week_balance = week_actual - week_ref
+
+    # Mois courant
+    month_start = today.replace(day=1)
+    month_entries = db.session.scalars(
+        sa.select(WorkEntry).where(WorkEntry.date.between(month_start, today))
+    ).all()
+
+    vehicles = get_vehicles()
+    journeys = get_journeys()
+
+    month_km = {}
+    month_co2 = 0.0
+    for entry in month_entries:
+        km = compute_km_for_entry(entry.journey_profile_id, journeys)
+        for v, d in km.items():
+            month_km[v] = month_km.get(v, 0) + d
+        month_co2 += compute_co2_grams(km, vehicles)
+
+    # Solde congés/RTT
+    balance = get_or_create_balance(year)
+    used = compute_leave_used(year)
+
+    # Saisie du jour
+    today_entry = db.session.scalar(
+        sa.select(WorkEntry).where(WorkEntry.date == today)
+    )
+
+    return render_template(
+        "dashboard.html",
+        today=today,
+        today_entry=today_entry,
+        journeys=journeys,
+        week_actual_str=minutes_to_str(week_actual),
+        week_balance=week_balance,
+        week_balance_str=minutes_to_str(abs(week_balance)),
+        month_km=month_km,
+        month_co2_kg=round(month_co2 / 1000, 2),
+        balance=balance,
+        used=used,
+    )
+```
+
+**Step 4: Créer `app/routes/entries.py`** (stub minimal)
+
+```python
+from flask import Blueprint, render_template, request, redirect, url_for, flash
+from datetime import date, time
+import sqlalchemy as sa
+from app import db
+from app.models import WorkEntry, TimeSlot
+from app.config_loader import get_journeys, day_types_without_journey
+
+bp = Blueprint("entries", __name__, url_prefix="/entries")
+
+DAY_TYPES = [
+    ("WORK", "Travail"),
+    ("TT", "Télétravail"),
+    ("GARDE", "Garde"),
+    ("ASTREINTE", "Astreinte"),
+    ("FORMATION", "Formation"),
+    ("RTT", "RTT"),
+    ("CONGE", "Congé"),
+    ("MALADE", "Maladie"),
+    ("FERIE", "Férié"),
+]
+
+
+@bp.route("/")
+def list_entries():
+    entries = db.session.scalars(
+        sa.select(WorkEntry).order_by(WorkEntry.date.desc())
+    ).all()
+    return render_template("entry_list.html", entries=entries)
+
+
+@bp.route("/new", methods=["GET", "POST"])
+@bp.route("/<int:entry_id>/edit", methods=["GET", "POST"])
+def entry_form(entry_id=None):
+    entry = None
+    if entry_id:
+        entry = db.session.get(WorkEntry, entry_id)
+        if not entry:
+            flash("Entrée introuvable.", "error")
+            return redirect(url_for("entries.list_entries"))
+
+    if request.method == "POST":
+        entry_date = date.fromisoformat(request.form["date"])
+        day_type = request.form["day_type"]
+        journey_profile_id = request.form.get("journey_profile_id") or None
+        comment = request.form.get("comment") or None
+
+        # Si type sans déplacement, on ignore le profil
+        if day_type in day_types_without_journey():
+            journey_profile_id = None
+
+        if entry is None:
+            existing = db.session.scalar(
+                sa.select(WorkEntry).where(WorkEntry.date == entry_date)
+            )
+            if existing:
+                flash(f"Une entrée existe déjà pour le {entry_date}.", "error")
+                return redirect(url_for("entries.entry_form"))
+            entry = WorkEntry(date=entry_date)
+            db.session.add(entry)
+
+        entry.day_type = day_type
+        entry.journey_profile_id = journey_profile_id
+        entry.comment = comment
+
+        # Supprime les anciens time_slots et recrée
+        for slot in list(entry.time_slots):
+            db.session.delete(slot)
+
+        starts = request.form.getlist("start_time")
+        ends = request.form.getlist("end_time")
+        for s, e in zip(starts, ends):
+            if s and e:
+                db.session.add(TimeSlot(
+                    entry=entry,
+                    start_time=time.fromisoformat(s),
+                    end_time=time.fromisoformat(e),
+                ))
+
+        db.session.commit()
+        flash("Entrée enregistrée.", "success")
+        return redirect(url_for("dashboard.index"))
+
+    journeys = get_journeys()
+    return render_template(
+        "entry_form.html",
+        entry=entry,
+        day_types=DAY_TYPES,
+        journeys=journeys,
+        day_types_without_journey=day_types_without_journey(),
+        today=date.today().isoformat(),
+    )
+
+
+@bp.route("/<int:entry_id>/delete", methods=["POST"])
+def delete_entry(entry_id):
+    entry = db.session.get(WorkEntry, entry_id)
+    if entry:
+        db.session.delete(entry)
+        db.session.commit()
+        flash("Entrée supprimée.", "success")
+    return redirect(url_for("entries.list_entries"))
+```
+
+**Step 5: Créer `app/routes/reports.py`** (stub minimal)
+
+```python
+from flask import Blueprint, render_template, request
+from datetime import date
+import sqlalchemy as sa
+from app import db
+from app.models import WorkEntry
+from app.business.travel_calc import compute_km_for_entry, compute_co2_grams, compute_frais_reels
+from app.config_loader import get_vehicles, get_journeys, get_bareme
+
+bp = Blueprint("reports", __name__, url_prefix="/reports")
+
+
+@bp.route("/")
+def index():
+    year = request.args.get("year", date.today().year, type=int)
+    start = date(year, 1, 1)
+    end = date(year, 12, 31)
+
+    entries = db.session.scalars(
+        sa.select(WorkEntry).where(WorkEntry.date.between(start, end))
+    ).all()
+
+    vehicles = get_vehicles()
+    journeys = get_journeys()
+
+    total_km = {}
+    total_co2 = 0.0
+    for entry in entries:
+        km = compute_km_for_entry(entry.journey_profile_id, journeys)
+        for v, d in km.items():
+            total_km[v] = total_km.get(v, 0) + d
+        total_co2 += compute_co2_grams(km, vehicles)
+
+    # Frais réels : uniquement pour les véhicules motorisés
+    frais_reels = {}
+    for vehicle_id, km in total_km.items():
+        vehicle = vehicles.get(vehicle_id, {})
+        cv = vehicle.get("cv")
+        if cv:
+            tranches = get_bareme(year, cv)
+            frais_reels[vehicle_id] = round(compute_frais_reels(km, tranches), 2)
+
+    return render_template(
+        "reports.html",
+        year=year,
+        total_km=total_km,
+        total_co2_kg=round(total_co2 / 1000, 2),
+        frais_reels=frais_reels,
+        vehicles=vehicles,
+    )
+```
+
+**Step 6: Commit**
+
+```bash
+git add app/routes/ app/templates/base.html
+git commit -m "feat: Flask routes stubs for dashboard, entries, reports"
+```
+
+---
+
+## Task 8 : Templates Jinja2 + HTMX
+
+**Files:**
+- Create: `app/templates/dashboard.html`
+- Create: `app/templates/entry_form.html`
+- Create: `app/templates/entry_list.html`
+- Create: `app/templates/reports.html`
+
+**Step 1: Créer `app/templates/dashboard.html`**
+
+```html
+{% extends "base.html" %}
+{% block title %}Tableau de bord{% endblock %}
+{% block content %}
+
+<!-- Carte aujourd'hui -->
+<div class="bg-white rounded-xl shadow p-4 mb-4">
+  <h2 class="font-semibold text-gray-700 mb-2">
+    Aujourd'hui — {{ today.strftime('%A %d %B %Y') }}
+  </h2>
+  {% if today_entry %}
+    <p class="text-green-700 font-medium">{{ today_entry.day_type }} — {{ today_entry.total_hours_str() }}</p>
+    <a href="/entries/{{ today_entry.id }}/edit"
+       class="mt-2 inline-block text-sm text-blue-600 hover:underline">Modifier</a>
+  {% else %}
+    <a href="/entries/new"
+       class="block w-full text-center bg-blue-600 text-white py-3 rounded-lg font-semibold text-lg hover:bg-blue-700 active:bg-blue-800 transition">
+      + Saisir ma journée
+    </a>
+  {% endif %}
+</div>
+
+<!-- Synthèse semaine -->
+<div class="bg-white rounded-xl shadow p-4 mb-4">
+  <h2 class="font-semibold text-gray-700 mb-3">Semaine courante</h2>
+  <div class="flex justify-between items-center">
+    <span class="text-gray-600">Total</span>
+    <span class="font-bold text-xl">{{ week_actual_str }}</span>
+  </div>
+  <div class="flex justify-between items-center mt-1">
+    <span class="text-gray-600">Écart vs 38h45</span>
+    <span class="font-medium {% if week_balance >= 0 %}text-green-600{% else %}text-red-600{% endif %}">
+      {{ '+' if week_balance >= 0 else '-' }}{{ week_balance_str }}
+    </span>
+  </div>
+</div>
+
+<!-- Synthèse mois -->
+<div class="bg-white rounded-xl shadow p-4 mb-4">
+  <h2 class="font-semibold text-gray-700 mb-3">Ce mois</h2>
+  {% for vehicle_id, km in month_km.items() %}
+  <div class="flex justify-between text-sm text-gray-600 mb-1">
+    <span>{{ vehicle_id | capitalize }}</span>
+    <span>{{ km }} km</span>
+  </div>
+  {% endfor %}
+  <div class="flex justify-between text-sm text-gray-600 mt-2">
+    <span>CO₂</span>
+    <span>{{ month_co2_kg }} kg</span>
+  </div>
+</div>
+
+<!-- Solde congés/RTT -->
+<div class="bg-white rounded-xl shadow p-4">
+  <h2 class="font-semibold text-gray-700 mb-3">Congés / RTT</h2>
+  <div class="mb-3">
+    <div class="flex justify-between text-sm mb-1">
+      <span>Congés</span>
+      <span>{{ used.conges }} / {{ balance.conges_total }} j</span>
+    </div>
+    <div class="w-full bg-gray-200 rounded-full h-2">
+      <div class="bg-blue-500 h-2 rounded-full"
+           style="width: {{ [(used.conges / balance.conges_total * 100), 100] | min }}%"></div>
+    </div>
+  </div>
+  <div>
+    <div class="flex justify-between text-sm mb-1">
+      <span>RTT</span>
+      <span>{{ used.rtt }} / {{ balance.rtt_total }} j</span>
+    </div>
+    <div class="w-full bg-gray-200 rounded-full h-2">
+      <div class="bg-purple-500 h-2 rounded-full"
+           style="width: {{ [(used.rtt / balance.rtt_total * 100), 100] | min }}%"></div>
+    </div>
+  </div>
+</div>
+
+{% endblock %}
+```
+
+**Step 2: Créer `app/templates/entry_form.html`**
+
+```html
+{% extends "base.html" %}
+{% block title %}{% if entry %}Modifier{% else %}Nouvelle entrée{% endif %}{% endblock %}
+{% block content %}
+
+<h1 class="text-xl font-bold mb-4">
+  {% if entry %}Modifier le {{ entry.date }}{% else %}Nouvelle journée{% endif %}
+</h1>
+
+<form method="POST" class="space-y-5">
+
+  <!-- Date -->
+  <div>
+    <label class="block text-sm font-medium text-gray-700 mb-1">Date</label>
+    <input type="date" name="date"
+           value="{{ entry.date.isoformat() if entry else today }}"
+           class="w-full border rounded-lg px-3 py-2 text-sm" required>
+  </div>
+
+  <!-- Type de journée -->
+  <div>
+    <label class="block text-sm font-medium text-gray-700 mb-2">Type de journée</label>
+    <div class="grid grid-cols-3 gap-2">
+      {% for value, label in day_types %}
+      <label class="cursor-pointer">
+        <input type="radio" name="day_type" value="{{ value }}"
+               {% if entry and entry.day_type == value %}checked{% elif not entry and value == 'WORK' %}checked{% endif %}
+               class="sr-only peer"
+               hx-on:change="updateJourneyVisibility(this.value)">
+        <div class="text-center text-sm py-2 px-1 rounded-lg border-2 border-gray-200
+                    peer-checked:border-blue-500 peer-checked:bg-blue-50 peer-checked:text-blue-700
+                    hover:border-gray-300 transition">
+          {{ label }}
+        </div>
+      </label>
+      {% endfor %}
+    </div>
+  </div>
+
+  <!-- Profil de trajet -->
+  <div id="journey-section"
+       class="{% if entry and entry.day_type in day_types_without_journey %}hidden{% endif %}">
+    <label class="block text-sm font-medium text-gray-700 mb-1">Trajet domicile-travail</label>
+    <select name="journey_profile_id"
+            class="w-full border rounded-lg px-3 py-2 text-sm">
+      <option value="">— Pas de déplacement —</option>
+      {% for jid, jdata in journeys.items() %}
+      <option value="{{ jid }}"
+              {% if entry and entry.journey_profile_id == jid %}selected{% endif %}>
+        {{ jdata.name }}
+        ({% for v, d in jdata.distances.items() %}{{ d }} km {{ v }}{% if not loop.last %} + {% endif %}{% endfor %})
+      </option>
+      {% endfor %}
+    </select>
+  </div>
+
+  <!-- Plages horaires -->
+  <div>
+    <label class="block text-sm font-medium text-gray-700 mb-2">Plages horaires</label>
+    <div id="time-slots" class="space-y-2">
+      {% if entry and entry.time_slots %}
+        {% for slot in entry.time_slots %}
+        <div class="flex gap-2 items-center time-slot-row">
+          <input type="time" name="start_time" value="{{ slot.start_time.strftime('%H:%M') }}"
+                 class="flex-1 border rounded-lg px-3 py-2 text-sm" required>
+          <span class="text-gray-400">→</span>
+          <input type="time" name="end_time" value="{{ slot.end_time.strftime('%H:%M') }}"
+                 class="flex-1 border rounded-lg px-3 py-2 text-sm" required>
+          <button type="button" onclick="this.closest('.time-slot-row').remove()"
+                  class="text-red-400 hover:text-red-600 text-xl leading-none">×</button>
+        </div>
+        {% endfor %}
+      {% else %}
+        <div class="flex gap-2 items-center time-slot-row">
+          <input type="time" name="start_time" class="flex-1 border rounded-lg px-3 py-2 text-sm">
+          <span class="text-gray-400">→</span>
+          <input type="time" name="end_time" class="flex-1 border rounded-lg px-3 py-2 text-sm">
+          <button type="button" onclick="this.closest('.time-slot-row').remove()"
+                  class="text-red-400 hover:text-red-600 text-xl leading-none">×</button>
+        </div>
+      {% endif %}
+    </div>
+    <button type="button" onclick="addTimeSlot()"
+            class="mt-2 text-sm text-blue-600 hover:underline">+ Ajouter une plage</button>
+  </div>
+
+  <!-- Commentaire -->
+  <div>
+    <label class="block text-sm font-medium text-gray-700 mb-1">Commentaire</label>
+    <textarea name="comment" rows="2"
+              class="w-full border rounded-lg px-3 py-2 text-sm"
+              placeholder="Formation, déplacement exceptionnel...">{{ entry.comment if entry and entry.comment else '' }}</textarea>
+  </div>
+
+  <!-- Actions -->
+  <div class="flex gap-3 pt-2">
+    <button type="submit"
+            class="flex-1 bg-blue-600 text-white py-3 rounded-lg font-semibold hover:bg-blue-700 transition">
+      Enregistrer
+    </button>
+    <a href="/" class="flex-1 text-center bg-gray-100 text-gray-700 py-3 rounded-lg font-semibold hover:bg-gray-200 transition">
+      Annuler
+    </a>
+  </div>
+</form>
+
+<script>
+const NO_JOURNEY_TYPES = {{ day_types_without_journey | list | tojson }};
+
+function updateJourneyVisibility(dayType) {
+  const section = document.getElementById('journey-section');
+  section.classList.toggle('hidden', NO_JOURNEY_TYPES.includes(dayType));
+}
+
+function addTimeSlot() {
+  const container = document.getElementById('time-slots');
+  const row = document.createElement('div');
+  row.className = 'flex gap-2 items-center time-slot-row';
+  row.innerHTML = `
+    <input type="time" name="start_time" class="flex-1 border rounded-lg px-3 py-2 text-sm">
+    <span class="text-gray-400">→</span>
+    <input type="time" name="end_time" class="flex-1 border rounded-lg px-3 py-2 text-sm">
+    <button type="button" onclick="this.closest('.time-slot-row').remove()"
+            class="text-red-400 hover:text-red-600 text-xl leading-none">×</button>
+  `;
+  container.appendChild(row);
+}
+</script>
+{% endblock %}
+```
+
+**Step 3: Créer `app/templates/entry_list.html`**
+
+```html
+{% extends "base.html" %}
+{% block title %}Historique{% endblock %}
+{% block content %}
+
+<h1 class="text-xl font-bold mb-4">Historique</h1>
+
+{% if not entries %}
+  <p class="text-gray-500 text-center py-8">Aucune entrée pour le moment.</p>
+{% endif %}
+
+<div class="space-y-2">
+{% for entry in entries %}
+<div class="bg-white rounded-xl shadow p-3 flex items-center justify-between">
+  <div>
+    <p class="font-medium text-sm">{{ entry.date.strftime('%a %d %b %Y') }}</p>
+    <p class="text-xs text-gray-500">
+      {{ entry.day_type }}
+      {% if entry.time_slots %} — {{ entry.total_hours_str() }}{% endif %}
+      {% if entry.journey_profile_id %} — {{ entry.journey_profile_id }}{% endif %}
+    </p>
+    {% if entry.comment %}
+    <p class="text-xs text-gray-400 mt-0.5 italic">{{ entry.comment }}</p>
+    {% endif %}
+  </div>
+  <div class="flex gap-2">
+    <a href="/entries/{{ entry.id }}/edit" class="text-blue-500 text-sm hover:underline">Éditer</a>
+    <form method="POST" action="/entries/{{ entry.id }}/delete"
+          onsubmit="return confirm('Supprimer cette entrée ?')">
+      <button class="text-red-400 text-sm hover:underline">Suppr.</button>
+    </form>
+  </div>
+</div>
+{% endfor %}
+</div>
+
+{% endblock %}
+```
+
+**Step 4: Créer `app/templates/reports.html`**
+
+```html
+{% extends "base.html" %}
+{% block title %}Rapports{% endblock %}
+{% block content %}
+
+<div class="flex items-center justify-between mb-4">
+  <h1 class="text-xl font-bold">Rapports {{ year }}</h1>
+  <form method="GET">
+    <select name="year" onchange="this.form.submit()"
+            class="border rounded-lg px-2 py-1 text-sm">
+      {% for y in range(2024, year + 2) %}
+      <option value="{{ y }}" {% if y == year %}selected{% endif %}>{{ y }}</option>
+      {% endfor %}
+    </select>
+  </form>
+</div>
+
+<!-- Kilométrage -->
+<div class="bg-white rounded-xl shadow p-4 mb-4">
+  <h2 class="font-semibold text-gray-700 mb-3">Kilométrage annuel</h2>
+  {% for vehicle_id, km in total_km.items() %}
+  <div class="flex justify-between py-1 border-b border-gray-100 last:border-0">
+    <span class="text-sm text-gray-600">{{ vehicles.get(vehicle_id, {}).get('name', vehicle_id) }}</span>
+    <span class="font-medium text-sm">{{ km }} km</span>
+  </div>
+  {% endfor %}
+  <div class="flex justify-between pt-2 mt-1">
+    <span class="text-sm text-gray-500">CO₂ total</span>
+    <span class="font-medium text-sm">{{ total_co2_kg }} kg</span>
+  </div>
+</div>
+
+<!-- Frais réels -->
+<div class="bg-white rounded-xl shadow p-4 mb-4">
+  <h2 class="font-semibold text-gray-700 mb-1">Frais réels (barème {{ year }})</h2>
+  <p class="text-xs text-gray-400 mb-3">Déduction fiscale estimée — véhicules motorisés uniquement</p>
+  {% for vehicle_id, montant in frais_reels.items() %}
+  <div class="flex justify-between py-1 border-b border-gray-100 last:border-0">
+    <span class="text-sm text-gray-600">{{ vehicles.get(vehicle_id, {}).get('name', vehicle_id) }}</span>
+    <span class="font-bold text-green-700">{{ montant }} €</span>
+  </div>
+  {% endfor %}
+  {% if not frais_reels %}
+  <p class="text-sm text-gray-400">Aucune donnée pour {{ year }}.</p>
+  {% endif %}
+</div>
+
+{% endblock %}
+```
+
+**Step 5: Tester manuellement l'interface**
+
+```bash
+python run.py
+```
+Ouvrir http://127.0.0.1:5000 et vérifier :
+- Dashboard s'affiche sans erreur
+- Formulaire de saisie fonctionne (ajouter/supprimer plages horaires)
+- Liste des entrées s'affiche
+- Rapports s'affichent
+
+**Step 6: Commit**
+
+```bash
+git add app/templates/
+git commit -m "feat: Jinja2 templates for dashboard, entry form, list, and reports"
+```
+
+---
+
+## Task 9 : Configuration Gunicorn + script de démarrage
+
+**Files:**
+- Create: `gunicorn.conf.py`
+- Create: `start.sh`
+
+**Step 1: Créer `gunicorn.conf.py`**
+
+```python
+bind = "127.0.0.1:5000"
+workers = 2
+timeout = 30
+accesslog = "-"
+errorlog = "-"
+```
+
+**Step 2: Créer `start.sh`**
+
+```bash
+#!/bin/bash
+set -e
+export SECRET_KEY="${SECRET_KEY:-changeme-in-production}"
+exec gunicorn -c gunicorn.conf.py "app:create_app()"
+```
+
+**Step 3: Rendre exécutable**
+
+```bash
+chmod +x start.sh
+```
+
+**Step 4: Tester le démarrage**
+
+```bash
+./start.sh
+```
+Expected: Gunicorn démarre sur 127.0.0.1:5000
+
+**Step 5: Commit final**
+
+```bash
+git add gunicorn.conf.py start.sh
+git commit -m "feat: Gunicorn config and startup script"
+```
+
+---
+
+## Task 10 : Tests d'intégration des routes
+
+**Files:**
+- Create: `tests/test_routes.py`
+
+**Step 1: Écrire `tests/test_routes.py`**
+
+```python
+from app.models import WorkEntry, TimeSlot
+from app import db
+from datetime import date, time
+
+
+def test_dashboard_empty(client):
+    response = client.get("/")
+    assert response.status_code == 200
+    assert "Tableau de bord" in response.text
+
+
+def test_entry_form_get(client):
+    response = client.get("/entries/new")
+    assert response.status_code == 200
+    assert "Nouvelle journée" in response.text
+
+
+def test_create_entry(client, app):
+    response = client.post("/entries/new", data={
+        "date": "2025-06-02",
+        "day_type": "WORK",
+        "journey_profile_id": "voiture_seule",
+        "start_time": ["09:00"],
+        "end_time": ["17:45"],
+        "comment": "",
+    }, follow_redirects=True)
+    assert response.status_code == 200
+
+    with app.app_context():
+        entry = db.session.scalar(
+            __import__("sqlalchemy").select(WorkEntry).where(
+                WorkEntry.date == date(2025, 6, 2)
+            )
+        )
+        assert entry is not None
+        assert entry.day_type == "WORK"
+        assert len(entry.time_slots) == 1
+
+
+def test_entry_list(client, app):
+    with app.app_context():
+        entry = WorkEntry(date=date(2025, 6, 3), day_type="TT")
+        db.session.add(entry)
+        db.session.commit()
+
+    response = client.get("/entries/")
+    assert response.status_code == 200
+    assert "TT" in response.text
+
+
+def test_reports_page(client):
+    response = client.get("/reports/")
+    assert response.status_code == 200
+    assert "Rapports" in response.text
+
+
+def test_delete_entry(client, app):
+    with app.app_context():
+        entry = WorkEntry(date=date(2025, 6, 4), day_type="RTT")
+        db.session.add(entry)
+        db.session.commit()
+        entry_id = entry.id
+
+    response = client.post(f"/entries/{entry_id}/delete", follow_redirects=True)
+    assert response.status_code == 200
+
+    with app.app_context():
+        import sqlalchemy as sa
+        deleted = db.session.scalar(
+            sa.select(WorkEntry).where(WorkEntry.id == entry_id)
+        )
+        assert deleted is None
+```
+
+**Step 2: Lancer tous les tests**
+
+```bash
+pytest -v
+```
+Expected: tous PASSED
+
+**Step 3: Commit final**
+
+```bash
+git add tests/test_routes.py
+git commit -m "test: integration tests for all routes"
+```
+
+---
+
+## Résumé des commits
+
+| # | Message | Contenu |
+|---|---|---|
+| 1 | feat: initial Flask project setup | setup, conftest |
+| 2 | feat: TOML config loader | config.toml, config_loader.py |
+| 3 | feat: SQLAlchemy models | models.py |
+| 4 | feat: time calculation business logic | time_calc.py |
+| 5 | feat: travel calculation | travel_calc.py |
+| 6 | feat: leave balance calculation | leave_calc.py |
+| 7 | feat: Flask routes stubs | routes/ |
+| 8 | feat: Jinja2 templates | templates/ |
+| 9 | feat: Gunicorn config | gunicorn.conf.py, start.sh |
+| 10 | test: integration tests | test_routes.py |