chore(release): Kanbante 0.19.0 — performance et pilotage (A + C)

- /forecast : une ligne par jalon, tous projets, triée par
  risque (écart décroissant), filtrable, ancres ms-<owner>-<repo>
  pointées par le bloc jalon des cartes du dashboard ; débit
  par projet conservé en tableau compact.
- /health : tableau trié par sévérité (pastille, zombies,
  goulot) ; page détail : sélecteur de projet (health.js).
- Tri des tableaux mutualisé dans static/js/tablesort.js
  (dashboard, forecast, health).

CHANGELOG.md

@@ -1,5 +1,63 @@
 # Changelog
 
+## 0.19.0 — 2026-10-12
+
+### Performance + navigation « Pilotage » (chantiers A + C, décidés par Bruno)
+
+- **Parallélisation (A1)** : les pages inter-projets (dashboard,
+  /health, /forecast, /triage, /wall) attendaient chaque dépôt à
+  la queue leu leu ; elles utilisent maintenant un `asyncio.gather`
+  borné (16) — le patron que /focus appliquait déjà.
+- **Cache stale-while-revalidate (A2)** : les listes Gitea
+  (dépôts, issues, jalons, étoiles) sont servies immédiatement
+  même périmées, et rafraîchies en tâche de fond. Fini le
+  « mur » de rechargement à chaque expiration du cache (30 s) :
+  seul le tout premier chargement après un démarrage paie le
+  coût complet. Les mutations vident le cache et désarment les
+  rafraîchissements en vol (aucune donnée périmée ressuscitée).
+- **Prévisions refondues (C1)** : /forecast devient un tableau de
+  bord des jalons **tous projets** — une ligne par jalon (projet,
+  échéance, progression, ETA, **écart**, débit), triée par risque,
+  filtrable, colonnes triables ; le bloc jalon des cartes du
+  dashboard y pointe directement (ancres). Le débit par projet
+  reste en dessous, en tableau compact.
+- **Santé refondue (C2)** : /health devient un tableau trié par
+  sévérité (pastille, ouvertes, zombies, goulot) ; la page santé
+  d'un projet gagne un **sélecteur de projet** pour basculer sans
+  repasser par l'index. Le tri des tableaux est mutualisé
+  (`static/js/tablesort.js`, dashboard inclus).
+- Mesuré sur l'instance réelle (depuis le réseau de test) :
+  pages chaudes 0,04–0,16 s ; le premier chargement à froid
+  reste de quelques secondes — le chantier B (instantanés
+  d'arrière-plan) demeure le levier pour le supprimer, si voulu.
+
+## 0.18.0 — 2026-10-11
+
+### Nouveautés — vague 2, suite (4 cartes de Bruno)
+- **Activité récente par projet** (#19) : ligne sur la carte du
+  dashboard calculée par UNE requête agrégée sur le journal —
+  « 📈 X fermées · Y déplacements cette semaine », ou « 💤 aucune
+  activité kanban depuis N j » pour les projets endormis.
+- **Actions rapides sur la carte** (#23) : menu ⋯ sur chaque
+  carte — Board, ⚡ Capturer ici (la page capture accepte
+  `?repo=` et pré-remplit le dépôt), Triage du backlog, Santé,
+  Récit de sprint, Gitea. Clavier et tactile soignés (Échap,
+  clic extérieur).
+- **Tri et regroupement** (#21) : tri par activité Gitea,
+  activité kanban, ouvertes ou nom ; regroupement par
+  propriétaire en sections repliables ; préférences mémorisées
+  par navigateur (localStorage).
+- **Vue liste dense** (#22) : bascule Grille/Liste persistée —
+  tableau triable par colonne (Projet, Propriétaire, Ouvertes,
+  En vol, Prochain jalon, Santé, Dernière activité) réutilisant
+  les enrichissements des cartes, mêmes onglets et même filtre.
+
+Note : le lien Triage du menu ⋯ est constant — la taille du
+backlog « stats » du dashboard ne compte que les cartes placées,
+pas le backlog réel ; la page Triage affiche l'état exact.
+
+7 tests ajoutés (185 au total).
+
 ## 0.17.0 — 2026-10-11
 
 ### Nouveautés — vague 2 « Gestion de projets » (4 cartes de Bruno)

app/config.py

@@ -89,7 +89,7 @@ from pathlib import Path
 
 BASE_DIR = Path(__file__).resolve().parent.parent
 
-APP_VERSION = "0.17.0"
+APP_VERSION = "0.19.0"
 
 
 def _env_bool(name: str, default: bool) -> bool:

app/digest.py

@@ -143,7 +143,7 @@ async def _mcp_session(client: httpx.AsyncClient, url: str, token: str) -> None:
         {
             "protocolVersion": MCP_PROTOCOL_VERSION,
             "capabilities": {},
-            "clientInfo": {"name": "kanbante", "version": "0.17.0"},
+            "clientInfo": {"name": "kanbante", "version": "0.19.0"},
         },
         req_id=1,
     )

app/gitea_client.py

@@ -17,8 +17,10 @@ Changes from the 0.1.0 client:
 - .env loading targets the project root only (no hardcoded home path).
 """
 
+import asyncio
 import logging
 import time
+from collections.abc import Awaitable, Callable
 from pathlib import Path
 from typing import Any
 
@@ -60,6 +62,8 @@ class GiteaClient:
         )
         self._user: dict | None = None
         self._cache: dict[str, tuple[float, Any]] = {}
+        self._refreshing: set[str] = set()
+        self._cache_gen = 0
 
     async def aclose(self) -> None:
         await self.client.aclose()
@@ -105,24 +109,62 @@ class GiteaClient:
             page += 1
         return items
 
-    def _cache_get(self, key: str) -> Any | None:
-        if self.cache_ttl <= 0:
-            return None
-        hit = self._cache.get(key)
-        if hit and (time.monotonic() - hit[0]) < self.cache_ttl:
-            return hit[1]
-        return None
-
     def _cache_put(self, key: str, value: Any) -> None:
         if self.cache_ttl > 0:
             self._cache[key] = (time.monotonic(), value)
 
     def _cache_clear(self) -> None:
         self._cache.clear()
+        # Invalidate in-flight background refreshes: a refresh that
+        # started before a mutation must not resurrect stale data.
+        self._cache_gen += 1
+
+    async def _cached_list(
+        self, key: str, fetcher: Callable[[], Awaitable[Any]]
+    ) -> Any:
+        """Stale-while-revalidate cache for list endpoints (0.19.0).
+
+        Fresh (< TTL): serve the cache. Stale: serve the cached
+        value IMMEDIATELY and refresh it in the background (once
+        per key) — the user never waits on Gitea for a page when
+        any earlier answer exists. Absent: fetch and wait.
+        Mutations clear the cache (see _cache_clear), so writes are
+        never hidden by a stale entry.
+        """
+        if self.cache_ttl <= 0:
+            return await fetcher()
+        hit = self._cache.get(key)
+        if hit is not None:
+            if (time.monotonic() - hit[0]) < self.cache_ttl:
+                return hit[1]
+            if key not in self._refreshing:
+                self._refreshing.add(key)
+                asyncio.create_task(
+                    self._refresh_entry(key, fetcher, self._cache_gen)
+                )
+            return hit[1]
+        value = await fetcher()
+        self._cache_put(key, value)
+        return value
+
+    async def _refresh_entry(
+        self,
+        key: str,
+        fetcher: Callable[[], Awaitable[Any]],
+        generation: int,
+    ) -> None:
+        try:
+            value = await fetcher()
+            if generation == self._cache_gen:
+                self._cache_put(key, value)
+        except Exception as exc:
+            logger.debug("background refresh failed for %s: %s", key, exc)
+        finally:
+            self._refreshing.discard(key)
 
     def invalidate_cache(self) -> None:
         """Drop every cached list response (called on webhook events)."""
-        self._cache.clear()
+        self._cache_clear()
 
     # ── API ────────────────────────────────────────────────
 
@@ -141,20 +183,21 @@ class GiteaClient:
         return self._user
 
     async def search_repos(self) -> list[dict]:
-        """All repos visible to the token owner (paginated, cached)."""
-        cached = self._cache_get("search_repos")
-        if cached is not None:
-            return cached
-        params: dict[str, Any] = {}
-        try:
-            user = await self.get_user()
-            if user and user.get("id"):
-                params["uid"] = user["id"]
-        except Exception as exc:  # no/invalid token → public search
-            logger.debug("get_user failed, falling back to public search: %s", exc)
-        repos = await self._get_all_pages("/repos/search", **params)
-        self._cache_put("search_repos", repos)
-        return repos
+        """All repos visible to the token owner (paginated, SWR-cached)."""
+
+        async def _fetch() -> list[dict]:
+            params: dict[str, Any] = {}
+            try:
+                user = await self.get_user()
+                if user and user.get("id"):
+                    params["uid"] = user["id"]
+            except Exception as exc:  # no/invalid token → public search
+                logger.debug(
+                    "get_user failed, falling back to public search: %s", exc
+                )
+            return await self._get_all_pages("/repos/search", **params)
+
+        return await self._cached_list("search_repos", _fetch)
 
     async def get_repo(self, owner: str, repo: str) -> dict:
         return await self._get(f"/repos/{owner}/{repo}")
@@ -178,14 +221,12 @@ class GiteaClient:
         (see app.main._is_issue).
         """
         key = f"issues:{owner}/{repo}:{state}"
-        cached = self._cache_get(key)
-        if cached is not None:
-            return cached
-        issues = await self._get_all_pages(
-            f"/repos/{owner}/{repo}/issues", state=state
+        return await self._cached_list(
+            key,
+            lambda: self._get_all_pages(
+                f"/repos/{owner}/{repo}/issues", state=state
+            ),
         )
-        self._cache_put(key, issues)
-        return issues
 
     async def get_all_issues(
         self, repos: list[dict], state: str = "open"
@@ -308,25 +349,19 @@ class GiteaClient:
         self, owner: str, repo: str, state: str = "open"
     ) -> list[dict]:
         key = f"milestones:{owner}/{repo}:{state}"
-        cached = self._cache_get(key)
-        if cached is not None:
-            return cached
-        milestones = await self._get_all_pages(
-            f"/repos/{owner}/{repo}/milestones", state=state
+        return await self._cached_list(
+            key,
+            lambda: self._get_all_pages(
+                f"/repos/{owner}/{repo}/milestones", state=state
+            ),
         )
-        self._cache_put(key, milestones)
-        return milestones
 
     async def list_starred(self) -> list[dict]:
         """Repos starred by the token user (issue #20: pinning rides
         on Gitea stars — the forge stays the source of truth)."""
-        key = "user:starred"
-        cached = self._cache_get(key)
-        if cached is not None:
-            return cached
-        repos = await self._get_all_pages("/user/starred")
-        self._cache_put(key, repos)
-        return repos
+        return await self._cached_list(
+            "user:starred", lambda: self._get_all_pages("/user/starred")
+        )
 
     async def set_starred(self, owner: str, repo: str, starred: bool) -> None:
         """Star / unstar a repo for the token user."""

app/main.py

@@ -58,6 +58,7 @@ from app.models import (
     get_metrics,
     get_notes,
     get_picks,
+    get_project_activity,
     get_stats,
     init_db,
     log_event,
@@ -377,6 +378,27 @@ def _parse_datetime(value: str | None) -> datetime | None:
         return None
 
 
+async def _parallel_map(items, fn, limit: int = 16) -> list:
+    """Run an async fn over items with bounded concurrency (0.19.0).
+
+    Cross-project pages used to await each repo in sequence, so the
+    page took the SUM of every Gitea round trip. Gathering with a
+    per-call semaphore (created here, bound to the current loop)
+    cuts that to roughly the slowest single repo, without letting
+    a big instance stampede Gitea. Exceptions come back in place —
+    callers decide what a failed repo means for them.
+    """
+    semaphore = asyncio.Semaphore(limit)
+
+    async def _run(item):
+        async with semaphore:
+            return await fn(item)
+
+    return await asyncio.gather(
+        *(_run(item) for item in items), return_exceptions=True
+    )
+
+
 def classify_repos(
     repos: list[dict], now: datetime | None = None
 ) -> tuple[list[dict], list[dict], list[dict]]:
@@ -584,7 +606,7 @@ async def dashboard(request: Request):
     except Exception as exc:  # stars are decoration, never fatal (#20)
         logger.debug("starred list failed: %s", exc)
         starred_names = set()
-    for repo_info in active:
+    async def _enrich_active(repo_info: dict) -> None:
         full_name = repo_info["full_name"]
         owner, _, repo = full_name.partition("/")
         repo_info["forecast_label"] = _repo_forecast_label(
@@ -598,8 +620,28 @@ async def dashboard(request: Request):
             logger.debug("health dot failed for %s: %s", full_name, exc)
             repo_info["health_dot"] = None
         repo_info["starred"] = full_name in starred_names
+
+    await _parallel_map(active, _enrich_active)
     for repo_info in inactive:
         repo_info["starred"] = repo_info["full_name"] in starred_names
+    activity_by_repo = get_project_activity()
+    today_utc = datetime.now(timezone.utc).date()
+    for repo_info in active + inactive + archived:
+        act = activity_by_repo.get(repo_info["full_name"])
+        if act is None:
+            repo_info["activity"] = None
+            continue
+        idle_days = None
+        if act["last_at"]:
+            last_dt = _parse_datetime(act["last_at"])
+            if last_dt is not None:
+                idle_days = (today_utc - last_dt.date()).days
+        repo_info["activity"] = {
+            "closed": act["closed"],
+            "moved": act["moved"],
+            "idle_days": idle_days,
+            "last_at": act["last_at"] or "",
+        }
     for repo_info in active:
         repo_info["home_tab"] = "active"
     for repo_info in inactive:
@@ -994,19 +1036,18 @@ async def triage_picker(request: Request):
     """Triage mode (issue #11): pick a project by its backlog size."""
     repos = await gitea.search_repos()
     active, _inactive, _archived = classify_repos(repos)
-    projects = []
-    for repo_info in active:
+
+    async def _one_triage(repo_info: dict) -> dict | None:
         owner, _, name = repo_info["full_name"].partition("/")
-        try:
-            all_items = await gitea.get_repo_issues(owner, name, state="all")
-        except Exception:
-            continue
+        all_items = await gitea.get_repo_issues(owner, name, state="all")
         columns, _display, _state = _board_columns_for(owner, name, all_items)
         backlog = len(columns["backlog"])
         if backlog:
-            projects.append(
-                {"full_name": repo_info["full_name"], "backlog": backlog}
-            )
+            return {"full_name": repo_info["full_name"], "backlog": backlog}
+        return None
+
+    results = await _parallel_map(active, _one_triage)
+    projects = [r for r in results if isinstance(r, dict)]
     projects.sort(key=lambda p: -p["backlog"])
     return render(request, "triage.html", projects=projects)
 
@@ -1535,30 +1576,52 @@ async def health_index(request: Request):
     """Flow health, global summary (issue #9)."""
     repos = await gitea.search_repos()
     active, _inactive, _archived = classify_repos(repos)
-    projects = []
-    for repo_info in active:
+
+    async def _one_health(repo_info: dict) -> dict:
         owner, _, name = repo_info["full_name"].partition("/")
-        try:
-            projects.append(await _project_health(owner, name))
-        except Exception as exc:
-            logger.warning("Health failed for %s: %s", repo_info["full_name"], exc)
+        return await _project_health(owner, name)
+
+    results = await _parallel_map(active, _one_health)
+    projects = []
+    for repo_info, result in zip(active, results):
+        if isinstance(result, Exception):
+            logger.warning(
+                "Health failed for %s: %s", repo_info["full_name"], result
+            )
+            continue
+        result["dot"] = _health_dot(result)
+        projects.append(result)
+    severity_rank = {"red": 0, "orange": 1, "green": 2}
+    projects.sort(
+        key=lambda p: (
+            severity_rank.get(p["dot"]["level"], 3),
+            -len(p["zombies"]),
+        )
+    )
     return render(request, "health.html", projects=projects)
 
 
 @app.get("/health/{owner}/{repo}", response_class=HTMLResponse)
 async def health_project(request: Request, owner: str, repo: str):
-    """Flow health of one project: dwell per column + zombies."""
+    """Flow health of one project: dwell per column + zombies.
+
+    Passes the active project list so the page can offer a project
+    switcher — no more back-to-the-index round trip (0.19.0, C).
+    """
     repos = await gitea.search_repos()
-    known = {r["full_name"] for r in repos}
-    if f"{owner}/{repo}" not in known:
+    active, _inactive, _archived = classify_repos(repos)
+    project_names = [r["full_name"] for r in active]
+    if f"{owner}/{repo}" not in {r["full_name"] for r in repos}:
         return render(
             request, "health_project.html",
             health=None, full_name=f"{owner}/{repo}",
+            project_names=project_names,
         )
     health = await _project_health(owner, repo)
     return render(
         request, "health_project.html",
         health=health, full_name=f"{owner}/{repo}",
+        project_names=project_names,
     )
 
 
@@ -1585,11 +1648,29 @@ async def standup_page(request: Request):
 
 @app.get("/forecast", response_class=HTMLResponse)
 async def forecast_page(request: Request):
-    """Forecasts (issue #7): real-pace ETAs per project + milestone."""
+    """Forecasts (issue #7; portfolio table in 0.19.0, chantier C).
+
+    One row per open milestone across every active project,
+    sorted by risk (largest ETA-vs-deadline gap first) — the
+    cross-project question the old per-project card wall could
+    not answer without reading everything. Per-project pace
+    (weekly bars + backlog ETA) stays as a compact second table.
+    """
     repos = await gitea.search_repos()
     active, _inactive, _archived = classify_repos(repos)
-    projects = []
-    for repo_info in active:
+
+    async def _fetch_milestones(repo_info: dict) -> list[dict]:
+        owner, _, name = repo_info["full_name"].partition("/")
+        try:
+            return await gitea.get_milestones(owner, name)
+        except Exception:
+            return []
+
+    ms_results = await _parallel_map(active, _fetch_milestones)
+
+    rows: list[dict] = []
+    projects: list[dict] = []
+    for repo_info, ms_list in zip(active, ms_results):
         full = repo_info["full_name"]
         owner, _, name = full.partition("/")
         weekly = forecast_service.weekly_closures(
@@ -1604,50 +1685,100 @@ async def forecast_page(request: Request):
             }
             for b in weekly
         ]
+        stats = forecast_service.throughput_stats(weekly)
         remaining = repo_info.get("open_issues_count") or 0
         est = forecast_service.estimate(remaining, weekly)
-        milestones = []
-        try:
-            ms_list = await gitea.get_milestones(owner, name)
-        except Exception:
-            ms_list = []
-        for ms in ms_list:
-            if ms.get("state") not in (None, "open"):
-                continue
-            rem = ms.get("open_issues") or 0
-            if rem == 0 and not (ms.get("closed_issues") or 0):
-                continue
-            m_est = forecast_service.estimate(rem, weekly)
-            verdict = None
-            due_raw = ms.get("due_on")
-            if m_est and not m_est.get("done") and due_raw:
-                due = _parse_datetime(str(due_raw))
-                if due is not None:
-                    verdict = (
-                        "⚠️ en retard à ce rythme"
-                        if m_est["central"] > due.date()
-                        else "✅ dans les temps à ce rythme"
-                    )
-            milestones.append(
-                {
-                    "title": ms.get("title", ""),
-                    "due_on": (due_raw or "")[:10],
-                    "remaining": rem,
-                    "eta": forecast_service.eta_label(m_est),
-                    "verdict": verdict,
-                }
-            )
         projects.append(
             {
                 "full_name": full,
                 "bars": bars,
-                "stats": forecast_service.throughput_stats(weekly),
+                "stats": stats,
                 "remaining": remaining,
                 "eta_label": forecast_service.eta_label(est),
-                "milestones": milestones,
             }
         )
-    return render(request, "forecast.html", projects=projects)
+        if isinstance(ms_list, Exception):
+            ms_list = []
+        next_title = None
+        next_due = None
+        for ms in ms_list:
+            if ms.get("state") not in (None, "open"):
+                continue
+            rem = ms.get("open_issues") or 0
+            closed_n = ms.get("closed_issues") or 0
+            if rem == 0 and not closed_n:
+                continue
+            total = rem + closed_n
+            m_est = forecast_service.estimate(rem, weekly)
+            due_raw = ms.get("due_on")
+            due_dt = _parse_datetime(str(due_raw)) if due_raw else None
+            due_date = due_dt.date() if due_dt else None
+            gap_days = None
+            verdict = "noeta"
+            if due_date is None:
+                verdict = "nodue"
+            elif m_est and not m_est.get("done"):
+                gap_days = (m_est["central"] - due_date).days
+                verdict = "late" if gap_days > 0 else "ontime"
+            elif m_est and m_est.get("done"):
+                verdict = "ontime"
+            rows.append(
+                {
+                    "project": full,
+                    "owner": owner,
+                    "repo": name,
+                    "title": ms.get("title", ""),
+                    "due_label": (
+                        forecast_service.french_date(due_date, short=True)
+                        if due_date else "—"
+                    ),
+                    "due_sort": due_date.isoformat() if due_date else "9999",
+                    "remaining": rem,
+                    "closed": closed_n,
+                    "total": total,
+                    "pct": round(100 * closed_n / total) if total else 0,
+                    "eta": forecast_service.eta_label(m_est),
+                    "gap_days": gap_days,
+                    "verdict": verdict,
+                    "throughput": stats["avg"] if stats else None,
+                    "anchor": False,
+                }
+            )
+            if (
+                due_date is not None
+                and (next_due is None or due_date < next_due)
+            ):
+                next_due, next_title = due_date, ms.get("title", "")
+        for row in rows:
+            if (
+                row["project"] == full
+                and row["title"] == next_title
+                and next_title is not None
+            ):
+                row["anchor"] = True
+
+    def _risk_key(row: dict):
+        # Late first (worst gap first), then dated on-time by due
+        # date, then no-ETA, then no due date.
+        order = {"late": 0, "ontime": 1, "noeta": 2, "nodue": 3}
+        return (
+            order.get(row["verdict"], 4),
+            -(row["gap_days"] or 0) if row["verdict"] == "late" else 0,
+            row["due_sort"],
+            row["project"],
+            row["title"],
+        )
+
+    rows.sort(key=_risk_key)
+    summary = {
+        "late": sum(1 for r in rows if r["verdict"] == "late"),
+        "ontime": sum(1 for r in rows if r["verdict"] == "ontime"),
+        "total": len(rows),
+    }
+    return render(
+        request, "forecast.html",
+        rows=rows, projects=projects, summary=summary,
+    )
 
 
 @app.get("/focus", response_class=HTMLResponse)
@@ -1720,15 +1851,14 @@ async def _collect_wall_data(only_repo: str | None) -> list[dict]:
                 closed_today.get(event["repo_full_name"], 0) + 1
             )
 
-    slides = []
-    for repo in repos:
+    async def _one_slide(repo: dict) -> dict | None:
         full_name = repo["full_name"]
         owner, _, name = full_name.partition("/")
         try:
             items = await gitea.get_repo_issues(owner, name, state="open")
         except Exception as exc:
             logger.debug("wall: issues failed for %s: %s", full_name, exc)
-            continue
+            return None
         open_issues = [i for i in items if _is_issue(i)]
         _adopt_label_columns(full_name, open_issues, get_board_state(full_name))
         board_state = get_board_state(full_name)
@@ -1750,17 +1880,17 @@ async def _collect_wall_data(only_repo: str | None) -> list[dict]:
                         "aging": days is not None and days >= aging_days,
                     }
                 )
-        slides.append(
-            {
-                "full_name": full_name,
-                "counts": {col: len(columns[col]) for col in KANBAN_COLUMNS},
-                "open_total": len(open_issues),
-                "cards": cards[:9],
-                "cards_total": len(cards),
-                "closed_today": closed_today.get(full_name, 0),
-            }
-        )
-    return slides
+        return {
+            "full_name": full_name,
+            "counts": {col: len(columns[col]) for col in KANBAN_COLUMNS},
+            "open_total": len(open_issues),
+            "cards": cards[:9],
+            "cards_total": len(cards),
+            "closed_today": closed_today.get(full_name, 0),
+        }
+
+    results = await _parallel_map(repos, _one_slide)
+    return [r for r in results if isinstance(r, dict)]
 
 
 @app.get("/wall", response_class=HTMLResponse)
@@ -2305,13 +2435,17 @@ async def api_capture(request: Request):
 
 
 @app.get("/capture", response_class=HTMLResponse)
-async def capture_page(request: Request):
-    """Quick-capture page: form, status and usage instructions."""
+async def capture_page(request: Request, repo: str = ""):
+    """Quick-capture page: form, status and usage instructions.
+
+    `?repo=Owner/name` pre-fills the target repo (issue #23: the
+    project card's quick actions capture straight into a project).
+    """
     settings = get_settings()
     return render(
         request,
         "capture.html",
-        capture_repo=settings.capture_repo,
+        capture_repo=repo.strip() or settings.capture_repo,
         api_enabled=bool(settings.capture_token),
         ntfy_topic=settings.capture_ntfy_topic,
         ntfy_url=settings.ntfy_url,

app/models.py

@@ -368,6 +368,38 @@ def column_entry_times(repo_full_name: str) -> dict[int, str]:
     return {row["issue_number"]: row["entered_at"] for row in rows}
 
 
+def get_project_activity(days: int = 7) -> dict:
+    """Per-repo journal activity in ONE aggregated pass (issue #19).
+
+    For every repo present in the journal: closures and moves of
+    the last `days` days (journal stamps are UTC strings), plus
+    the most recent event ever seen for that repo.
+    """
+    from datetime import datetime, timedelta, timezone
+
+    cutoff = (datetime.now(timezone.utc) - timedelta(days=days)).strftime(
+        "%Y-%m-%d %H:%M:%S"
+    )
+    with get_db() as conn:
+        rows = conn.execute(
+            """
+            SELECT repo_full_name,
+                   SUM(CASE WHEN event_type = 'closed' AND created_at >= ?
+                            THEN 1 ELSE 0 END),
+                   SUM(CASE WHEN event_type = 'moved' AND created_at >= ?
+                            THEN 1 ELSE 0 END),
+                   MAX(created_at)
+            FROM board_events
+            GROUP BY repo_full_name
+            """,
+            (cutoff, cutoff),
+        ).fetchall()
+    return {
+        r[0]: {"closed": r[1] or 0, "moved": r[2] or 0, "last_at": r[3]}
+        for r in rows
+    }
+
+
 def get_metrics(repo_full_name: str | None = None, window_days: int = 30) -> dict:
     """Throughput and cycle time computed from the journal.
 

app/templates/dashboard.html

@@ -24,7 +24,22 @@
         </div>
     </section>
 
-    <main x-data="{ tab: 'active', search: '' }">
+    <script>
+        // État du dashboard (#21/#22) : la vue grille/liste survit au
+        // rechargement (localStorage), lue avant qu'Alpine démarre.
+        function dashState() {
+            var view = 'grid';
+            try { view = localStorage.getItem('kanbante-dash-view') || 'grid'; } catch (e) { /* défaut */ }
+            return {
+                tab: 'active', search: '', view: view,
+                setView: function (v) {
+                    this.view = v;
+                    try { localStorage.setItem('kanbante-dash-view', v); } catch (e) { /* non-fatal */ }
+                }
+            };
+        }
+    </script>
+    <main x-data="dashState()">
         <!-- Tabs: "actif" = mis à jour dans la fenêtre glissante;
              "archivé" = le vrai drapeau Gitea (repo.archived). -->
         <div class="tabs">
@@ -46,10 +61,34 @@
             <kbd class="kbd">/</kbd>
         </div>
 
+        <!-- Outils d'affichage (#21 tri/regroupement, #22 vue liste) :
+             pilotés par dashboard.js, préférences en localStorage. -->
+        <div class="dash-tools">
+            <label class="dash-tool">↕️ Tri
+                <select id="dash-sort">
+                    <option value="default">Par défaut</option>
+                    <option value="updated">Activité Gitea récente</option>
+                    <option value="activity">Activité kanban récente</option>
+                    <option value="open">Issues ouvertes ↓</option>
+                    <option value="name">Nom A → Z</option>
+                </select>
+            </label>
+            <label class="dash-tool dash-tool-check">
+                <input type="checkbox" id="dash-group"> 🗂️ Grouper par propriétaire
+            </label>
+            <div class="dash-view-toggle" role="group" aria-label="Mode d'affichage">
+                <button type="button" :class="{ active: view === 'grid' }" @click="setView('grid')">▦ Grille</button>
+                <button type="button" :class="{ active: view === 'list' }" @click="setView('list')">☰ Liste</button>
+            </div>
+        </div>
+
         {% macro project_card(repo, archived=False) %}
             {% set full = repo.full_name %}
             <div class="project-card{% if archived %} archived{% endif %}"
                  data-full="{{ full }}" data-home="{{ repo.home_tab or '' }}"
+                 data-name="{{ repo.name|lower }}" data-owner="{{ repo.owner.login }}"
+                 data-updated="{{ repo.updated_at }}" data-open="{{ repo.open_issues_count or 0 }}"
+                 data-activity="{{ repo.activity.last_at if repo.activity else '' }}"
                  data-search="{{ (repo.name ~ ' ' ~ repo.full_name ~ ' ' ~ (repo.description or ''))|lower }}"
                  x-show="search === '' || $el.dataset.search.includes(search.toLowerCase())">
                 <div class="card-header">
@@ -60,6 +99,19 @@
                     <span class="date">{{ repo.updated_at[:10] }}</span>
                     {% if not archived %}
                     <button type="button" class="star-btn" data-full="{{ full }}" data-starred="{{ 1 if repo.starred else 0 }}" title="{{ 'Désépingler (étoile Gitea)' if repo.starred else 'Épingler (étoile Gitea)' }}" aria-label="Épingler {{ repo.name }}">{{ '⭐' if repo.starred else '☆' }}</button>
+                    <div class="card-menu-wrap">
+                        <button type="button" class="card-menu-btn" data-menu-btn aria-haspopup="true" aria-expanded="false" title="Actions rapides pour {{ repo.name }}" aria-label="Actions rapides pour {{ repo.name }}">⋯</button>
+                        <div class="card-menu" hidden>
+                            <a href="/board/{{ full }}">📋 Board</a>
+                            <a href="/capture?repo={{ full|urlencode }}">⚡ Capturer ici</a>
+                            <a href="/triage/{{ full }}">📥 Triage du backlog</a>
+                            <a href="/health/{{ full }}">🩺 Santé</a>
+                            <a href="/sprint/{{ full }}">📖 Récit de sprint</a>
+                            {% if repo.html_url %}
+                            <a href="{{ repo.html_url }}" target="_blank" rel="noopener">🔗 Gitea ↗</a>
+                            {% endif %}
+                        </div>
+                    </div>
                     {% endif %}
                 </div>
                 <h3>
@@ -79,7 +131,7 @@
                 {% set ms = repo.next_milestone %}
                 <div class="ms-block">
                     <div class="ms-line">
-                        <span class="ms-title">🎯 {{ ms.title }}</span>
+                        <a href="/forecast#ms-{{ repo.owner.login }}-{{ repo.name }}" class="ms-title" title="Voir ce jalon dans le tableau des prévisions">🎯 {{ ms.title }}</a>
                         {% if ms.due_label %}<span class="ms-due{% if ms.late %} late{% endif %}">{{ '⚠️ ' if ms.late }}échéance {{ ms.due_label }}</span>{% endif %}
                     </div>
                     {% if ms.total %}
@@ -107,9 +159,62 @@
                     </div>
                     {% endif %}
                 </div>
+                {% if repo.activity %}
+                <div class="activity-line">
+                    {% if repo.activity.closed or repo.activity.moved %}
+                    📈 {{ repo.activity.closed }} fermée(s) · {{ repo.activity.moved }} déplacement(s) cette semaine
+                    {% elif repo.activity.idle_days is not none and repo.activity.idle_days > 7 %}
+                    💤 aucune activité kanban depuis {{ repo.activity.idle_days }} j
+                    {% endif %}
+                </div>
+                {% endif %}
             </div>
         {% endmacro %}
 
+        {% macro project_row(repo, archived=False) %}
+            {% set full = repo.full_name %}
+            {% set st = stats.get(full, {}) %}
+            <tr data-name="{{ repo.name|lower }}" data-owner="{{ repo.owner.login|lower }}"
+                data-open="{{ repo.open_issues_count or 0 }}"
+                data-inflight="{{ (st.get('in_progress', 0) + st.get('qa', 0) + st.get('review', 0)) }}"
+                data-updated="{{ repo.updated_at }}"
+                data-search="{{ (repo.name ~ ' ' ~ repo.full_name ~ ' ' ~ (repo.description or ''))|lower }}"
+                x-show="search === '' || $el.dataset.search.includes(search.toLowerCase())">
+                <td><a href="/project/{{ full }}"><strong>{{ repo.name }}</strong></a></td>
+                <td>{{ repo.owner.login }}</td>
+                <td>{{ repo.open_issues_count or 0 }}</td>
+                <td>{{ st.get('in_progress', 0) + st.get('qa', 0) + st.get('review', 0) }}</td>
+                <td>{% if repo.next_milestone %}🎯 {{ repo.next_milestone.title }}{% if repo.next_milestone.late %} ⚠️{% endif %}{% else %}—{% endif %}</td>
+                <td>{% if repo.health_dot %}<a href="/health/{{ full }}" class="health-dot {{ repo.health_dot.level }}" title="{{ repo.health_dot.tooltip }}" aria-label="Santé : {{ repo.health_dot.tooltip }}"></a>{% else %}—{% endif %}</td>
+                <td>{{ repo.updated_at[:10] }}</td>
+            </tr>
+        {% endmacro %}
+
+        {% macro project_table(repos, tab_name, archived=False) %}
+        <div x-show="tab === '{{ tab_name }}'">
+            <table class="proj-table">
+                <thead>
+                    <tr>
+                        <th data-sort="name">Projet</th>
+                        <th data-sort="owner">Propriétaire</th>
+                        <th data-sort="open">Ouvertes</th>
+                        <th data-sort="inflight">En vol</th>
+                        <th>Prochain jalon</th>
+                        <th>Santé</th>
+                        <th data-sort="updated">Dernière activité</th>
+                    </tr>
+                </thead>
+                <tbody>
+                    {% for repo in repos %}{{ project_row(repo, archived) }}{% endfor %}
+                </tbody>
+            </table>
+            {% if not repos %}
+            <div class="empty-state">Aucun projet dans cette vue.</div>
+            {% endif %}
+        </div>
+        {% endmacro %}
+
+        <div x-show="view === 'grid'">
         <!-- Épinglés (#20) : les dépôts étoilés dans Gitea, hors onglets. -->
         <section id="pinned-section"{% if not pinned_repos %} hidden{% endif %}>
             <h3 class="pinned-title">⭐ Épinglés</h3>
@@ -138,6 +243,14 @@
             <div class="empty-state">🗄️ Aucun projet archivé. L'archivage se fait dans Gitea (Réglages du dépôt).</div>
             {% endif %}
         </div>
+        </div>
+
+        <!-- Vue liste dense (#22) : mêmes onglets, mêmes données. -->
+        <div x-show="view === 'list'">
+            {{ project_table(active_repos, 'active') }}
+            {{ project_table(inactive_repos, 'inactive') }}
+            {{ project_table(archived_repos, 'archived', archived=True) }}
+        </div>
     </main>
 
     <footer>
@@ -146,6 +259,8 @@
     <script src="/static/js/live.js" defer></script>
     <script>window.KANBANTE_CSRF = "{{ csrf_token }}";</script>
     <script src="/static/js/stars.js" defer></script>
+    <script src="/static/js/dashboard.js" defer></script>
+    <script src="/static/js/tablesort.js" defer></script>
     <script>
         document.addEventListener('keydown', function (e) {
             if (e.key === '/' && !/INPUT|TEXTAREA/.test(document.activeElement?.tagName || '')) {

app/templates/forecast.html

@@ -13,13 +13,72 @@
     <main class="focus-main">
         <section class="briefing-card">
             <h1>🔮 Prévisions — « on finit quand ? »</h1>
-            <p>Réponse honnête, calculée depuis le journal : fermetures réelles par semaine (8 dernières), débit moyen/min/max sur les 4 dernières semaines complètes, et fourchette plutôt que faux chiffre précis. Sans historique de fermetures, aucune prévision n'est affichée.</p>
+            <p>Le tableau de bord des jalons, <strong>tous projets confondus</strong>, trié par risque : l'écart entre la date estimée (au débit réel du journal) et l'échéance. Réponse honnête — fourchettes plutôt que faux chiffres précis, et aucune prévision sans historique de fermetures.</p>
+            <p class="forecast-summary">
+                <span class="chip chip-total">🎯 {{ summary.total }} jalon(s) ouvert(s)</span>
+                {% if summary.late %}<span class="chip chip-late">⚠️ {{ summary.late }} en retard à ce rythme</span>{% endif %}
+                {% if summary.ontime %}<span class="chip chip-ok">✅ {{ summary.ontime }} dans les temps</span>{% endif %}
+            </p>
+            <div class="search-bar forecast-filter">
+                <input type="text" id="ms-filter" placeholder="🔍 Filtrer par projet ou jalon..." autocomplete="off">
+            </div>
         </section>
 
-        {% for project in projects %}
-        <section class="briefing-card forecast-card">
-            <h2>📂 {{ project.full_name }}</h2>
+        {% if rows %}
+        <table class="proj-table pilot-table">
+            <thead>
+                <tr>
+                    <th data-sort="project">Projet</th>
+                    <th data-sort="title">Jalon</th>
+                    <th data-sort="due">Échéance</th>
+                    <th>Progression</th>
+                    <th>ETA</th>
+                    <th data-sort="gap">Écart</th>
+                    <th data-sort="throughput">Débit / sem.</th>
+                </tr>
+            </thead>
+            <tbody>
+                {% for row in rows %}
+                <tr{% if row.anchor %} id="ms-{{ row.owner }}-{{ row.repo }}"{% endif %}
+                    data-project="{{ row.project|lower }}" data-title="{{ row.title|lower }}"
+                    data-due="{{ row.due_sort }}" data-gap="{{ row.gap_days if row.gap_days is not none else '' }}"
+                    data-throughput="{{ row.throughput if row.throughput is not none else '' }}"
+                    data-search="{{ (row.project ~ ' ' ~ row.title)|lower }}">
+                    <td><a href="/project/{{ row.project }}">{{ row.project }}</a></td>
+                    <td><a href="/board/{{ row.project }}?milestone={{ row.title|urlencode }}"><strong>{{ row.title }}</strong></a></td>
+                    <td>{{ row.due_label }}</td>
+                    <td>
+                        {% if row.total %}
+                        <div class="progress ms-progress pilot-progress"><span style="width: {{ row.pct }}%"></span></div>
+                        <span class="ms-meta">{{ row.closed }}/{{ row.total }}</span>
+                        {% else %}—{% endif %}
+                    </td>
+                    <td>{{ row.eta or '—' }}</td>
+                    <td>
+                        {% if row.verdict == 'late' %}
+                        <span class="verdict verdict-late">⚠️ +{{ row.gap_days }} j</span>
+                        {% elif row.verdict == 'ontime' %}
+                        <span class="verdict verdict-ok">✅ dans les temps{% if row.gap_days is not none and row.gap_days < 0 %} ({{ -row.gap_days }} j d'avance){% endif %}</span>
+                        {% elif row.verdict == 'nodue' %}
+                        <span class="verdict">sans échéance</span>
+                        {% else %}
+                        <span class="verdict">pas d'ETA</span>
+                        {% endif %}
+                    </td>
+                    <td>{{ row.throughput if row.throughput is not none else '—' }}</td>
+                </tr>
+                {% endfor %}
+            </tbody>
+        </table>
+        {% else %}
+        <section class="briefing-card"><p>Aucun jalon ouvert dans les projets actifs. Crée des jalons dans Gitea pour piloter par échéances.</p></section>
+        {% endif %}
+
+        <section class="briefing-card">
+            <h2>📈 Débit par projet</h2>
+            {% for project in projects %}
             <div class="forecast-flex">
+                <div class="forecast-proj-name">📂 <a href="/project/{{ project.full_name }}">{{ project.full_name }}</a></div>
                 <svg class="sparkline" viewBox="0 0 168 48" role="img" aria-label="Fermetures par semaine">
                     {% for bar in project.bars %}
                     {% set px = (bar.h * 0.42)|round|int %}
@@ -30,25 +89,17 @@
                 </svg>
                 <div class="forecast-nums">
                     {% if project.stats %}
-                    <p>Débit : <strong>{{ project.stats.avg }} / semaine</strong> en moyenne (min {{ project.stats.min }}, max {{ project.stats.max }})</p>
+                    <p>Débit : <strong>{{ project.stats.avg }} / semaine</strong> (min {{ project.stats.min }}, max {{ project.stats.max }})</p>
                     {% else %}
-                    <p>Débit : <strong>pas assez d'historique</strong> — aucune fermeture récente dans le journal.</p>
+                    <p>Débit : <strong>pas assez d'historique</strong>.</p>
                     {% endif %}
-                    <p>Restant ouvert : <strong>{{ project.remaining }}</strong>
-                    {% if project.eta_label %} · 🔮 backlog {{ project.eta_label }}{% endif %}</p>
+                    <p>Restant ouvert : <strong>{{ project.remaining }}</strong>{% if project.eta_label %} · 🔮 backlog {{ project.eta_label }}{% endif %}</p>
                 </div>
             </div>
-            {% if project.milestones %}
-            <ul class="forecast-milestones">
-                {% for ms in project.milestones %}
-                <li>🎯 <strong>{{ ms.title }}</strong> — {{ ms.remaining }} restante(s){% if ms.due_on %} · échéance {{ ms.due_on }}{% endif %}{% if ms.eta %} · 🔮 {{ ms.eta }}{% endif %}{% if ms.verdict %} · {{ ms.verdict }}{% endif %}</li>
-                {% endfor %}
-            </ul>
-            {% endif %}
+            {% else %}
+            <p>Aucun projet actif.</p>
+            {% endfor %}
         </section>
-        {% else %}
-        <div class="briefing-card"><p>Aucun projet actif.</p></div>
-        {% endfor %}
     </main>
     <footer>
         <span>Kanbante v{{ version }} · prévisions = journal des fermetures, pas boule de cristal</span>
@@ -56,5 +107,14 @@
     {% include "_palette.html" %}
     <script src="/static/js/palette.js" defer></script>
     <script src="/static/js/live.js" defer></script>
+    <script src="/static/js/tablesort.js" defer></script>
+    <script>
+        document.getElementById('ms-filter')?.addEventListener('input', function (e) {
+            var q = e.target.value.toLowerCase();
+            document.querySelectorAll('.pilot-table tbody tr').forEach(function (row) {
+                row.style.display = !q || (row.dataset.search || '').includes(q) ? '' : 'none';
+            });
+        });
+    </script>
 </body>
 </html>

app/templates/health.html

@@ -13,23 +13,44 @@
     <main class="focus-main">
         <section class="briefing-card">
             <h1>🩺 Santé du flux</h1>
-            <p>Les boards montrent l'état ; cette page montre la <strong>santé</strong> : quelle colonne accumule (temps médian passé dans chaque colonne, d'après le journal) et quelles cartes sont devenues des <strong>zombies</strong> (aucune activité depuis le seuil configuré).</p>
+            <p>Tous les projets actifs, <strong>triés par sévérité</strong> — le rouge d'abord. Quelle colonne accumule (temps médian par colonne, d'après le journal) et quelles cartes sont devenues des <strong>zombies</strong>. Cliquez un projet pour le détail et les actions rapides.</p>
         </section>
 
-        {% for project in projects %}
-        <section class="briefing-card forecast-card">
-            <h2>📂 {{ project.full_name }} <small>({{ project.open_count }} ouverte(s))</small></h2>
-            {% if project.slowest %}
-            <p>🐌 Colonne la plus lente : <strong>{{ project.column_labels[project.slowest.column] }}</strong> — médiane {{ project.slowest.median_days }} j ({{ project.slowest.count }} séjours mesurés)</p>
-            {% else %}
-            <p>🐌 Pas encore assez de séjours mesurés pour nommer un goulot.</p>
-            {% endif %}
-            <p>🧟 Zombies (≥ {{ project.zombie_days }} j sans activité) : <strong>{{ project.zombies|length }}</strong>
-            — <a href="/health/{{ project.full_name }}">voir le détail et agir →</a></p>
-        </section>
+        {% if projects %}
+        <table class="proj-table pilot-table">
+            <thead>
+                <tr>
+                    <th data-sort="severity">Santé</th>
+                    <th data-sort="project">Projet</th>
+                    <th data-sort="open">Ouvertes</th>
+                    <th data-sort="zombies">🧟 Zombies</th>
+                    <th data-sort="slowest">🐌 Goulot</th>
+                    <th></th>
+                </tr>
+            </thead>
+            <tbody>
+                {% for project in projects %}
+                <tr data-severity="{{ {'red': 0, 'orange': 1, 'green': 2}.get(project.dot.level, 3) }}"
+                    data-project="{{ project.full_name|lower }}" data-open="{{ project.open_count }}"
+                    data-zombies="{{ project.zombies|length }}"
+                    data-slowest="{{ project.slowest.median_days if project.slowest else '' }}">
+                    <td><span class="health-dot {{ project.dot.level }}" title="{{ project.dot.title }}"></span></td>
+                    <td><a href="/health/{{ project.full_name }}"><strong>{{ project.full_name }}</strong></a></td>
+                    <td>{{ project.open_count }}</td>
+                    <td>{{ project.zombies|length }}{% if project.zombies %} <span class="ms-meta">(≥ {{ project.zombie_days }} j)</span>{% endif %}</td>
+                    <td>
+                        {% if project.slowest %}
+                        {{ project.column_labels[project.slowest.column] }} — médiane {{ project.slowest.median_days }} j
+                        {% else %}<span class="ms-meta">pas assez de données</span>{% endif %}
+                    </td>
+                    <td><a href="/health/{{ project.full_name }}">détail →</a></td>
+                </tr>
+                {% endfor %}
+            </tbody>
+        </table>
         {% else %}
-        <div class="briefing-card"><p>Aucun projet actif.</p></div>
-        {% endfor %}
+        <section class="briefing-card"><p>Aucun projet actif.</p></section>
+        {% endif %}
     </main>
     <footer>
         <span>Kanbante v{{ version }} · l'hygiène du flux, mesurée sur le journal — pas au feeling</span>
@@ -37,5 +58,6 @@
     {% include "_palette.html" %}
     <script src="/static/js/palette.js" defer></script>
     <script src="/static/js/live.js" defer></script>
+    <script src="/static/js/tablesort.js" defer></script>
 </body>
 </html>

app/templates/health_project.html

@@ -11,6 +11,18 @@
     {% include "_header.html" %}
 
     <main class="focus-main">
+        {% if project_names %}
+        <div class="health-switch-bar">
+            <label for="health-switch">🩺 Projet :</label>
+            <select id="health-switch">
+                {% for name in project_names %}
+                <option value="{{ name }}"{% if name == full_name %} selected{% endif %}>{{ name }}</option>
+                {% endfor %}
+                {% if full_name not in project_names %}<option value="{{ full_name }}" selected>{{ full_name }}</option>{% endif %}
+            </select>
+            <a href="/health" class="health-back">← tous les projets</a>
+        </div>
+        {% endif %}
         {% if health is none %}
         <section class="briefing-card">
             <h1>🩺 {{ full_name }}</h1>

pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "kanbante"
-version = "0.17.0"
+version = "0.19.0"
 description = "Kanban project manager integrated with Gitea"
 requires-python = ">=3.11"
 dependencies = [

static/css/style.css

@@ -1371,3 +1371,107 @@ body.sidebar-collapsed .side-foot { justify-content: center; }
 .proj-dim { color: var(--text-3); }
 .proj-empty { color: var(--text-2); font-size: 0.92rem; }
 .proj-notes-body { white-space: pre-wrap; font-size: 0.93rem; background: var(--surface-2); border-radius: 10px; padding: 12px 14px; }
+
+/* ── Dashboard vague 2 suite (0.18.0, #19 #21 #22 #23) ── */
+.activity-line { margin-top: 8px; font-size: 0.82rem; color: var(--text-2); }
+.dash-tools {
+    display: flex; align-items: center; gap: 18px; flex-wrap: wrap;
+    padding: 0 24px; margin: 4px 0 14px;
+}
+.dash-tool { display: inline-flex; align-items: center; gap: 8px; font-size: 0.88rem; color: var(--text-2); }
+.dash-tool select {
+    background: var(--surface-2); color: var(--text);
+    border: 1px solid var(--border); border-radius: 8px; padding: 6px 8px;
+}
+.dash-tool-check input { width: 17px; height: 17px; accent-color: #7c5cfc; }
+.dash-view-toggle { margin-left: auto; display: inline-flex; border: 1px solid var(--border); border-radius: 10px; overflow: hidden; }
+.dash-view-toggle button {
+    background: var(--surface-1); color: var(--text-2); border: none;
+    padding: 7px 14px; cursor: pointer; font-size: 0.88rem;
+}
+.dash-view-toggle button.active { background: var(--surface-3, #1d2942); color: var(--text); font-weight: 700; }
+.owner-group { grid-column: 1 / -1; }
+.owner-head {
+    display: flex; justify-content: space-between; align-items: center;
+    width: 100%; padding: 9px 12px; margin-bottom: 10px; cursor: pointer;
+    background: var(--surface-1); color: var(--text);
+    border: 1px solid var(--border); border-radius: 10px;
+    font-size: 0.95rem; font-weight: 700;
+}
+.owner-head:hover { border-color: var(--accent, #58a6ff); }
+.owner-head .owner-chevron { transition: transform 0.2s ease; font-size: 0.7rem; }
+.owner-head[aria-expanded="false"] .owner-chevron { transform: rotate(-90deg); }
+.owner-grid { padding: 0 !important; }
+.card-menu-wrap { position: relative; }
+.card-menu-btn {
+    background: transparent; border: none; cursor: pointer;
+    color: var(--text-2); font-size: 1.15rem; font-weight: 800;
+    padding: 2px 7px; border-radius: 8px; line-height: 1;
+}
+.card-menu-btn:hover { background: var(--surface-2); color: var(--text); }
+.card-menu {
+    position: absolute; right: 0; top: calc(100% + 6px); z-index: 60;
+    min-width: 210px; display: flex; flex-direction: column; gap: 2px;
+    background: var(--surface-1); border: 1px solid var(--border);
+    border-radius: 12px; padding: 6px;
+    box-shadow: 0 14px 34px rgba(0, 0, 0, 0.45);
+}
+.card-menu[hidden] { display: none !important; }
+.card-menu a {
+    display: flex; align-items: center; min-height: 32px;
+    padding: 8px 10px; border-radius: 8px;
+    color: var(--text-2); font-size: 0.92rem;
+}
+.card-menu a:hover { background: var(--surface-2); color: var(--text); text-decoration: none; }
+.proj-table {
+    width: calc(100% - 48px); margin: 0 24px 18px;
+    border-collapse: collapse; font-size: 0.93rem;
+    background: var(--surface-1); border: 1px solid var(--border);
+    border-radius: 12px; overflow: hidden;
+}
+.proj-table th, .proj-table td {
+    text-align: left; padding: 10px 14px;
+    border-bottom: 1px solid var(--border);
+}
+.proj-table thead th { color: var(--text-2); font-size: 0.8rem; text-transform: uppercase; letter-spacing: 0.06em; }
+.proj-table th.sortable { cursor: pointer; }
+.proj-table th.sortable:hover { color: var(--text); }
+.proj-table th[data-dir="asc"]::after { content: " ↑"; }
+.proj-table th[data-dir="desc"]::after { content: " ↓"; }
+.proj-table tbody tr:hover { background: var(--surface-2); }
+@media (max-width: 900px) {
+    .proj-table { display: block; overflow-x: auto; }
+    .dash-view-toggle { margin-left: 0; }
+}
+
+/* ── Pilotage 0.19.0 : tableaux Prévisions/Santé (chantier C) ── */
+.pilot-table { margin-bottom: 18px; }
+.pilot-table tr[id] { scroll-margin-top: 76px; }
+.pilot-progress { min-width: 90px; }
+.forecast-summary { display: flex; gap: 8px; flex-wrap: wrap; margin: 10px 0 4px; }
+.forecast-summary .chip {
+    font-size: 12.5px; padding: 3px 10px; border-radius: 999px;
+    background: rgba(255, 255, 255, .07); border: 1px solid var(--border, #333);
+}
+.forecast-summary .chip-late { background: rgba(248, 81, 73, .15); }
+.forecast-summary .chip-ok { background: rgba(63, 185, 80, .15); }
+.forecast-filter { margin-top: 10px; max-width: 420px; }
+.forecast-filter input { width: 100%; }
+.forecast-proj-name { font-weight: 600; min-width: 180px; }
+.verdict {
+    font-size: 12.5px; padding: 2px 9px; border-radius: 999px; white-space: nowrap;
+    background: rgba(255, 255, 255, .06);
+}
+.verdict-late { background: rgba(248, 81, 73, .18); }
+.verdict-ok { background: rgba(63, 185, 80, .16); }
+a.ms-title { color: inherit; text-decoration: none; }
+a.ms-title:hover { text-decoration: underline; }
+.health-switch-bar {
+    display: flex; align-items: center; gap: 10px; margin-bottom: 14px; flex-wrap: wrap;
+}
+.health-switch-bar select {
+    padding: 8px 10px; border-radius: 8px; font-size: 14px; min-height: 38px;
+    background: var(--panel-2, #1c2330); color: inherit;
+    border: 1px solid var(--border, #333);
+}
+.health-back { font-size: 13.5px; }

static/js/dashboard.js

@@ -0,0 +1,159 @@
+/**
+ * Kanbante — dashboard display tools (issues #21, #22, #23).
+ * Sort + group-by-owner for the card grids, sortable dense tables,
+ * and the per-card quick-actions menu. Preferences live in
+ * localStorage; the server markup stays the single source.
+ */
+(function () {
+    var LS_SORT = 'kanbante-dash-sort';
+    var LS_GROUP = 'kanbante-dash-group';
+    var LS_OWNERS = 'kanbante-dash-owners-closed';
+
+    function lsGet(key, fallback) {
+        try {
+            var v = localStorage.getItem(key);
+            return v === null ? fallback : v;
+        } catch (e) { return fallback; }
+    }
+    function lsSet(key, value) {
+        try { localStorage.setItem(key, value); } catch (e) { /* non-fatal */ }
+    }
+
+    /* ── Tri des grilles de cartes ─────────────────────────── */
+    var sortSelect = document.getElementById('dash-sort');
+    var grids = ['grid-active', 'grid-inactive', 'grid-archived']
+        .map(function (id) { return document.getElementById(id); })
+        .filter(Boolean);
+
+    function cardKey(card, mode) {
+        if (mode === 'name') return (card.getAttribute('data-name') || '').toLowerCase();
+        if (mode === 'open') return -(parseInt(card.getAttribute('data-open') || '0', 10));
+        if (mode === 'updated') return card.getAttribute('data-updated') || '';
+        if (mode === 'activity') return card.getAttribute('data-activity') || '';
+        return null; // 'default' : ordre serveur, on ne touche à rien
+    }
+    function sortCards(container, mode) {
+        var cards = Array.prototype.slice.call(
+            container.querySelectorAll('.project-card'));
+        if (mode === 'default' || !cards.length) return;
+        cards.sort(function (a, b) {
+            var ka = cardKey(a, mode), kb = cardKey(b, mode);
+            if (ka < kb) return mode === 'name' ? -1 : 1;
+            if (ka > kb) return mode === 'name' ? 1 : -1;
+            return 0;
+        });
+        cards.forEach(function (c) { container.appendChild(c); });
+    }
+    function applySort() {
+        var mode = sortSelect ? sortSelect.value : 'default';
+        lsSet(LS_SORT, mode);
+        grids.forEach(function (grid) {
+            if (groupToggle && groupToggle.checked) {
+                grid.querySelectorAll('.owner-grid').forEach(function (og) {
+                    sortCards(og, mode);
+                });
+            } else {
+                sortCards(grid, mode);
+            }
+        });
+    }
+
+    /* ── Regroupement par propriétaire ─────────────────────── */
+    var groupToggle = document.getElementById('dash-group');
+    function closedOwners() {
+        try { return JSON.parse(lsGet(LS_OWNERS, '[]')); } catch (e) { return []; }
+    }
+    function setOwnerClosed(owner, closed) {
+        var list = closedOwners().filter(function (o) { return o !== owner; });
+        if (closed) list.push(owner);
+        lsSet(LS_OWNERS, JSON.stringify(list));
+    }
+    function groupGrid(grid) {
+        var cards = Array.prototype.slice.call(
+            grid.querySelectorAll(':scope > .project-card'));
+        if (!cards.length) return;
+        var byOwner = {};
+        cards.forEach(function (c) {
+            var o = c.getAttribute('data-owner') || '—';
+            (byOwner[o] = byOwner[o] || []).push(c);
+        });
+        Object.keys(byOwner).sort().forEach(function (owner) {
+            var wrap = document.createElement('div');
+            wrap.className = 'owner-group';
+            var head = document.createElement('button');
+            head.type = 'button';
+            head.className = 'owner-head';
+            var closed = closedOwners().indexOf(owner) >= 0;
+            head.setAttribute('aria-expanded', closed ? 'false' : 'true');
+            head.innerHTML = '<span>🗂️ ' + owner + ' (' + byOwner[owner].length + ')</span><span class="owner-chevron">▾</span>';
+            var body = document.createElement('div');
+            body.className = 'project-grid owner-grid';
+            if (closed) body.hidden = true;
+            head.addEventListener('click', function () {
+                body.hidden = !body.hidden;
+                head.setAttribute('aria-expanded', body.hidden ? 'false' : 'true');
+                setOwnerClosed(owner, body.hidden);
+            });
+            byOwner[owner].forEach(function (c) { body.appendChild(c); });
+            wrap.appendChild(head);
+            wrap.appendChild(body);
+            grid.appendChild(wrap);
+        });
+    }
+    function ungroupGrid(grid) {
+        grid.querySelectorAll('.owner-group').forEach(function (wrap) {
+            var body = wrap.querySelector('.owner-grid');
+            Array.prototype.slice.call(body.querySelectorAll('.project-card'))
+                .forEach(function (c) { grid.appendChild(c); });
+            wrap.remove();
+        });
+    }
+    function applyGrouping() {
+        var on = !!(groupToggle && groupToggle.checked);
+        lsSet(LS_GROUP, on ? '1' : '0');
+        grids.forEach(function (grid) {
+            ungroupGrid(grid);
+            if (on) groupGrid(grid);
+        });
+        applySort();
+    }
+
+    if (sortSelect) {
+        sortSelect.value = lsGet(LS_SORT, 'default');
+        sortSelect.addEventListener('change', applySort);
+    }
+    if (groupToggle) {
+        groupToggle.checked = lsGet(LS_GROUP, '0') === '1';
+        groupToggle.addEventListener('change', applyGrouping);
+    }
+    applyGrouping(); // applique regroupement + tri mémorisés
+
+    /* ── Menu ⋯ d'actions rapides (#23) ────────────────────── */
+    function closeMenus() {
+        document.querySelectorAll('.card-menu').forEach(function (m) {
+            m.hidden = true;
+        });
+        document.querySelectorAll('[data-menu-btn]').forEach(function (b) {
+            b.setAttribute('aria-expanded', 'false');
+        });
+    }
+    document.querySelectorAll('[data-menu-btn]').forEach(function (btn) {
+        btn.addEventListener('click', function (e) {
+            e.stopPropagation();
+            var menu = btn.parentElement.querySelector('.card-menu');
+            var willOpen = menu.hidden;
+            closeMenus();
+            if (willOpen) {
+                menu.hidden = false;
+                btn.setAttribute('aria-expanded', 'true');
+            }
+        });
+    });
+    document.addEventListener('click', closeMenus);
+    document.addEventListener('keydown', function (e) {
+        if (e.key === 'Escape') closeMenus();
+    });
+
+    /* Le tri des tableaux denses (#22) vit dans tablesort.js,
+       partagé avec /forecast et /health (0.19.0). */
+})();

static/js/health.js

@@ -5,6 +5,15 @@
 (function () {
     var csrf = (document.querySelector('meta[name="csrf-token"]') || {}).content || '';
 
+    /* Project switcher (0.19.0): jump between projects without
+       going back to the health index. */
+    var switcher = document.getElementById('health-switch');
+    if (switcher) {
+        switcher.addEventListener('change', function () {
+            window.location.href = '/health/' + switcher.value;
+        });
+    }
+
     function post(url, fields) {
         var data = new FormData();
         Object.keys(fields).forEach(function (k) { data.append(k, fields[k]); });

static/js/tablesort.js

@@ -0,0 +1,38 @@
+/**
+ * Kanbante — tri des tableaux « pilotage » (.proj-table), partagé
+ * entre le dashboard, /forecast et /health (0.19.0).
+ * Tri client par colonne : les lignes portent leurs valeurs dans
+ * des attributs data-<clé> ; cliquer un <th data-sort="clé">
+ * trie dans un sens puis dans l'autre.
+ */
+(function () {
+    document.querySelectorAll('.proj-table').forEach(function (table) {
+        var tbody = table.querySelector('tbody');
+        if (!tbody) return;
+        table.querySelectorAll('th[data-sort]').forEach(function (th) {
+            th.classList.add('sortable');
+            th.addEventListener('click', function () {
+                var key = th.getAttribute('data-sort');
+                var dir = th.getAttribute('data-dir') === 'asc' ? 'desc' : 'asc';
+                table.querySelectorAll('th').forEach(function (h) {
+                    h.removeAttribute('data-dir');
+                });
+                th.setAttribute('data-dir', dir);
+                var rows = Array.prototype.slice.call(tbody.querySelectorAll('tr'));
+                rows.sort(function (a, b) {
+                    var va = a.getAttribute('data-' + key) || '';
+                    var vb = b.getAttribute('data-' + key) || '';
+                    var na = parseFloat(va), nb = parseFloat(vb);
+                    var cmp;
+                    if (!isNaN(na) && !isNaN(nb) && va !== '' && vb !== '') {
+                        cmp = na - nb;
+                    } else {
+                        cmp = va < vb ? -1 : (va > vb ? 1 : 0);
+                    }
+                    return dir === 'asc' ? cmp : -cmp;
+                });
+                rows.forEach(function (r) { tbody.appendChild(r); });
+            });
+        });
+    });
+})();

tests/test_palier14.py

@@ -0,0 +1,74 @@
+"""Palier 14 (0.18.0): vague 2 suite — activité 7 jours (#19),
+tri/regroupement (#21), vue liste dense (#22), actions rapides (#23)."""
+
+from datetime import datetime, timedelta, timezone
+
+from app import models
+
+
+def _ts(days_ago: int) -> str:
+    dt = datetime.now(timezone.utc) - timedelta(days=days_ago)
+    return dt.strftime("%Y-%m-%d 12:00:00")
+
+
+def test_activity_line_recent_week(client, fake_gitea):
+    for _ in range(2):
+        models.log_event("Projets/demo", 1, "closed",
+                         to_column="done", created_at=_ts(1))
+    models.log_event("Projets/demo", 5, "moved",
+                     from_column="backlog", to_column="todo",
+                     created_at=_ts(0))
+    page = client.get("/")
+    assert "2 fermée(s) · 1 déplacement(s) cette semaine" in page.text
+
+
+def test_activity_line_idle_project(client, fake_gitea):
+    models.log_event("Projets/vieux", 9, "moved",
+                     from_column="backlog", to_column="todo",
+                     created_at=_ts(35))
+    page = client.get("/")
+    assert "aucune activité kanban depuis 35 j" in page.text
+
+
+def test_dashboard_display_tools_markup(client, fake_gitea):
+    page = client.get("/")
+    assert "dashState" in page.text
+    assert 'id="dash-sort"' in page.text
+    assert 'id="dash-group"' in page.text
+    assert "Grouper par propriétaire" in page.text
+    assert "setView('grid')" in page.text
+    assert "setView('list')" in page.text
+
+
+def test_dense_list_view_tables(client, fake_gitea):
+    page = client.get("/")
+    assert page.text.count('class="proj-table"') == 3
+    assert 'data-sort="open"' in page.text
+    assert 'data-sort="inflight"' in page.text
+    # La ligne dense de demo : lien page projet + compteurs.
+    assert 'href="/project/Projets/demo"' in page.text
+
+
+def test_dashboard_js_contract(client, fake_gitea):
+    js = client.get("/static/js/dashboard.js")
+    assert js.status_code == 200
+    assert "kanbante-dash-sort" in js.text
+    assert "kanbante-dash-group" in js.text
+    assert "owner-group" in js.text
+    assert "data-menu-btn" in js.text
+
+
+def test_card_quick_actions_menu(client, fake_gitea):
+    page = client.get("/")
+    assert "data-menu-btn" in page.text
+    # urlencode de Jinja conserve les « / » : le lien est valide tel quel.
+    assert 'href="/capture?repo=Projets/demo"' in page.text
+    assert 'href="/triage/Projets/demo"' in page.text
+    assert 'href="/sprint/Projets/demo"' in page.text
+    assert 'href="/health/Projets/demo"' in page.text
+
+
+def test_capture_prefilled_repo(client, fake_gitea):
+    page = client.get("/capture?repo=Projets/kanbante")
+    assert page.status_code == 200
+    assert 'value="Projets/kanbante"' in page.text

tests/test_palier15.py

@@ -0,0 +1,112 @@
+"""Palier 15 (0.19.0) — Performance + navigation Pilotage.
+
+- A : les boucles par dépôt sont parallélisées (le comportement
+  visible ne change pas — couvert par les paliers précédents) et
+  le cache du client passe en stale-while-revalidate (testé dans
+  test_gitea_client.py).
+- C : /forecast devient un tableau de bord des jalons (une ligne
+  par jalon, ancres depuis le dashboard) et /health un tableau
+  trié par sévérité, avec sélecteur de projet sur le détail.
+"""
+
+import asyncio
+
+import httpx
+
+from app.gitea_client import GiteaClient
+
+
+def test_forecast_is_a_portfolio_table(client):
+    r = client.get("/forecast")
+    assert r.status_code == 200
+    assert "pilot-table" in r.text
+    assert "jalon(s) ouvert(s)" in r.text
+    # One row for the demo milestone, anchored for dashboard links.
+    assert 'id="ms-Projets-demo"' in r.text
+    assert "Sprint 1" in r.text
+    # The per-project pace table is still there.
+    assert "Débit par projet" in r.text
+
+
+def test_dashboard_milestone_links_into_forecast(client):
+    r = client.get("/")
+    assert r.status_code == 200
+    assert 'href="/forecast#ms-Projets-demo"' in r.text
+
+
+def test_health_index_is_a_severity_table(client):
+    r = client.get("/health")
+    assert r.status_code == 200
+    assert "pilot-table" in r.text
+    assert "data-severity" in r.text
+    assert "Projets/demo" in r.text
+
+
+def test_health_detail_has_project_switcher(client):
+    r = client.get("/health/Projets/demo")
+    assert r.status_code == 200
+    assert 'id="health-switch"' in r.text
+    assert '<option value="Projets/demo" selected>' in r.text
+    assert "tous les projets" in r.text
+
+
+async def test_swr_serves_stale_then_refreshes_in_background():
+    """Stale entries are served instantly; the refresh lands
+    asynchronously and the next read sees the fresh value."""
+    calls = {"n": 0}
+
+    def handler(request):
+        if request.url.path.endswith("/user"):
+            return httpx.Response(200, json={"id": 7})
+        calls["n"] += 1
+        return httpx.Response(200, json={"data": [{"id": calls["n"]}]})
+
+    client = GiteaClient(
+        base_url="http://gitea.test",
+        token="",
+        cache_ttl=60,
+        transport=httpx.MockTransport(handler),
+    )
+    first = await client.search_repos()
+    assert first == [{"id": 1}]
+    # Fresh cache: no new fetch.
+    assert await client.search_repos() == [{"id": 1}]
+    assert calls["n"] == 1
+    # Age the entry beyond the TTL: the stale value comes back
+    # immediately (same content, no wait)…
+    ts, value = client._cache["search_repos"]
+    client._cache["search_repos"] = (ts - 120, value)
+    assert await client.search_repos() == [{"id": 1}]
+    # …and the background refresh replaces it.
+    await asyncio.sleep(0.3)
+    assert await client.search_repos() == [{"id": 2}]
+    await client.aclose()
+
+
+async def test_swr_mutation_clear_blocks_stale_resurrection():
+    """A refresh started before a cache clear (mutation) must not
+    put its now-stale result back."""
+    calls = {"n": 0}
+
+    def handler(request):
+        if request.url.path.endswith("/user"):
+            return httpx.Response(200, json={"id": 7})
+        calls["n"] += 1
+        return httpx.Response(200, json={"data": [{"id": calls["n"]}]})
+
+    client = GiteaClient(
+        base_url="http://gitea.test",
+        token="",
+        cache_ttl=60,
+        transport=httpx.MockTransport(handler),
+    )
+    await client.search_repos()
+    ts, value = client._cache["search_repos"]
+    client._cache["search_repos"] = (ts - 120, value)
+    await client.search_repos()  # triggers background refresh
+    client._cache_clear()  # a mutation lands first
+    await asyncio.sleep(0.3)
+    # The cache was cleared and the in-flight refresh was disarmed:
+    # the next read fetches fresh instead of serving the old value.
+    assert await client.search_repos() == [{"id": 3}]
+    await client.aclose()