diff --git a/.claude/rules/04-code-conventions.md b/.claude/rules/04-code-conventions.md
index a5943ba..071cc63 100644
--- a/.claude/rules/04-code-conventions.md
+++ b/.claude/rules/04-code-conventions.md
@@ -60,7 +60,12 @@ python3 script/analyse/check_comment_hygiene.py --staged
 
 🔴 `identifiant` est une trouvaille, à retirer. 🟡 `récit` est un signal à
 relire : l'outil ne sait pas si la phrase énonce un fait durable ou raconte
-une journée, et ne tranche pas à votre place.
+une journée, et ne tranche pas à votre place. 🟡 `nom` en est un autre, et sa
+limite est plus dure : un nom d'hôte NU ne se distingue mécaniquement ni d'un
+mot ordinaire ni du nom d'un logiciel, donc l'outil ne voit que la forme
+pleinement qualifiée. Un miroir de paquets nommé dans un commentaire y
+répond, et se confirme d'un coup d'œil ; l'absence de signal ne prouve rien
+sur les noms.
 
 Trois exemples pris dans ce dépôt, leurs noms propres masqués — une règle qui
 interdit de nommer ne se cite pas elle-même en clair.
diff --git a/script/analyse/check_comment_hygiene.py b/script/analyse/check_comment_hygiene.py
index 65b449a..a2e8f8d 100755
--- a/script/analyse/check_comment_hygiene.py
+++ b/script/analyse/check_comment_hygiene.py
@@ -8,7 +8,7 @@ La convention est dans `.claude/rules/04-code-conventions.md` : un commentaire
 dit COMMENT le code marche, il ne porte aucune donnée identifiante et il ne
 raconte pas l'enquête. Cet outil en vérifie la part mécanique.
 
-Deux familles, de sûreté très différente :
+Trois familles, de sûreté très différente :
 
 - `identifiant` — adresse IP, courriel, chemin de compte. Une
   correspondance est une trouvaille : ces formes n'ont aucune raison d'être
@@ -17,6 +17,12 @@ Deux familles, de sûreté très différente :
   absolue, première personne. Une correspondance est un SIGNAL À RELIRE : la
   même phrase peut énoncer un fait durable. L'outil ne trie pas à la place
   du lecteur.
+- `nom` — un nom de machine pleinement qualifié. Aussi un signal à relire,
+  et pour une raison plus dure : un nom d'hôte NU ne se distingue
+  mécaniquement ni d'un mot ordinaire ni du nom d'un logiciel, donc cette
+  famille ne voit que la forme qualifiée. Les miroirs de paquets nommés dans
+  un commentaire y répondent, et c'est le prix d'un signal mécanique — le
+  lecteur confirme en deux secondes, là où la classe entière était invisible.
 
 Il lit les commentaires `#` et, en Python, les docstrings de module, de classe
 et de fonction. Le reste du code ne l'intéresse pas.
@@ -116,6 +122,64 @@ MOTIFS_RECIT = (
     ("personne", PERSONNE),
 )
 
+# Le nom de machine est la SEULE classe interdite qu'aucun motif ne tranche :
+# un nom d'hôte ne se distingue mécaniquement ni d'un mot pointé ordinaire, ni
+# du nom d'un logiciel. Seule sa forme pleinement qualifiée se reconnaît, et
+# encore : « chemin.home » et « logging.info » ont la même forme. D'où un
+# signal à relire et non une trouvaille.
+#
+# Le suffixe est comparé à une liste FERMÉE. Sans elle, tout attribut pointé
+# du code correspondrait. Les suffixes de service — local, lan, internal —
+# y sont exprès : c'est sous eux qu'une machine du parc se nomme.
+SUFFIXES_DHOTE = (
+    "com",
+    "ca",
+    "net",
+    "org",
+    "io",
+    "dev",
+    "fr",
+    "be",
+    "ch",
+    "eu",
+    "us",
+    "uk",
+    "biz",
+    "cloud",
+    "app",
+    "tech",
+    "quebec",
+    "local",
+    "lan",
+    "internal",
+    "intra",
+    "corp",
+)
+
+# Le point qui SUIT décide de deux choses opposées : suivi d'un caractère de
+# nom, il prolonge l'adresse et la correspondance n'est qu'un préfixe ; seul,
+# c'est le point d'une phrase, et l'adresse s'arrête là. Les confondre rendait
+# invisible toute adresse en fin de phrase.
+NOM_DHOTE = re.compile(
+    r"(?<![\w.@-])((?:[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?\.)+"
+    r"(?:%s))(?![\w-])(?!\.[\w-])" % "|".join(SUFFIXES_DHOTE),
+    re.IGNORECASE,
+)
+
+# Ce que la convention autorise nommément. Le dépôt nomme son PROPRIÉTAIRE et
+# sa licence dans l'en-tête de chaque fichier : les signaler reviendrait à
+# signaler l'en-tête obligatoire partout.
+DOMAINES_PERMIS = re.compile(
+    r"^(?:www\.)?(?:technolibre\.ca|gnu\.org)$"
+    r"|^(?:[a-z0-9-]+\.)*(?:example|exemple)\.(?:com|net|org)$",
+    re.IGNORECASE,
+)
+
+# Une adresse portée par une URL désigne une ressource publique — un miroir de
+# paquets, une page de documentation — et non une machine du parc. La machine
+# qui fuite dans un commentaire s'y écrit nue.
+DANS_UNE_URL = re.compile(r"[a-z][a-z0-9+.-]*://\S*$", re.IGNORECASE)
+
 
 def _bloc(sous_lignes):
     """Un bloc : son texte recollé, et les lignes physiques qui le portent.
@@ -264,6 +328,28 @@ def recits(texte):
     return sorted(trouves, key=lambda t: t[2])
 
 
+def noms_dhote(texte):
+    """Les noms de machine pleinement qualifiés d'un texte.
+
+    Rend (motif, extrait, position), comme `recits` et `identifiants`, pour
+    que les trois familles se traitent de la même façon.
+
+    Trois formes sortent : le domaine du propriétaire et celui de la licence,
+    que l'en-tête de chaque fichier porte ; les domaines réservés à la
+    documentation par la RFC 2606 ; et toute adresse portée par une URL, qui
+    désigne une ressource publique.
+    """
+    trouves = []
+    for trouve in NOM_DHOTE.finditer(texte):
+        nom = trouve.group(1)
+        if DOMAINES_PERMIS.match(nom):
+            continue
+        if DANS_UNE_URL.search(texte[: trouve.start()]):
+            continue
+        trouves.append(("nom d'hôte", nom, trouve.start()))
+    return trouves
+
+
 def ligne_a(bloc, position):
     """La ligne physique qui porte cette position du texte recollé."""
     numero = bloc["line"]
@@ -287,6 +373,7 @@ def inspect(chemin, source=None, termes=None):
         familles = (
             ("identifiant", identifiants(bloc["text"], termes)),
             ("récit", recits(bloc["text"])),
+            ("nom", noms_dhote(bloc["text"])),
         )
         for genre, trouves in familles:
             for motif, extrait, position in trouves:
diff --git a/test/test_check_comment_hygiene.py b/test/test_check_comment_hygiene.py
index 799dafb..ae248a3 100644
--- a/test/test_check_comment_hygiene.py
+++ b/test/test_check_comment_hygiene.py
@@ -382,5 +382,103 @@ class TestLeHook(unittest.TestCase):
         self.assertEqual(0, r.returncode, r.stderr)
 
 
+class TestLesNomsDHote(unittest.TestCase):
+    """La classe interdite qu'aucun motif ne tranche vraiment.
+
+    Un nom d'hôte NU — « rig », « la-machine-de-tests » — ne se distingue
+    mécaniquement ni d'un mot ordinaire ni du nom d'un logiciel : ces tests
+    fixent donc ce que l'outil VOIT, la forme pleinement qualifiée, et ce
+    qu'il continue de ne pas voir. Confondre les deux ferait croire la classe
+    couverte.
+
+    Les noms sont inventés et ne paraissent nulle part ailleurs dans le
+    dépôt, comme l'exige la règle pour l'exemple qui illustre un interdit.
+    """
+
+    def _noms(self, texte):
+        return [extrait for _, extrait, _ in hygiene.noms_dhote(texte)]
+
+    def test_un_nom_pleinement_qualifie(self):
+        self.assertEqual(
+            self._noms("# le service tourne sur garance-01.interne.lan"),
+            ["garance-01.interne.lan"],
+        )
+
+    def test_un_domaine_de_client(self):
+        self.assertEqual(
+            self._noms("# la base de airelle-conseil.ca"),
+            ["airelle-conseil.ca"],
+        )
+
+    def test_le_domaine_du_proprietaire_passe(self):
+        """L'en-tête de copyright est l'exception nommée par la convention."""
+        self.assertEqual(self._noms("# © TechnoLibre www.technolibre.ca"), [])
+
+    def test_le_domaine_de_la_licence_passe(self):
+        self.assertEqual(
+            self._noms("# License AGPL, www.gnu.org/licenses"), []
+        )
+
+    def test_un_domaine_de_documentation_passe(self):
+        """La RFC 2606 les réserve : ils ne désignent aucune machine."""
+        self.assertEqual(self._noms("# par exemple vpn.example.com"), [])
+        self.assertEqual(self._noms("# ou bien hote.exemple.com"), [])
+
+    def test_une_url_passe(self):
+        """Une URL désigne une ressource publique, non une machine du parc."""
+        self.assertEqual(
+            self._noms("# voir https://docs.airelle-conseil.ca/guide"), []
+        )
+
+    def test_un_attribut_pointe_ne_pointe_rien(self):
+        """Le suffixe se compare à une liste fermée, sinon tout correspond."""
+        self.assertEqual(self._noms("# logging.info dit la version"), [])
+        self.assertEqual(self._noms("# asyncio.wait attend un futur"), [])
+        self.assertEqual(self._noms("# chemin.home est le répertoire"), [])
+
+    def test_un_fichier_ne_pointe_rien(self):
+        self.assertEqual(self._noms("# voir todo.py et les autres"), [])
+
+    def test_un_nom_nu_reste_invisible(self):
+        """La limite, énoncée plutôt que cachée.
+
+        « rig » est un nom de machine de ce parc, et rien ne le distingue
+        d'un mot. L'absence de trouvaille ne prouve donc rien sur les noms —
+        c'est pourquoi la famille est un signal 🟡 et non une trouvaille."""
+        self.assertEqual(self._noms("# le calcul tourne sur rig"), [])
+
+    def test_la_famille_est_un_signal_a_relire(self):
+        """Le genre décide de l'icône et de --identifying-only."""
+        trouvailles = hygiene.inspect(
+            "essai.py", source='"""Sur garance-01.interne.lan."""\n'
+        )
+        self.assertEqual(genres(trouvailles), {"nom"})
+        durs = [f for f in trouvailles if f["kind"] == "identifiant"]
+        self.assertEqual(durs, [])
+
+    def test_le_genre_sort_de_identifying_only(self):
+        with tempfile.NamedTemporaryFile(
+            "w", suffix=".py", delete=False, encoding="utf-8"
+        ) as fh:
+            fh.write('"""Sur garance-01.interne.lan."""\n')
+            chemin = fh.name
+        try:
+            sortie = subprocess.run(
+                [
+                    sys.executable,
+                    OUTIL,
+                    chemin,
+                    "--identifying-only",
+                    "--no-color",
+                ],
+                capture_output=True,
+                text=True,
+            )
+            self.assertEqual(sortie.returncode, 0)
+            self.assertNotIn("garance-01", sortie.stdout)
+        finally:
+            os.unlink(chemin)
+
+
 if __name__ == "__main__":
     unittest.main(verbosity=2)