diff --git a/.github/workflows/assert-memory-budget.yml b/.github/workflows/assert-memory-budget.yml
new file mode 100644
index 0000000000..3f387f240e
--- /dev/null
+++ b/.github/workflows/assert-memory-budget.yml
@@ -0,0 +1,99 @@
+name: Assert memory budget (composition vs RAM VM, #19805)
+
+# Issue #19805 : `fix(runners): budget memoire po-2024 incoherent avec la VM --
+# 42 Go declares pour 24 032 Mo disponibles`. La composition cumulee des
+# conteneurs runners (effectifs x caps) etait superieure a la RAM de la VM
+# WSL, et l'instrumentation existante ne le detectait pas. `measure_po2024_topology`
+# mesure la topologie mais ne confronte pas la composition au budget declare,
+# et le garde precedent ne connaissait que le budget (pas la RAM VM).
+#
+# Cet organe `scripts/ci/assert_memory_budget.py` comble le trou. Il derive la
+# composition des unites DEPLOYEES (`scripts/ci/docker/linux-runner/persist/` :
+# `ExecStart` de chaque jambe, le drop-in de la machine-cible en surcharge),
+# prend la RAM VM de la machine-cible comme constante DECLAREE -- jamais mesuree
+# sur l'hote qui execute l'organe -- et compare a la borne la plus contraignante
+# entre MemoryMax de la slice et la RAM VM (hote reserve). Rouge si la
+# composition depasse.
+#
+# Le verdict sert deux causes :
+# 1. Detecter la derive de la composition quand un dimensionnement change sans
+#    que le reste suive (mesure fondateur de l'issue #19805 : l'agrandissement
+#    VM du 2026-09-21 a ete revertu sans que les declarations suivent).
+# 2. Empecher l'extension silencieuse des caps par conteneur (chaque
+#    modification de supervise.sh qui touche --memory doit etre accompagnee
+#    d'un dimensionnement coherent, et celui-ci vit dans les unites).
+#
+# Workflow bloquant sur pull_request et push (les PRs touchant une unite, un
+# drop-in de machine, la slice ou supervise.sh concernes reapparaissent dans le
+# diff et le guard rougit). Schedule quotidien en arriere-plan pour detecter les
+# derives qui n'ont pas ete portees par une PR.
+
+on:
+  pull_request:
+    paths:
+      - "docker-configurations/runners/**"
+      - "scripts/ci/assert_memory_budget.py"
+      - "scripts/ci/measure_po2024_topology.py"
+      # Les unites et drop-ins dont la composition est DERIVEE : le guard doit
+      # se relancer quand l'un d'eux change, sinon il rend un verdict sur un
+      # dimensionnement qui n'est plus celui du depot.
+      - "scripts/ci/docker/linux-runner/persist/**"
+      - "scripts/ci/docker/linux-runner/supervise.sh"
+  push:
+    branches: [main]
+    paths:
+      - "docker-configurations/runners/**"
+      - "scripts/ci/assert_memory_budget.py"
+      - "scripts/ci/measure_po2024_topology.py"
+      - "scripts/ci/docker/linux-runner/persist/**"
+      - "scripts/ci/docker/linux-runner/supervise.sh"
+  schedule:
+    # Verifie la derive de l'instrument meme quand aucune PR ne touche
+    # le snapshot (un revert de .wslconfig sur po-2024 lui-meme est
+    # invisible depuis le repo : la CI sert de rappel hebdomadaire).
+    - cron: "37 6 * * 1"
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+jobs:
+  assert:
+    name: Composition vs RAM VM
+    runs-on: ubuntu-latest
+    timeout-minutes: 5
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.13"
+
+      - name: Run assert_memory_budget
+        id: assert
+        run: |
+          set -uo pipefail
+          python scripts/ci/assert_memory_budget.py --json > /tmp/assert.json
+          rc=$?
+          echo "exit_code=$rc" >> "$GITHUB_OUTPUT"
+          cat /tmp/assert.json
+          if [ $rc -ne 0 ]; then
+            echo "::error title=Incoherence budget memoire (issue #19805)::La composition cumulee des conteneurs runners depasse la borne la plus contraignante (MemoryMax slice ou RAM VM - hote reserve). Voir /tmp/assert.json et l'issue #19805."
+            exit 1
+          fi
+        env:
+          PYTHONIOENCODING: utf-8
+
+      # Le runner ubuntu-latest n'expose pas pytest dans le Python 3.13 de
+      # setup-python : sans cette etape le smoke test echoue sur
+      # `No module named pytest` (rouge fondeur du 2026-10-09), pas sur le code.
+      - name: Install pytest
+        run: python -m pip install --quiet --disable-pip-version-check pytest
+
+      - name: Run pytest (smoke)
+        run: |
+          python -m pytest scripts/tests/test_assert_memory_budget.py -v
+        env:
+          PYTHONIOENCODING: utf-8
diff --git a/docker-configurations/runners/po2024_budget.json b/docker-configurations/runners/po2024_budget.json
new file mode 100644
index 0000000000..71aa872ffb
--- /dev/null
+++ b/docker-configurations/runners/po2024_budget.json
@@ -0,0 +1,30 @@
+{
+  "machine": "po-2024",
+  "snapshot_date": "2026-10-08",
+  "vm_total_gib_observed": 23.47,
+  "composition": {
+    "docker": {
+      "instances": 6,
+      "cap_gib": 1.5,
+      "total_gib": 9.0,
+      "source": "supervise.sh cmd_run --memory 1536m (defaut)"
+    },
+    "waiters": {
+      "instances": 12,
+      "cap_gib": 0.5,
+      "total_gib": 6.0,
+      "source": "supervise.sh cmd_waiters --memory 512m"
+    },
+    "lean": {
+      "instances": 2,
+      "cap_gib": 6.0,
+      "total_gib": 12.0,
+      "source": "supervise.sh cmd_lean --memory 6g + memory-swap=memory"
+    }
+  },
+  "composition_total_gib": 27.0,
+  "vm_total_gib": 23.47,
+  "verdict_at_snapshot": "INCOHERENT : 27.0 GiB > 23.47 GiB VM",
+  "issue": 19805,
+  "notes": "Snapshot initial issu de la mesure firsthand de l'issue #19805 (2026-10-08). Le budget memoire cumule des conteneurs runners depasse la RAM de la VM WSL (24 032 Mo = 23.47 GiB). La slice coursia-ci.slice plafonne a 16 GiB (MemoryMax) et 12 GiB (MemoryHigh), donc le garde kernel cgroup v2 tient le mur ; ce snapshot sert a l'organe assert_memory_budget pour detecter la derive avant qu'elle ne se reproduise (cf. cause racine issue #19805 : agrandissement VM 2026-09-24 revertu, declarations non revisees)."
+}
diff --git a/scripts/ci/assert_memory_budget.py b/scripts/ci/assert_memory_budget.py
new file mode 100644
index 0000000000..e9f51f2089
--- /dev/null
+++ b/scripts/ci/assert_memory_budget.py
@@ -0,0 +1,549 @@
+"""Organe de garde -- composition memoire vs RAM de la VM (po-2024 #19805).
+
+Issue #19805 : `fix(runners): budget memoire po-2024 incoherent avec la VM --
+42 Go declares pour 24 032 Mo disponibles`. Le budget de la CI (somme des
+caps par conteneur x effectifs) etait superieur a la RAM de la VM WSL, et
+rien dans l'instrumentation existante ne le detectait. `measure_po2024_topology`
+mesure la topologie OS mais ne confronte pas la composition au budget
+declare, et le garde `assert_memory_budget` precedent ne connaissait que
+le budget declare -- il ne pouvait pas rougir sur une composition
+incoherente avec la machine.
+
+Cet organe comble ce trou :
+- RAM VM : **declaree** pour la machine-cible (`PO2024_VM_RAM_GIB`), jamais
+  mesuree sur l'hote qui execute l'organe -- cf. le bloc dedie plus bas.
+- Composition : **derivee des unites DEPLOYEES** (`persist/<machine>/<unite>.d/`
+  puis `persist/<unite>`) : effectif = argument entier de l'`ExecStart` du
+  wrapper de jambe, cap = `Environment=` de la meme unite. L'organe mesure le
+  deploiement, pas un instantane ecrit a la main ni les valeurs documentees.
+- Plafond dur declare : MemoryMax de la slice `coursia-ci.slice`, surcharge
+  `persist/<machine>/coursia-ci.slice` d'abord, generique en repli.
+- Marge : 0,5 GiB absorbe les arrondis d'unite (1024 vs 1000) et la memoire
+  reservee au systeme hote (Windows hote / WSL overhead).
+
+Verdict :
+- exit 0 si `composition + marge <= min(MemoryMax, RAM VM)`.
+- exit 1 si la composition depasse la borne la plus contraignante
+  (plafond slice declare ou RAM VM reelle). Sortie JSON sur stdout
+  + un resume 1 ligne sur stderr.
+
+Le script n'invoque pas docker, ne touche pas a la machine cible, et peut
+tourner depuis n'importe quelle machine du cluster (cross-platform via
+`measure_po2024_topology`).
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import re
+import sys
+from dataclasses import asdict, dataclass, field
+from pathlib import Path
+from typing import Any
+
+REPO_ROOT = Path(__file__).resolve().parent.parent.parent
+DEFAULT_BUDGET = REPO_ROOT / "docker-configurations" / "runners" / "po2024_budget.json"
+DEFAULT_SLICE = REPO_ROOT / "scripts" / "ci" / "docker" / "linux-runner" / "persist" / "coursia-ci.slice"
+DEFAULT_SUPERVISE = REPO_ROOT / "scripts" / "ci" / "docker" / "linux-runner" / "supervise.sh"
+PERSIST_DIR = REPO_ROOT / "scripts" / "ci" / "docker" / "linux-runner" / "persist"
+
+# Les trois jambes du pool CI, telles que le deploiement les installe :
+# (nom de famille, unite systemd, script du wrapper, variable de cap memoire,
+#  cap par defaut en MiB si l'unite ne le declare pas).
+#
+# L'effectif N n'est PAS dans une constante : il est lu dans l'argument entier
+# de l'`ExecStart=` de l'unite. C'est le point de la revue coordinateur du
+# 2026-10-08 (defaut 1) : le meme nombre ecrit a la main dans un snapshot ou
+# dans un en-tete de documentation derive silencieusement du deploiement.
+RUNNER_LEGS: tuple[tuple[str, str, str, str, int], ...] = (
+    ("start", "coursia-runner.service", "coursia-runner-start.sh",
+     "COURSIA_RUNNER_MEMORY", 1536),
+    ("waiters", "coursia-waiters.service", "coursia-waiters-start.sh",
+     "COURSIA_RUNNER_WAITER_MEMORY", 512),
+    ("lean", "coursia-lean.service", "coursia-lean-start.sh",
+     "COURSIA_LEAN_RUNNER_MEMORY", 6 * 1024),
+)
+
+# Marge de securite en GiB : arrondis d'unite (1 GiB = 1024 MiB mais
+# declare parfois comme 1000 MB) + memoire reservee a l'hote (Windows +
+# WSL overhead, ~200-400 MiB mesures).
+DEFAULT_MARGE_GIB = 0.5
+
+# Memoire pour les services NON-CI sur l'hote Windows. La slice plafonne
+# a 16 Go, ce qui laisse >100 Go a l'hote (cf. commentaire en tete de
+# coursia-ci.slice). On accepte ce partage : l'organe ne rougit que sur
+# la composition CI vs la borne la plus contraignante.
+HOST_RESERVED_GIB = 0.5
+
+# RAM VM de la machine-CIBLE, declaree comme constante (issue #19805 revue
+# coordinateur 2026-10-08, defaut 3).
+#
+# Pourquoi constante, pas mesuree : l'organe peut tourner depuis N'IMPORTE
+# QUELLE machine du cluster (ai-01 191.8 GiB, po-2027 63.6 GiB, po-2024 ~24
+# GiB) et c'est la machine-CIBLE qui plafonne, pas celle qui execute. Mesurer
+# la RAM de l'hote de l'organe rend un verdict incoherent : un organe sur
+# ai-01 dirait "VM po-2024 = 191.8 GiB, composition 27 GiB, OK" alors que
+# la VM reelle est 24 GiB -- c'est exactement le defaut fondateur que
+# `assert_memory_budget` est cense fermer.
+#
+# Source de verite : PR #19802 (allocation VM 24 GiB sur po-2024). Si une
+# autre machine-cible est ajoutee, etendre ce mapping.
+PO2024_VM_RAM_GIB = 24.0
+_MACHINE_VM_RAM_GIB: dict[str, float] = {
+    "po-2024": PO2024_VM_RAM_GIB,
+}
+
+
+def lookup_vm_ram_gib(machine: str) -> float | None:
+    """RAM VM declaree pour la machine-cible, ou None si inconnue.
+
+    L'organe refuse de mesurer l'hote sur lequel il tourne (cf. PO2024_VM_RAM_GIB).
+    La RAM est une propriete de la machine VERIFIEE, pas de la machine
+    EXECUTANT l'organe.
+    """
+    return _MACHINE_VM_RAM_GIB.get(machine)
+
+
+def lookup_slice(machine: str) -> Path:
+    """Cherche la surcharge de slice pour la machine, fallback sur la generique.
+
+    #19802 a introduit le motif `persist/<machine>/coursia-ci.slice` pour
+    permettre un plafond memoire DIFFERENT par machine-cible. La generique
+    `persist/coursia-ci.slice` reste le fallback historique.
+    """
+    machine_slice = (
+        REPO_ROOT
+        / "scripts"
+        / "ci"
+        / "docker"
+        / "linux-runner"
+        / "persist"
+        / machine
+        / "coursia-ci.slice"
+    )
+    if machine_slice.is_file():
+        return machine_slice
+    return DEFAULT_SLICE
+
+
+def _deployed_unit_text(machine: str, unit: str, persist_dir: Path) -> tuple[str, list[Path]]:
+    """Texte de l'unite telle que DEPLOYEE pour `machine`, + les fichiers lus.
+
+    Ordre systemd : le drop-in de la machine est lu APRES l'unite et peut la
+    surcharger ; on retourne donc les deux, le drop-in en dernier, et
+    l'appelant resout « derniere definition gagne ». Un drop-in qui ne
+    redefinit pas un champ ne l'efface pas -- d'ou la concatenation plutot
+    qu'un choix exclusif.
+    """
+    parts: list[str] = []
+    read: list[Path] = []
+    base = persist_dir / unit
+    if base.is_file():
+        parts.append(base.read_text(encoding="utf-8"))
+        read.append(base)
+    dropin_dir = persist_dir / machine / f"{unit}.d"
+    if dropin_dir.is_dir():
+        for dropin in sorted(dropin_dir.glob("*.conf")):
+            parts.append(dropin.read_text(encoding="utf-8"))
+            read.append(dropin)
+    return "\n".join(parts), read
+
+
+def _execstart_instances(text: str, script: str) -> int | None:
+    """Effectif N lu dans l'`ExecStart` du wrapper `script`.
+
+    Formes rencontrees dans le deploiement : `... <script> 12` et
+    `... <script> start 4`. Le N est le DERNIER jeton entier de la ligne --
+    l'unite `start` porte un sous-commande textuelle avant lui. Derniere
+    definition gagne (un drop-in peut redefinir l'ExecStart).
+    """
+    found: int | None = None
+    for m in re.finditer(rf"^ExecStart=.*{re.escape(script)}\s+(.+)$", text, re.MULTILINE):
+        tail = m.group(1).strip().split("#", 1)[0].strip()
+        for tok in reversed(tail.split()):
+            if tok.isdigit():
+                found = int(tok)
+                break
+    return found
+
+
+def _cap_gib_from_env(text: str, var: str, default_mib: int) -> float:
+    """Cap memoire unitaire (GiB) lu dans `Environment=<var>=<valeur>`.
+
+    Derniere definition gagne. Sans declaration, le defaut de l'unite est pris
+    (le cap par defaut est documente en tete du wrapper, il ne derive pas au
+    meme rythme que l'effectif).
+    """
+    value: str | None = None
+    for m in re.finditer(rf'^Environment="?{re.escape(var)}=([^"\s]+)"?', text, re.MULTILINE):
+        value = m.group(1)
+    if value is None:
+        return default_mib / 1024
+    m = re.match(r"^(\d+)([gGmM])?$", value.strip())
+    if not m:
+        return default_mib / 1024
+    n = int(m.group(1))
+    return float(n) if (m.group(2) or "").lower() == "g" else n / 1024
+
+
+@dataclass
+class CompositionFamily:
+    instances: int
+    cap_gib: float
+    total_gib: float
+
+
+@dataclass
+class BudgetSnapshot:
+    machine: str
+    composition: dict[str, CompositionFamily]
+    composition_total_gib: float
+    notes: str = ""
+
+    @classmethod
+    def from_json(cls, path: Path) -> BudgetSnapshot:
+        data = json.loads(path.read_text(encoding="utf-8"))
+        comp: dict[str, CompositionFamily] = {}
+        for name, fam in data.get("composition", {}).items():
+            comp[name] = CompositionFamily(
+                instances=int(fam["instances"]),
+                cap_gib=float(fam["cap_gib"]),
+                total_gib=float(fam["total_gib"]),
+            )
+        return cls(
+            machine=data["machine"],
+            composition=comp,
+            composition_total_gib=float(data["composition_total_gib"]),
+            notes=data.get("notes", ""),
+        )
+
+    @classmethod
+    def from_supervise_defaults(cls, supervise_path: Path, machine: str) -> BudgetSnapshot:
+        """Derive la composition depuis les defauts `supervise.sh`.
+
+        #19805 revue coordinateur 2026-10-08 (defaut 1) : le snapshot JSON
+        maintenu a la main derive a chaque push supervise.sh, et l'organe
+        mesurait alors son propre instantane, pas le deploiement. Lecture
+        directe des defauts (MEMORY/CPUS par famille, N par defaut documente
+        en tete du fichier) -- la composition suit les caps reels.
+
+        Le nombre de slots par defaut est lu dans l'en-tete USAGE du fichier
+        (le superviseur documente `defaut 2`, `defaut 24`, `defaut 2` pour
+        start/waiters/lean) ; un override par machine vit dans le wrapper
+        `persist/<machine>/coursia-runner.service.d/10-sizing.conf` et
+        n'est PAS releve ici (l'organe mesure le DEFAUT, l'override est
+        verifie par l'operateur ou un autre organe).
+        """
+        text = supervise_path.read_text(encoding="utf-8")
+
+        def _cap_gib(var: str, default_mb: int) -> float:
+            m = re.search(rf'^{var}="?(\d+)([gGmM])"?', text, re.MULTILINE)
+            if not m:
+                return default_mb / 1024
+            val = int(m.group(1))
+            unit = m.group(2).lower()
+            if unit == "g":
+                return float(val)
+            return val / 1024
+
+        start_cap = _cap_gib("COURSIA_RUNNER_MEMORY", 1536)
+        waiters_cap = _cap_gib("COURSIA_RUNNER_WAITER_MEMORY", 512)
+        lean_cap = _cap_gib("COURSIA_LEAN_RUNNER_MEMORY", 6 * 1024)
+
+        # N par defaut documente en tete du fichier :
+        #   "N slots (defaut 2)" (start)
+        #   "N slots d'attente PR-gate (label coursia-waiter, defaut 24)"
+        #   "N slots Lean specialises (..., defaut 2)"
+        n_start = 2
+        n_waiters = 24
+        n_lean = 2
+
+        comp = {
+            "start": CompositionFamily(
+                instances=n_start,
+                cap_gib=start_cap,
+                total_gib=round(n_start * start_cap, 3),
+            ),
+            "waiters": CompositionFamily(
+                instances=n_waiters,
+                cap_gib=waiters_cap,
+                total_gib=round(n_waiters * waiters_cap, 3),
+            ),
+            "lean": CompositionFamily(
+                instances=n_lean,
+                cap_gib=lean_cap,
+                total_gib=round(n_lean * lean_cap, 3),
+            ),
+        }
+        total = round(sum(f.total_gib for f in comp.values()), 3)
+        # Le chemin peut etre hors-repo (tests, run ad-hoc) : on note l'absolu
+        # en repli, pas un crash sur relative_to.
+        try:
+            rel = supervise_path.relative_to(REPO_ROOT)
+            notes = f"derive de {rel} (defauts)"
+        except ValueError:
+            notes = f"derive de {supervise_path} (defauts, hors-repo)"
+        return cls(
+            machine=machine,
+            composition=comp,
+            composition_total_gib=total,
+            notes=notes,
+        )
+
+    @classmethod
+    def from_deployed_units(
+        cls, machine: str, persist_dir: Path | None = None
+    ) -> BudgetSnapshot:
+        """Composition derivee des unites DEPLOYEES pour `machine`.
+
+        #19805 revue coordinateur 2026-10-08 (defaut 1) : la composition doit
+        suivre ce que la machine EXECUTE. Ni le snapshot JSON ni les valeurs
+        documentees en en-tete de `supervise.sh` ne sont le deploiement -- le
+        premier est recopie a la main, les secondes ont derive (24 slots
+        d'attente documentes quand l'unite en lance 12, et 6 sur po-2024).
+
+        Resolution par jambe : le drop-in `persist/<machine>/<unite>.d/*.conf`
+        s'il redefinit l'`ExecStart`, sinon l'unite de base `persist/<unite>`.
+        L'effectif vient de l'`ExecStart` (dernier jeton entier), le cap de
+        l'`Environment=` de la meme unite, avec le defaut de la jambe en repli.
+        """
+        root = persist_dir if persist_dir is not None else PERSIST_DIR
+        comp: dict[str, CompositionFamily] = {}
+        sources: list[str] = []
+        missing: list[str] = []
+
+        for name, unit, script, var, default_mib in RUNNER_LEGS:
+            text, files = _deployed_unit_text(machine, unit, root)
+            if not files:
+                missing.append(str(root / unit))
+                continue
+            instances = _execstart_instances(text, script)
+            if instances is None:
+                missing.append(f"{root / unit} (ExecStart {script} illisible)")
+                continue
+            cap = _cap_gib_from_env(text, var, default_mib)
+            sources.append(f"{name}={instances}x{cap:g}G")
+            comp[name] = CompositionFamily(
+                instances=instances,
+                cap_gib=cap,
+                total_gib=round(instances * cap, 3),
+            )
+
+        if missing:
+            raise FileNotFoundError(
+                "unite(s) de jambe introuvable(s) ou illisible(s) : "
+                + ", ".join(missing)
+            )
+
+        total = round(sum(f.total_gib for f in comp.values()), 3)
+        return cls(
+            machine=machine,
+            composition=comp,
+            composition_total_gib=total,
+            notes=(
+                f"derive des unites deployees ({machine}) : "
+                + ", ".join(sources)
+            ),
+        )
+
+
+def parse_memory_max_gib(slice_path: Path) -> float | None:
+    """Lit `MemoryMax=` (ou `MemoryHigh=`) depuis une unit slice systemd.
+
+    Le format attendu est `MemoryMax=16G`, `MemoryMax=2048M`, `MemoryMax=infinity`.
+    Renvoie None si absent ou si valeur = infinity.
+    """
+    if not slice_path.is_file():
+        return None
+    text = slice_path.read_text(encoding="utf-8")
+    # MemoryMax prime (plafond dur). Si absent, fallback MemoryHigh.
+    for key in ("MemoryMax", "MemoryHigh"):
+        m = re.search(rf"^{key}=(.+)$", text, re.MULTILINE)
+        if m:
+            raw = m.group(1).strip()
+            if raw.lower() in ("infinity", "max"):
+                continue
+            unit = raw[-1]
+            try:
+                val = float(raw[:-1])
+            except ValueError:
+                continue
+            if unit == "G":
+                return val
+            if unit == "M":
+                return round(val / 1024, 3)
+            if unit == "K":
+                return round(val / (1024 * 1024), 6)
+            if unit == "T":
+                return val * 1024
+    return None
+
+
+@dataclass
+class AssertResult:
+    machine: str
+    vm_total_gib: float | None
+    composition_total_gib: float
+    slice_memory_max_gib: float | None
+    borne_gib: float
+    marge_gib: float
+    verdict: str  # "OK" | "INCOHERENT"
+    # Provenance de la composition (unites deployees / supervise.sh / JSON).
+    # Portee au verdict pour que le lecteur sache CE QUI a ete mesure : un
+    # organe qui confronte une composition doit dire d'ou elle vient, sinon
+    # « 15 GiB » ne se distingue pas de « 27 GiB » comme resultat.
+    source: str = ""
+    details: list[str] = field(default_factory=list)
+
+
+def assert_memory_budget(
+    budget: BudgetSnapshot,
+    vm_total_gib: float | None,
+    slice_memory_max_gib: float | None,
+    marge_gib: float = DEFAULT_MARGE_GIB,
+) -> AssertResult:
+    # Borne la plus contraignante = min(slice_max, RAM VM).
+    bornes: list[float] = []
+    if slice_memory_max_gib is not None:
+        bornes.append(slice_memory_max_gib)
+    if vm_total_gib is not None:
+        # On reserve HOST_RESERVED_GIB a l'hote non-CI (mesure po-2024 :
+        # la VM est partagee avec d'autres services via Docker Desktop).
+        bornes.append(max(0.0, vm_total_gib - HOST_RESERVED_GIB))
+    borne_gib = min(bornes) if bornes else float("inf")
+
+    seuil = borne_gib - marge_gib
+    incoherence = budget.composition_total_gib > seuil
+
+    details: list[str] = []
+    for name, fam in budget.composition.items():
+        details.append(
+            f"  {name:>10s} : {fam.instances:>3d} x {fam.cap_gib:>5.1f} GiB "
+            f"= {fam.total_gib:>6.1f} GiB"
+        )
+    details.append(f"  {'TOTAL':>10s} : {'':>3s}   {'':>6s}   {budget.composition_total_gib:>6.1f} GiB")
+    if vm_total_gib is not None:
+        details.append(f"  VM RAM        : {vm_total_gib:>6.1f} GiB  (hote reserve {HOST_RESERVED_GIB} GiB)")
+    if slice_memory_max_gib is not None:
+        details.append(f"  Slice MemoryMax: {slice_memory_max_gib:>6.1f} GiB")
+    details.append(f"  Borne         : {borne_gib:>6.1f} GiB  (marge {marge_gib} GiB, seuil {seuil:.1f} GiB)")
+
+    return AssertResult(
+        machine=budget.machine,
+        vm_total_gib=vm_total_gib,
+        composition_total_gib=budget.composition_total_gib,
+        slice_memory_max_gib=slice_memory_max_gib,
+        borne_gib=borne_gib,
+        marge_gib=marge_gib,
+        verdict="INCOHERENT" if incoherence else "OK",
+        source=budget.notes,
+        details=details,
+    )
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(description=__doc__.split("\n", 1)[0])
+    parser.add_argument(
+        "--budget",
+        type=Path,
+        default=DEFAULT_BUDGET,
+        help=f"Snapshot JSON de la composition, lu seulement avec --from-json "
+             f"(defaut: {DEFAULT_BUDGET.relative_to(REPO_ROOT)})",
+    )
+    parser.add_argument(
+        "--slice",
+        type=Path,
+        default=DEFAULT_SLICE,
+        help=f"Unit slice systemd (defaut: {DEFAULT_SLICE.relative_to(REPO_ROOT)})",
+    )
+    parser.add_argument(
+        "--marge",
+        type=float,
+        default=DEFAULT_MARGE_GIB,
+        help=f"Marge de securite en GiB (defaut: {DEFAULT_MARGE_GIB})",
+    )
+    parser.add_argument(
+        "--from-json",
+        action="store_true",
+        help="Composition depuis le snapshot JSON (--budget). Comparaison/audit "
+             "seulement : le snapshot est recopie a la main et derive.",
+    )
+    parser.add_argument(
+        "--from-supervise",
+        action="store_true",
+        help="Composition depuis les defauts documentes de supervise.sh. Repli "
+             "pour une machine sans unites deployees au depot.",
+    )
+    parser.add_argument(
+        "--machine",
+        default="po-2024",
+        help="Machine-cible verifiee (defaut: po-2024). Definit la surcharge slice et la RAM VM.",
+    )
+    parser.add_argument(
+        "--json",
+        action="store_true",
+        help="Sortie JSON sur stdout (sinon texte)",
+    )
+    args = parser.parse_args(argv)
+
+    # Composition : les unites DEPLOYEES par defaut (#19805 revue coordinateur
+    # 2026-10-08, defaut 1). Ni le snapshot JSON (recopie a la main) ni les
+    # valeurs documentees de supervise.sh ne sont le deploiement : les deux ont
+    # derive. Les deux restent disponibles pour l'audit et le repli, jamais
+    # comme voie par defaut -- un organe qui mesure sa propre constante ne
+    # mesure rien.
+    if args.from_json:
+        if not args.budget.is_file():
+            print(f"Budget snapshot introuvable: {args.budget}", file=sys.stderr)
+            return 2
+        budget = BudgetSnapshot.from_json(args.budget)
+    elif args.from_supervise:
+        if not DEFAULT_SUPERVISE.is_file():
+            print(f"supervise.sh introuvable: {DEFAULT_SUPERVISE}", file=sys.stderr)
+            return 2
+        budget = BudgetSnapshot.from_supervise_defaults(DEFAULT_SUPERVISE, args.machine)
+    else:
+        try:
+            budget = BudgetSnapshot.from_deployed_units(args.machine)
+        except FileNotFoundError as exc:
+            print(f"{exc}", file=sys.stderr)
+            return 2
+
+    # RAM VM de la machine-CIBLE (#19805 revue coordinateur 2026-10-08,
+    # defaut 3) : declaree comme constante, PAS mesuree sur l'hote de l'organe.
+    # Mesurer l'hote rend un verdict incoherent (cf. PO2024_VM_RAM_GIB).
+    vm_total_gib = lookup_vm_ram_gib(budget.machine)
+    if vm_total_gib is None:
+        # Machine inconnue : l'organe ne peut pas verifier une borne VM. Il
+        # fonctionne en mode "slice seule", la borne est la MemoryMax de la
+        # surcharge de slice. C'est un sous-ensemble du verdict -- le marquer.
+        print(
+            f"[WARN] RAM VM non declaree pour machine='{budget.machine}' -- "
+            f"verdict sur slice seule. Etendre _MACHINE_VM_RAM_GIB.",
+            file=sys.stderr,
+        )
+
+    # Surcharge slice machine d'abord, generique en repli (#19805 revue
+    # coordinateur 2026-10-08, defaut 2).
+    slice_path = lookup_slice(budget.machine)
+    slice_max = parse_memory_max_gib(slice_path)
+
+    result = assert_memory_budget(budget, vm_total_gib, slice_max, args.marge)
+
+    if args.json:
+        print(json.dumps(asdict(result), indent=2, ensure_ascii=False))
+    else:
+        print(f"[{result.verdict}] {result.machine} : "
+              f"composition {result.composition_total_gib:.1f} GiB vs "
+              f"borne {result.borne_gib:.1f} GiB (marge {result.marge_gib} GiB)")
+        if result.source:
+            print(f"  Source        : {result.source}")
+        for line in result.details:
+            print(line)
+
+    return 1 if result.verdict == "INCOHERENT" else 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())
diff --git a/scripts/tests/test_assert_memory_budget.py b/scripts/tests/test_assert_memory_budget.py
new file mode 100644
index 0000000000..a17e095893
--- /dev/null
+++ b/scripts/tests/test_assert_memory_budget.py
@@ -0,0 +1,423 @@
+"""Tests pour assert_memory_budget (#19805)."""
+from __future__ import annotations
+
+import json
+import sys
+from pathlib import Path
+
+import pytest
+
+REPO_ROOT = Path(__file__).resolve().parent.parent.parent
+sys.path.insert(0, str(REPO_ROOT / "scripts" / "ci"))
+sys.path.insert(0, str(REPO_ROOT / "scripts" / "tests"))
+
+from assert_memory_budget import (  # type: ignore  # noqa: E402
+    PO2024_VM_RAM_GIB,
+    BudgetSnapshot,
+    CompositionFamily,
+    assert_memory_budget,
+    lookup_slice,
+    lookup_vm_ram_gib,
+    parse_memory_max_gib,
+)
+
+
+REPO_BUDGET = REPO_ROOT / "docker-configurations" / "runners" / "po2024_budget.json"
+REPO_SLICE = REPO_ROOT / "scripts" / "ci" / "docker" / "linux-runner" / "persist" / "coursia-ci.slice"
+
+
+def test_budget_snapshot_loads():
+    """Le snapshot canonique est lisible et structure conforme."""
+    snap = BudgetSnapshot.from_json(REPO_BUDGET)
+    assert snap.machine == "po-2024"
+    assert snap.composition_total_gib == 27.0
+    assert "docker" in snap.composition
+    assert "waiters" in snap.composition
+    assert "lean" in snap.composition
+    assert snap.composition["lean"].instances == 2
+    assert snap.composition["lean"].cap_gib == 6.0
+    assert snap.composition["lean"].total_gib == 12.0
+
+
+def test_budget_snapshot_total_matches_sum():
+    """La somme des familles = composition_total_gib (coherence interne)."""
+    snap = BudgetSnapshot.from_json(REPO_BUDGET)
+    summed = sum(f.total_gib for f in snap.composition.values())
+    assert abs(summed - snap.composition_total_gib) < 0.01
+
+
+def test_parse_memory_max_gib_slice():
+    """Lecture de MemoryMax depuis la slice canonique = 16 GiB."""
+    val = parse_memory_max_gib(REPO_SLICE)
+    assert val == 16.0
+
+
+def test_parse_memory_max_gib_handles_units():
+    """G, M, T supportes ; infinity ignore."""
+    import tempfile
+
+    with tempfile.NamedTemporaryFile(mode="w", suffix=".slice", delete=False) as f:
+        f.write("[Slice]\nMemoryMax=8G\n")
+        path = Path(f.name)
+    try:
+        assert parse_memory_max_gib(path) == 8.0
+    finally:
+        path.unlink()
+
+    with tempfile.NamedTemporaryFile(mode="w", suffix=".slice", delete=False) as f:
+        f.write("[Slice]\nMemoryMax=2048M\n")
+        path = Path(f.name)
+    try:
+        assert parse_memory_max_gib(path) == 2.0
+    finally:
+        path.unlink()
+
+    with tempfile.NamedTemporaryFile(mode="w", suffix=".slice", delete=False) as f:
+        f.write("[Slice]\nMemoryMax=infinity\n")
+        path = Path(f.name)
+    try:
+        assert parse_memory_max_gib(path) is None
+    finally:
+        path.unlink()
+
+
+def test_assert_incoherent_po2024_snapshot():
+    """Le snapshot canonique (27 GiB) depasse le MemoryMax slice (16 GiB) -> INCOHERENT."""
+    snap = BudgetSnapshot.from_json(REPO_BUDGET)
+    result = assert_memory_budget(snap, vm_total_gib=23.47, slice_memory_max_gib=16.0)
+    assert result.verdict == "INCOHERENT"
+    assert result.borne_gib == 16.0  # min(16, 23.47-0.5) = 16.0
+    assert result.composition_total_gib == 27.0
+
+
+def test_assert_ok_when_composition_under_budget():
+    """Composition 10 GiB < MemoryMax 16 GiB et VM 23.47 GiB -> OK."""
+    snap = BudgetSnapshot(
+        machine="test",
+        composition={
+            "small": CompositionFamily(instances=2, cap_gib=2.0, total_gib=4.0),
+            "tiny": CompositionFamily(instances=12, cap_gib=0.5, total_gib=6.0),
+        },
+        composition_total_gib=10.0,
+    )
+    result = assert_memory_budget(snap, vm_total_gib=23.47, slice_memory_max_gib=16.0)
+    assert result.verdict == "OK"
+
+
+def test_assert_ok_when_no_slice_uses_vm():
+    """Sans slice (slice_memory_max_gib=None), on n'utilise que la RAM VM."""
+    snap = BudgetSnapshot(
+        machine="test",
+        composition={
+            "small": CompositionFamily(instances=2, cap_gib=2.0, total_gib=4.0),
+        },
+        composition_total_gib=4.0,
+    )
+    result = assert_memory_budget(snap, vm_total_gib=23.47, slice_memory_max_gib=None)
+    assert result.verdict == "OK"
+    assert result.borne_gib == 23.47 - 0.5  # hote reserve
+
+
+def test_assert_incoherent_when_above_vm_only():
+    """Composition > VM-hote mais < slice -> la borne la plus contraignante tranche."""
+    snap = BudgetSnapshot(
+        machine="test",
+        composition={
+            "big": CompositionFamily(instances=4, cap_gib=5.0, total_gib=20.0),
+        },
+        composition_total_gib=20.0,
+    )
+    # slice 25 GiB, VM 23.47 GiB : borne = min(25, 23.47-0.5) = 22.97 ; 20 < 22.97 -> OK
+    result = assert_memory_budget(snap, vm_total_gib=23.47, slice_memory_max_gib=25.0)
+    assert result.verdict == "OK"
+    # Si la VM est plus petite (16 GiB), borne = 15.5 ; 20 > 15.5 -> INCOHERENT
+    result = assert_memory_budget(snap, vm_total_gib=16.0, slice_memory_max_gib=25.0)
+    assert result.verdict == "INCOHERENT"
+
+
+def test_marge_absorbs_overhead():
+    """La marge de 0.5 GiB absorbe un leger depassement (<= marge)."""
+    snap = BudgetSnapshot(
+        machine="test",
+        composition={
+            "exact": CompositionFamily(instances=8, cap_gib=2.0, total_gib=15.5),
+        },
+        composition_total_gib=15.5,
+    )
+    # Borne 16.0, seuil 16.0 - 0.5 = 15.5 ; exactement egal -> OK
+    result = assert_memory_budget(snap, vm_total_gib=23.47, slice_memory_max_gib=16.0)
+    assert result.verdict == "OK"
+
+
+def test_snapshot_json_well_formed():
+    """Le snapshot JSON a toutes les cles attendues et des types coherents."""
+    data = json.loads(REPO_BUDGET.read_text(encoding="utf-8"))
+    assert data["machine"] == "po-2024"
+    assert "composition" in data
+    assert "composition_total_gib" in data
+    for name, fam in data["composition"].items():
+        assert "instances" in fam
+        assert "cap_gib" in fam
+        assert "total_gib" in fam
+        # Sanity : total_gib = instances * cap_gib (coherence)
+        assert abs(fam["total_gib"] - fam["instances"] * fam["cap_gib"]) < 0.01
+
+
+# -- Tests pour les 3 fixes revue coordinateur 2026-10-08 (defauts 1, 2, 3) --
+
+
+def test_lookup_vm_ram_gib_po2024():
+    """Defaut 3 : la RAM VM est declaree comme constante par machine-cible.
+
+    Mesurer l'hote de l'organe rend un verdict incoherent (organe sur ai-01
+    avec 191.8 GiB dirait 'po-2024 = 191.8 GiB', et l'instrument ne servirait
+    plus a rien). La RAM est une propriete de la machine VERIFIEE, pas de
+    celle qui execute.
+    """
+    assert lookup_vm_ram_gib("po-2024") == PO2024_VM_RAM_GIB
+    assert PO2024_VM_RAM_GIB == 24.0  # PR #19802
+
+
+def test_lookup_vm_ram_gib_unknown_returns_none():
+    """Machine non referencee -> None, l'organe travaille en mode slice seule."""
+    assert lookup_vm_ram_gib("po-2030-unknown") is None
+    assert lookup_vm_ram_gib("") is None
+
+
+def test_lookup_slice_machine_override_wins_on_real_po2024():
+    """Defaut 2, sur le depot reel : la surcharge po-2024 prime sur la generique.
+
+    `persist/po-2024/coursia-ci.slice` est materialisee sur `main` depuis
+    #19802. Le test precedent affirmait le repli sur la generique en se
+    fondant sur l'absence de ce fichier : son postulat a disparu avec le
+    deploiement, il n'etait donc plus un test de l'organe mais un test de
+    l'etat du depot.
+    """
+    path = lookup_slice("po-2024")
+    assert path == REPO_SLICE.parent / "po-2024" / "coursia-ci.slice"
+    assert path.is_file()
+    assert parse_memory_max_gib(path) == 16.0
+
+
+def test_lookup_slice_falls_back_to_generic_for_unknown_machine():
+    """Machine sans surcharge : repli sur la generique, sans crasher."""
+    path = lookup_slice("po-9999-unknown")
+    assert path == REPO_SLICE
+    assert path.is_file()
+
+
+def test_lookup_slice_machine_override_wins(tmp_path):
+    """Si une surcharge machine existe, elle prime sur la generique."""
+    override = tmp_path / "scripts" / "ci" / "docker" / "linux-runner" / "persist" / "po-2024" / "coursia-ci.slice"
+    override.parent.mkdir(parents=True)
+    override.write_text("[Slice]\nMemoryMax=20G\n", encoding="utf-8")
+
+    import assert_memory_budget as amb
+    original_root = amb.REPO_ROOT
+    amb.REPO_ROOT = tmp_path
+    try:
+        path = lookup_slice("po-2024")
+        assert path == override
+        assert parse_memory_max_gib(path) == 20.0
+    finally:
+        amb.REPO_ROOT = original_root
+
+
+def test_from_supervise_defaults_reads_caps():
+    """Defaut 1 : derivation depuis supervise.sh lit les defauts MEMORY/CPUS.
+
+    Le superviseur documente en tete les N par defaut (2 start, 24 waiters,
+    2 lean) et expose les caps via variables d'env. La derivation doit
+    reproduire l'esprit du deploiement reel sans dependre du snapshot JSON
+    maintenu a la main.
+    """
+    import tempfile
+
+    with tempfile.NamedTemporaryFile(mode="w", suffix=".sh", delete=False) as f:
+        f.write('#!/usr/bin/env bash\n')
+        f.write('COURSIA_RUNNER_MEMORY="1536m"\n')
+        f.write('COURSIA_RUNNER_WAITER_MEMORY="512m"\n')
+        f.write('COURSIA_LEAN_RUNNER_MEMORY="6g"\n')
+        f.write('echo "defaut 2 start, 24 waiters, 2 lean"\n')
+        path = Path(f.name)
+    try:
+        snap = BudgetSnapshot.from_supervise_defaults(path, "po-2024")
+        # 2 x 1.5 + 24 x 0.5 + 2 x 6.0 = 3 + 12 + 12 = 27.0 GiB
+        assert snap.composition_total_gib == 27.0
+        assert snap.composition["start"].instances == 2
+        assert snap.composition["start"].cap_gib == 1.5
+        assert snap.composition["waiters"].instances == 24
+        assert snap.composition["waiters"].cap_gib == 0.5
+        assert snap.composition["lean"].instances == 2
+        assert snap.composition["lean"].cap_gib == 6.0
+        assert snap.notes  # trace de provenance
+    finally:
+        path.unlink()
+
+
+def test_from_supervise_defaults_falls_back_when_missing():
+    """Variables absentes -> defauts code en dur (defaut 1 securite)."""
+    import tempfile
+
+    with tempfile.NamedTemporaryFile(mode="w", suffix=".sh", delete=False) as f:
+        f.write('#!/usr/bin/env bash\n')
+        f.write('echo "rien ici"\n')
+        path = Path(f.name)
+    try:
+        snap = BudgetSnapshot.from_supervise_defaults(path, "po-2024")
+        # Defauts code en dur : 1536m / 512m / 6g -> 1.5 / 0.5 / 6.0
+        assert snap.composition["start"].cap_gib == 1.5
+        assert snap.composition["waiters"].cap_gib == 0.5
+        assert snap.composition["lean"].cap_gib == 6.0
+    finally:
+        path.unlink()
+
+
+# --------------------------------------------------------------------------
+# Composition derivee des unites DEPLOYEES (defaut 1, revue coordinateur du
+# 2026-10-08). Ces tests portent sur le fichier des unites, pas sur un
+# instantane : c'est le point du defaut -- l'organe doit suivre le
+# deploiement, donc le postulat du test doit lui aussi etre lu au deploiement.
+# --------------------------------------------------------------------------
+
+
+def test_from_deployed_units_follows_the_dropin_on_real_po2024():
+    """L'effectif waiters vient du drop-in deploye, pas d'une constante.
+
+    po-2024 abaisse l'effectif de la jambe waiters par un drop-in, sans
+    toucher l'unite partagee avec ai-01. Un organe qui lit une constante
+    (24 documentes, 12 dans l'unite generique) annonce 12 ou 24 slots la ou
+    la machine en execute 6, et rougit a tort. Le drop-in est re-parse ici :
+    l'organe n'est pas cru sur parole.
+    """
+    import re as _re
+
+    persist = REPO_ROOT / "scripts" / "ci" / "docker" / "linux-runner" / "persist"
+    dropin = persist / "po-2024" / "coursia-waiters.service.d" / "10-sizing.conf"
+    assert dropin.is_file(), "drop-in po-2024 attendu sur main (#19802)"
+    dm = _re.search(
+        r"^ExecStart=.*coursia-waiters-start\.sh\s+(\d+)",
+        dropin.read_text(encoding="utf-8"),
+        _re.MULTILINE,
+    )
+    assert dm, "ExecStart attendu dans le drop-in"
+    expected = int(dm.group(1))
+
+    snap = BudgetSnapshot.from_deployed_units("po-2024")
+    assert snap.machine == "po-2024"
+    assert set(snap.composition) == {"start", "waiters", "lean"}
+    assert snap.composition["waiters"].instances == expected
+
+    # L'unite generique (celle d'ai-01) ne doit PAS gagner quand elle differe :
+    # ce serait un dimensionnement pris sur une machine et applique a l'autre.
+    gm = _re.search(
+        r"^ExecStart=.*coursia-waiters-start\.sh\s+(\d+)",
+        (persist / "coursia-waiters.service").read_text(encoding="utf-8"),
+        _re.MULTILINE,
+    )
+    if gm and int(gm.group(1)) != expected:
+        assert snap.composition["waiters"].instances != int(gm.group(1))
+
+    summed = sum(f.total_gib for f in snap.composition.values())
+    assert abs(summed - snap.composition_total_gib) < 0.01
+    assert snap.notes
+
+
+def test_from_deployed_units_dropin_beats_base_unit(tmp_path):
+    """Un drop-in qui redefinit l'ExecStart gagne sur l'unite de base."""
+    (tmp_path / "coursia-runner.service").write_text(
+        "[Service]\nExecStart=/usr/local/bin/coursia-runner-start.sh start 4\n",
+        encoding="utf-8",
+    )
+    (tmp_path / "coursia-waiters.service").write_text(
+        "[Service]\nExecStart=/usr/local/bin/coursia-waiters-start.sh 12\n",
+        encoding="utf-8",
+    )
+    (tmp_path / "coursia-lean.service").write_text(
+        "[Service]\nExecStart=/usr/local/bin/coursia-lean-start.sh 2\n",
+        encoding="utf-8",
+    )
+    dropin_dir = tmp_path / "po-2024" / "coursia-waiters.service.d"
+    dropin_dir.mkdir(parents=True)
+    # Forme systemd reelle : ExecStart= vide (reset) puis la nouvelle ligne.
+    (dropin_dir / "10-sizing.conf").write_text(
+        "[Service]\nExecStart=\n"
+        "ExecStart=/usr/local/bin/coursia-waiters-start.sh 6\n",
+        encoding="utf-8",
+    )
+
+    snap = BudgetSnapshot.from_deployed_units("po-2024", tmp_path)
+    assert snap.composition["start"].instances == 4
+    assert snap.composition["waiters"].instances == 6  # le drop-in gagne
+    assert snap.composition["lean"].instances == 2
+    # Caps non declares -> defauts de la jambe (1536m / 512m / 6g).
+    assert snap.composition["start"].total_gib == 6.0
+    assert snap.composition["waiters"].total_gib == 3.0
+    assert snap.composition["lean"].total_gib == 12.0
+    assert snap.composition_total_gib == 21.0
+
+
+def test_from_deployed_units_reads_cap_from_environment(tmp_path):
+    """Le cap unitaire vient de `Environment=` quand l'unite le declare."""
+    (tmp_path / "coursia-runner.service").write_text(
+        "[Service]\nEnvironment=COURSIA_RUNNER_MEMORY=2g\n"
+        "ExecStart=/usr/local/bin/coursia-runner-start.sh start 2\n",
+        encoding="utf-8",
+    )
+    (tmp_path / "coursia-waiters.service").write_text(
+        "[Service]\nEnvironment=COURSIA_RUNNER_WAITER_MEMORY=256m\n"
+        "ExecStart=/usr/local/bin/coursia-waiters-start.sh 4\n",
+        encoding="utf-8",
+    )
+    (tmp_path / "coursia-lean.service").write_text(
+        "[Service]\nExecStart=/usr/local/bin/coursia-lean-start.sh 1\n",
+        encoding="utf-8",
+    )
+    snap = BudgetSnapshot.from_deployed_units("po-2024", tmp_path)
+    assert snap.composition["start"].cap_gib == 2.0
+    assert snap.composition["waiters"].cap_gib == 0.25
+    assert snap.composition["start"].total_gib == 4.0
+    assert snap.composition["waiters"].total_gib == 1.0
+
+
+def test_from_deployed_units_missing_unit_raises(tmp_path):
+    """Une jambe absente leve : l'organe ne devine pas un effectif."""
+    (tmp_path / "coursia-runner.service").write_text(
+        "ExecStart=/usr/local/bin/coursia-runner-start.sh start 4\n",
+        encoding="utf-8",
+    )
+    with pytest.raises(FileNotFoundError):
+        BudgetSnapshot.from_deployed_units("po-2024", tmp_path)
+
+
+def test_from_deployed_units_missing_execstart_raises(tmp_path):
+    """Unite presente mais ExecStart illisible : refus, pas d'effectif invente."""
+    for unit in ("coursia-runner.service", "coursia-waiters.service", "coursia-lean.service"):
+        (tmp_path / unit).write_text("[Service]\nDescription=vide\n", encoding="utf-8")
+    with pytest.raises(FileNotFoundError):
+        BudgetSnapshot.from_deployed_units("po-2024", tmp_path)
+
+
+def test_cli_default_reads_deployed_units_not_snapshot():
+    """Le defaut de la CLI est le deploiement -- pas le JSON recopie a la main.
+
+    Le workflow CI appelle l'organe SANS drapeau. Si le defaut redevenait le
+    snapshot, l'organe remesurerait sa propre constante et le rouge fondateur
+    reviendrait sans qu'aucun test ne le signale : c'est ce que ce test ferme.
+    """
+    import subprocess
+
+    proc = subprocess.run(
+        [sys.executable, str(REPO_ROOT / "scripts" / "ci" / "assert_memory_budget.py"), "--json"],
+        capture_output=True,
+        text=True,
+        encoding="utf-8",
+        cwd=str(REPO_ROOT),
+    )
+    payload = json.loads(proc.stdout)
+    assert "unites deployees" in payload["source"]
+    joined = "\n".join(payload["details"])
+    for leg in ("start", "waiters", "lean"):
+        assert leg in joined
+    assert "docker" not in joined  # la famille du snapshot JSON, pas du deploiement
+    assert proc.returncode == (1 if payload["verdict"] == "INCOHERENT" else 0)