phi-complexity 0.13.1__tar.gz → 0.14.1__tar.gz

{phi_complexity-0.13.1 → phi_complexity-0.14.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: phi-complexity
-Version: 0.13.1
+Version: 0.14.1
 Summary: Multi-language code quality metrics based on Golden Ratio (φ) mathematical invariants and adiabatic equilibrium
 Author-email: Tomy Verreault <contact@phidelia.dev>
 License: MIT
@@ -50,7 +50,10 @@ Unlike `pylint` (cultural rules) or `radon` (McCabe metrics), `phi-complexity` a
 pip install git+https://github.com/spockoo/Phi-Complexity.git
 ```
 
-> Note : le paquet est aussi sur PyPI (`pip install phi-complexity`, 0.12.0) — identique à cet arbre depuis le 2026-10-01.
+> Note : le paquet est aussi sur PyPI (`pip install phi-complexity`, 0.14.1).
+> Nouveauté 0.14.1 : parseur Lean 4 autonome (stdlib uniquement, zéro dépendance
+> externe) — l'analyse Lean ne nécessite plus tree-sitter ; durcissement de
+> l'extraction (la veille ne devient plus aveugle en silence).
 
 ```bash
 # Audit a file

{phi_complexity-0.13.1 → phi_complexity-0.14.1}/README.md

@@ -21,7 +21,10 @@ Unlike `pylint` (cultural rules) or `radon` (McCabe metrics), `phi-complexity` a
 pip install git+https://github.com/spockoo/Phi-Complexity.git
 ```
 
-> Note : le paquet est aussi sur PyPI (`pip install phi-complexity`, 0.12.0) — identique à cet arbre depuis le 2026-10-01.
+> Note : le paquet est aussi sur PyPI (`pip install phi-complexity`, 0.14.1).
+> Nouveauté 0.14.1 : parseur Lean 4 autonome (stdlib uniquement, zéro dépendance
+> externe) — l'analyse Lean ne nécessite plus tree-sitter ; durcissement de
+> l'extraction (la veille ne devient plus aveugle en silence).
 
 ```bash
 # Audit a file

{phi_complexity-0.13.1 → phi_complexity-0.14.1}/phi_complexity/carte.py

@@ -142,6 +142,26 @@ def carte_projet(dossier: str, lang: Optional[str] = None,
     non_supportes = fichiers_non_supportes(dossier, exclusions=exclusions,
                                            langage=lang)
     avertissements = _avertissements_backend()
+    # Verrouillage « zéro tree-sitter silencieux » (2026-10-03) : si des
+    # symboles n'existent que grâce au repli robuste (tree-sitter les a
+    # avalés), on le dit explicitement dans les avertissements — la clé
+    # existe déjà, aucun changement de schéma.
+    par_fichier_repli = {}
+    for chemin, symboles in index.items():
+        n = sum(1 for s in symboles
+                if getattr(s, "extraction", "analyseur") == "robuste_repli")
+        if n:
+            par_fichier_repli[os.path.basename(chemin)] = n
+    if par_fichier_repli:
+        total_repli = sum(par_fichier_repli.values())
+        avertissements.append(
+            f"⚠️ EXTRACTION DÉGRADÉE — repli robuste : {total_repli} "
+            f"symbole(s) récupéré(s) dans {len(par_fichier_repli)} "
+            f"fichier(s) (invisibles à tree-sitter, métriques = proxy "
+            f"lignes) : " + ", ".join(
+                f"{f} ({n})" for f, n in sorted(par_fichier_repli.items())))
+    # (docstring : en mode complet, les clés sont EXACTEMENT celles de
+    # v0.7.0 — on n'ajoute AUCUNE clé, on remplit `avertissements`.)
 
     fichiers = []
     radiances = []

{phi_complexity-0.13.1 → phi_complexity-0.14.1}/phi_complexity/core.py

@@ -48,7 +48,7 @@ ENTROPIE_CIBLE_NORMALISEE = PHI_INV
 BANDE_TOLERANCE_ADIABATIQUE = ETA_GOLDEN
 """Bande passante de tolérance pour l'entropie relative : η_golden = 1 - φ⁻¹ ≈ 0.381966."""
 
-VERSION = "0.12.0"
+VERSION = "0.14.1"
 AUTEUR = "Tomy Verreault"
 FRAMEWORK = "Morphic Phi Framework (φ-Meta)"
 

{phi_complexity-0.13.1 → phi_complexity-0.14.1}/phi_complexity/croyances.py

@@ -577,10 +577,17 @@ def chemins_croyants(dossier: str, lang: Optional[str] = None,
     sorry_modes = set()
 
     croyances: List[CroyanceSymbole] = []
+    # Durcissement 2026-10-02 : par fichier, combien de symboles viennent
+    # du repli robuste (tree-sitter aveugle). Jamais silencieux.
+    extraction_repli: Dict[str, int] = {}
     for f in fichiers:
         c = canon[f]
         rel = os.path.relpath(c, dossier_abs)
         symboles = sorted(index[f], key=lambda s: s.ligne)
+        n_repli = sum(1 for s in symboles
+                      if getattr(s, "extraction", "analyseur") == "robuste_repli")
+        if n_repli:
+            extraction_repli[rel] = n_repli
         sorry_map, mode = _sorry_par_symbole(f, symboles)
         sorry_modes.add(mode)
         if mode == "grep_repli":
@@ -676,6 +683,10 @@ def chemins_croyants(dossier: str, lang: Optional[str] = None,
         "imports_non_resolus": non_resolus[:20],
         "nb_imports_non_resolus": len(non_resolus),
         "limites": LIMITE_HONNETETE,
+        # Durcissement 2026-10-02 : fichiers où le repli robuste a récupéré
+        # des symboles invisibles à tree-sitter ({fichier_rel: n}).
+        # Absent/vide = extraction nominale partout.
+        "extraction_repli": extraction_repli,
     }
     if mode_exact:
         # Clé EFT : uniquement en mode exact (JSON flottant inchangé).

{phi_complexity-0.13.1 → phi_complexity-0.14.1}/phi_complexity/dependances.py

@@ -1,11 +1,12 @@
 """Extraction des dépendances entre définitions Lean.
 
-Utilise le parseur tree-sitter (parseur_lean.py) pour :
-1. Extraire toutes les déclarations d'un fichier.
+Utilise le parseur autonome (parseur_autonome.py, 2026-10-03, autonomie
+stricte) pour :
+1. Extraire toutes les déclarations d’un fichier (spans exacts).
 2. Pour chaque déclaration, trouver les identifiants référencés dans son corps.
 3. Construire le graphe de dépendances.
 
-Limites honnêtes :
+Zéro dépendance externe. Limites honnêtes :
 - Syntaxique, pas sémantique : on extrait les identifiants textuels,
   sans résolution de noms complète (pas de distinction entre
   variable liée et référence globale sans analyse de portée).
@@ -16,10 +17,10 @@ Limites honnêtes :
 
 from __future__ import annotations
 
+import re
 from dataclasses import dataclass, field
 from typing import Dict, List, Set
 
-from .parseur_lean import parse, extraire_declarations, extraire_declarations_robuste
 
 
 # Mots-clés Lean à ignorer (non des dépendances)
@@ -88,24 +89,39 @@ class GrapheDependances:
 
 
 def extraire_identifiants(code: str) -> Set[str]:
-    """Extrait tous les identifiants d'un fragment de code Lean."""
-    try:
-        racine = parse(code)
-    except Exception:
-        return set()
-    identifiants = set()
-    for noeud in racine.trouver_tous("identifier"):
-        texte = noeud.texte.strip()
-        # Filtrer les mots-clés et les identifiants vides
-        if texte and texte not in MOTS_CLES and not texte.startswith("_"):
-            # Ignorer les projections de champ simples (ex: x.val -> on garde x)
-            # Pour l'instant, on garde le texte brut
-            identifiants.add(texte)
-    return identifiants
+    """Extrait tous les identifiants d'un fragment de code Lean.
+
+    Source unique : le lexer du parseur autonome (2026-10-03). Les
+    commentaires et chaînes sont exclus par construction (tokens).
+    Ne rend jamais un ensemble vide silencieusement : si le code ne
+    contient vraiment aucun identifiant, c'est le cas — sinon le
+    lexer les voit tous (aucune grammaire externe).
+    """
+    from .parseur_autonome import tokenize, identifiants
+    toks, _avs, _nc = tokenize(code)
+    return {nom for nom, _ligne in identifiants(toks)
+            if nom and nom not in MOTS_CLES and not nom.startswith("_")}
+
+
+_RE_IDENT = re.compile(r"[A-Za-z_][A-Za-z0-9_']*")
+
+
+def _identifiants_regex(code: str) -> Set[str]:
+    """Repli regex pour `extraire_identifiants` quand tree-sitter est
+    indisponible (jamais de silence : ensemble vide seulement si le
+    code n'a vraiment aucun identifiant)."""
+    return {m.group(0) for m in _RE_IDENT.finditer(code)
+            if m.group(0) not in MOTS_CLES
+            and not m.group(0).startswith("_")}
 
 
 def analyser_fichier(chemin: str) -> GrapheDependances:
-    """Analyse un fichier Lean et construit le graphe de dépendances."""
+    """Analyse un fichier Lean et construit le graphe de dépendances.
+
+    Source unique : parseur autonome — déclarations avec spans de corps
+    exacts (pas de découpage par lignes approximatif).
+    """
+    from .parseur_autonome import parse_declarations
     graphe = GrapheDependances()
     try:
         with open(chemin, 'r', encoding='utf-8') as f:
@@ -113,49 +129,21 @@ def analyser_fichier(chemin: str) -> GrapheDependances:
     except Exception:
         return graphe
 
-    # Extraire les déclarations (version robuste, pas de limite de taille)
-    declarations = extraire_declarations_robuste(code)
-    noms_declares = {d.nom for d in declarations if d.nom}
-
-    # Pour chaque déclaration, extraire les identifiants de son corps
-    # On utilise une approche simple : découper le code par déclaration
-    # (une approche plus précise utiliserait les positions AST)
-    for decl in declarations:
+    for decl in parse_declarations(code):
         if not decl.nom:
             continue
-        # Trouver le corps : on prend le texte après ":=" jusqu'à la prochaine déclaration
-        # Simplification : on analyse tout le fichier et on filtre
-        # (pour une version précise, il faudrait les offsets AST)
-        pass
-
-    # Approche précise : extraire le corps entre deux déclarations
-    # On trie les déclarations par ligne, puis pour chacune,
-    # le corps va de sa ligne jusqu'à la ligne de la suivante.
-    lignes = code.split('\n')
-    decls_triees = sorted(
-        [d for d in declarations if d.nom and d.ligne],
-        key=lambda d: d.ligne
-    )
-    for idx, decl in enumerate(decls_triees):
-        # Début : ligne de la déclaration (0-indexed)
-        debut = decl.ligne - 1
-        # Fin : ligne de la prochaine déclaration (exclusive),
-        # ou fin du fichier si c'est la dernière
-        if idx + 1 < len(decls_triees):
-            fin = decls_triees[idx + 1].ligne - 1
-        else:
-            fin = len(lignes)
-        # Extraire le bloc exact
-        bloc = '\n'.join(lignes[debut:fin])
-        # Extraire les identifiants du bloc
-        refs = extraire_identifiants(bloc)
-        # Retirer l'auto-référence
+        refs = extraire_identifiants(decl.corps)
         refs.discard(decl.nom)
+        # Retirer les noms liés par les binders (paramètres, pas dépendances)
+        for bnom, _impl in decl.binders:
+            refs.discard(bnom)
         graphe.ajouter(decl.nom, refs, chemin, decl.ligne)
+    return graphe
 
     return graphe
 
 
+
 def dependances_pour(nom: str, graphe: GrapheDependances) -> List[str]:
     """Retourne la liste triée des dépendances transitives d'un nom,
     en ordre topologique (dépendances d'abord)."""

{phi_complexity-0.13.1 → phi_complexity-0.14.1}/phi_complexity/editeur/indexeur.py

@@ -71,6 +71,9 @@ class Symbole:
     complexite: int
     langage: str
     fichier: str
+    extraction: str = "analyseur"  # "analyseur" ou "robuste_repli"
+    # (durcissement 2026-10-02 : repli robuste Lean quand tree-sitter
+    # a avalé la déclaration — métriques = proxy lignes)
 
 
 # Cache d'invalidation : (chemin, complet) -> mtime de la dernière
@@ -103,6 +106,7 @@ def _symboles_du_fichier(chemin: str, langage: Optional[str] = None,
                     complexite=int(f.complexite),
                     langage=resultat.langage,
                     fichier=chemin,
+                    extraction=getattr(f, "extraction", "analyseur"),
                 )
             )
         except Exception:

{phi_complexity-0.13.1 → phi_complexity-0.14.1}/phi_complexity/eft.py

@@ -1,5 +1,5 @@
 """
-eft.py — Error-Free Transformations pour phi-complexity (v0.12.0, opt-in).
+eft.py — Error-Free Transformations pour phi-complexity (v0.14.1, opt-in).
 
 Références mathématiques :
 - T. Dekker, « A floating-point technique for extending the available

{phi_complexity-0.13.1 → phi_complexity-0.14.1}/phi_complexity/langs/lean.py

@@ -41,6 +41,14 @@ from .base import AnalyseurBase
 # Types de nœuds mot-clé (tels que la grammaire les normalise).
 _TYPES_DECLARATION = {"theorem", "def", "abbrev", "instance", "structure", "inductive"}
 
+# Kinds récupérables par le repli robuste : exactement ceux que
+# l'analyseur compte (mots-clés SOURCE, avant normalisation —
+# `lemma`→theorem et `class`→structure sont normalisés par la grammaire).
+# `example` et `opaque` en sont exclus : le repli répare un angle mort,
+# il n'étend pas le périmètre.
+_KINDS_COMPTES = {"theorem", "lemma", "def", "abbrev", "instance",
+                  "structure", "class", "inductive"}
+
 # Enfants de `declaration` à sauter avant le mot-clé.
 _PREFIXES_IGNORES = {"decl_modifiers", "attributes"}
 
@@ -76,17 +84,33 @@ class AnalyseurLean(AnalyseurBase):
     """
     Analyseur fractal dédié à Lean 4 : déclarations de tête uniquement,
     métriques calibrées pour le code de preuve.
+
+    Moteur d'extraction (2026-10-03, autonomie stricte) :
+    - "autonome" (défaut) : parseur_autonome (stdlib uniquement, zéro
+      dépendance externe) — source unique sur le chemin Lean ;
+    - "tree_sitter" : ancien chemin tree-sitter, conservé pour vérification
+      croisée optionnelle (désactivé par défaut).
     """
 
-    def __init__(self, fichier: str):
+    def __init__(self, fichier: str, moteur: str = "autonome"):
         super().__init__(fichier)
+        self.moteur = moteur
         self.tree = None
         self.source: bytes = b""
         self.lignes: List[str] = []
         self.resultat = ResultatAnalyse(fichier=fichier, langage="lean")
 
     def charger(self) -> "AnalyseurLean":
-        """Charge et parse le fichier. Lève ImportError explicite si la grammaire manque."""
+        """Charge le fichier. Le moteur autonome ne nécessite rien
+        d'externe ; le moteur tree_sitter lève ImportError explicite si
+        la grammaire manque."""
+        if self.moteur == "autonome":
+            with open(self.fichier, "r", encoding="utf-8", errors="replace") as f:
+                contenu = f.read()
+            self.lignes = contenu.splitlines()
+            self.source = contenu.encode("utf-8", errors="replace")
+            self._contenu = contenu
+            return self
         try:
             from tree_sitter_language_pack import get_parser
         except ImportError as exc:
@@ -113,6 +137,9 @@ class AnalyseurLean(AnalyseurBase):
         """
         Analyse : déclarations de tête, métriques, règles, oudjat.
 
+        Moteur "autonome" (défaut) : parseur proprietaire sans dépendance
+        externe. Moteur "tree_sitter" : ancien chemin (vérification croisée).
+
         `complet=True` : comportement historique. `complet=False`
         (phase 1) : noms, lignes, `complexite = nb_lignes` (PROXY explicite,
         pas le proxy lignes+tactiques du mode complet) ; ni comptage de
@@ -120,6 +147,8 @@ class AnalyseurLean(AnalyseurBase):
         (sentinelles : `profondeur_max=0`, `distance_fib=0.0`,
         `phi_ratio=1.0`). L'oudjat est la déclaration la plus longue.
         """
+        if self.moteur == "autonome":
+            return self._analyser_autonome(complet=complet)
         if self.tree is None:
             self.charger()
         racine = self.tree.root_node
@@ -134,13 +163,88 @@ class AnalyseurLean(AnalyseurBase):
                         self.resultat.nb_classes += 1
             elif enfant.type in _COMMENTAIRES:
                 self.resultat.nb_commentaires += 1
+        # Durcissement 2026-10-02 : repli robuste — récupère les
+        # déclarations avalées par la récupération d'erreur tree-sitter
+        # (cause racine : `|expr|` en position de type, voir _repli_robuste).
+        self._repli_robuste()
         if complet:
             self._regle_fibonacci()
         self._identifier_oudjat(complet=complet)
         return self.resultat
 
     # ────────────────────────────────────────────────────────
-    # EXTRACTION DES DÉCLARATIONS
+    # MOTEUR AUTONOME (2026-10-03, autonomie stricte)
+    # ────────────────────────────────────────────────────────
+
+    def _analyser_autonome(self, complet: bool = True) -> ResultatAnalyse:
+        """Analyse via le parseur autonome (stdlib uniquement).
+
+        Même contrat de sortie que le chemin tree-sitter : symboles
+        comptés = KINDS_COMPTES, complexite = nb_lignes + nb_tactiques
+        (mode complet) ou nb_lignes (phase 1, PROXY explicite).
+        Les avertissements du parseur deviennent des annotations WARNING
+        — jamais silencieux.
+        """
+        from ..parseur_autonome import parse as parse_autonome, KINDS_COMPTES
+        if not hasattr(self, "_contenu"):
+            self.charger()
+        contenu = self._contenu
+        self.resultat.nb_lignes_total = len(self.lignes)
+        res = parse_autonome(contenu)
+        self.resultat.nb_commentaires = res.nb_commentaires
+        for d in res.declarations:
+            if d.kind not in KINDS_COMPTES:
+                continue
+            if d.nom.startswith("_"):
+                continue  # définitions anonymes, comme avant
+            nb_lignes = d.ligne_fin - d.ligne_debut + 1
+            if not complet:
+                mesure = MetriqueFonction(
+                    nom=d.nom,
+                    ligne=d.ligne,
+                    complexite=nb_lignes,  # PROXY phase 1 (voir docstring analyser)
+                    nb_args=0,             # sentinelle : non calculé
+                    nb_lignes=nb_lignes,
+                    profondeur_max=0,      # sentinelle : non calculée
+                    distance_fib=0.0,      # sentinelle : non calculée
+                    phi_ratio=1.0,         # sentinelle : non calculé
+                    extraction="autonome",
+                )
+            else:
+                mesure = MetriqueFonction(
+                    nom=d.nom,
+                    ligne=d.ligne,
+                    complexite=nb_lignes + d.nb_tactiques,
+                    nb_args=d.nb_args,
+                    nb_lignes=nb_lignes,
+                    profondeur_max=d.profondeur_by,
+                    distance_fib=distance_fibonacci(nb_lignes),
+                    phi_ratio=1.0,  # Calculé après, quand la moyenne est connue
+                    extraction="autonome",
+                )
+            self.resultat.fonctions.append(mesure)
+            if d.kind in ("structure", "class", "inductive"):
+                self.resultat.nb_classes += 1
+        # Avertissements du parseur → annotations bruyantes.
+        for av in res.avertissements:
+            extrait = self.lignes[av.ligne - 1].strip() \
+                if 0 < av.ligne <= len(self.lignes) else ""
+            self.resultat.annotations.append(
+                Annotation(
+                    ligne=av.ligne,
+                    message=f"PARSEUR AUTONOME : {av.message}",
+                    niveau="WARNING",
+                    extrait=extrait,
+                    categorie="PARSEUR",
+                )
+            )
+        if complet:
+            self._regle_fibonacci()
+        self._identifier_oudjat(complet=complet)
+        return self.resultat
+
+    # ────────────────────────────────────────────────────────
+    # EXTRACTION DES DÉCLARATIONS (chemin tree_sitter)
     # ────────────────────────────────────────────────────────
 
     def _noeud_mot_cle(self, declaration):
@@ -219,9 +323,86 @@ class AnalyseurLean(AnalyseurBase):
         )
 
     # ────────────────────────────────────────────────────────
-    # MÉTRIQUES SPÉCIFIQUES LEAN
+    # REPLI ROBUSTE (durcissement 2026-10-02)
     # ────────────────────────────────────────────────────────
 
+    def _repli_robuste(self) -> int:
+        """Récupère les déclarations avalées par la récupération d'erreur.
+
+        Cause racine : la grammaire tree-sitter-lean confond les barres
+        `|expr|` (valeur absolue / norme) en position de type de retour
+        avec une alternative de filtrage `|` ; le nœud ERROR produit
+        avale ensuite les déclarations suivantes, qui deviennent
+        INVISIBLES à l'analyseur — silencieusement (constaté :
+        169 déclarations vues sur 261 dans scratch_65c_global.lean,
+        412 déclarations manquées sur 60/176 fichiers du dépôt Lean).
+
+        L'extracteur robuste (regex) est la source de vérité pour
+        l'EXISTENCE des symboles ; tree-sitter garde la main sur les
+        métriques fines quand il voit la déclaration. Les symboles
+        récupérés portent extraction="robuste_repli" et des métriques
+        PROXY honnêtes (complexite = nb_lignes du span, comme la
+        phase 1) — jamais de métriques inventées, jamais de silence.
+
+        Seuls les kinds déjà comptés par l'analyseur sont récupérés
+        (pas de `example`, pas de `opaque`) : le repli ne crée aucun
+        nouveau périmètre, il répare un angle mort.
+
+        Retourne le nombre de symboles récupérés. Le repli ne lève
+        jamais : en cas d'échec il ne fait rien (l'analyse principale
+        reste intacte).
+        """
+        try:
+            from ..parseur_lean import extraire_declarations_robuste
+            code = self.source.decode("utf-8", errors="replace")
+            robustes = sorted(extraire_declarations_robuste(code),
+                              key=lambda d: d.ligne)
+            # Référence de couverture : ce que la passe tree-sitter a
+            # VRAIMENT extrait (self.resultat.fonctions) — et non
+            # extraire_declarations(), qui ignore structure/inductive
+            # alors que l'analyseur les compte (doublons sinon).
+            vus = [(f.nom, f.ligne) for f in self.resultat.fonctions]
+
+            def couvert(d):
+                return any(n == d.nom and abs(l - d.ligne) <= 2
+                           for (n, l) in vus)
+
+            manquants = [
+                d for d in robustes
+                if d.kind in _KINDS_COMPTES and not d.nom.startswith("_")
+                and not couvert(d)
+            ]
+            if not manquants:
+                return 0
+            # Spans : chaque déclaration robuste va jusqu'à la suivante
+            # (tous kinds, comme le découpage par grep de _spans_symboles).
+            lignes_fin = {}
+            for i, d in enumerate(robustes):
+                fin = (robustes[i + 1].ligne - 1
+                       if i + 1 < len(robustes) else len(self.lignes))
+                lignes_fin[(d.nom, d.ligne)] = max(d.ligne, fin)
+            recuperes = 0
+            for d in manquants:
+                fin = lignes_fin.get((d.nom, d.ligne), len(self.lignes))
+                span = max(1, fin - d.ligne + 1)
+                self.resultat.fonctions.append(MetriqueFonction(
+                    nom=d.nom,
+                    ligne=d.ligne,
+                    complexite=span,   # PROXY phase 1, explicite
+                    nb_args=0,         # sentinelle : non calculé
+                    nb_lignes=span,
+                    profondeur_max=0,  # sentinelle : non calculée
+                    distance_fib=distance_fibonacci(span),
+                    phi_ratio=1.0,     # sentinelle : non calculé
+                    extraction="robuste_repli",
+                ))
+                if d.kind in ("structure", "class", "inductive"):
+                    self.resultat.nb_classes += 1
+                recuperes += 1
+            return recuperes
+        except Exception:
+            return 0
+
     def _compter_tactiques(self, declaration) -> int:
         """Nombre de pas de tactique = enfants nommés directs des blocs `by`."""
         total = 0

{phi_complexity-0.13.1 → phi_complexity-0.14.1}/phi_complexity/langs/registry.py

@@ -121,8 +121,12 @@ def analyseur_disponible(chemin: str, langage: Optional[str] = None) -> bool:
         return False
     if lang == "python":
         return True
+    if lang == "lean":
+        # Parseur autonome (stdlib uniquement, 2026-10-03) : Lean est
+        # toujours analysable, sans aucune dépendance externe.
+        return True
     ext = os.path.splitext(chemin)[1].lower()
-    if ext in EXTENSIONS_ANALYSEUR_DEDIE or lang == "lean":
+    if ext in EXTENSIONS_ANALYSEUR_DEDIE:
         # Analyseur dédié : le pack seul ne suffit pas, il faut la grammaire.
         return treesitter_disponible() and _grammaire_lean_ok()
     return treesitter_disponible()
@@ -149,14 +153,16 @@ def obtenir_analyseur(fichier: str, langage: Optional[str] = None) -> AnalyseurB
         return AnalyseurPython(fichier)
 
     ext = os.path.splitext(fichier)[1].lower()
-    if ext in EXTENSIONS_ANALYSEUR_DEDIE or lang == "lean":
-        if not treesitter_disponible() or not _grammaire_lean_ok():
-            raise ImportError(
-                "Analyse Lean non supportée : grammaire lean indisponible "
-                "(installez `pip install phi-complexity[multilang]` et vérifiez "
-                "l'accès réseau pour le téléchargement de la grammaire)."
-            )
-        return _analyseur_dedie(ext)(fichier)
-
+    if ext in EXTENSIONS_ANALYSEUR_DEDIE or lang == "lean":
+        # Lean : parseur autonome par défaut (zéro dépendance externe).
+        # Le moteur tree_sitter reste disponible en vérification croisée
+        # optionnelle : AnalyseurLean(fichier, moteur="tree_sitter").
+        return _analyseur_dedie(ext)(fichier)
+
+    if not treesitter_disponible():
+        raise ImportError(
+            "Analyse non supportée : `tree-sitter-language-pack` indisponible "
+            "(installez `pip install phi-complexity[multilang]`)."
+        )
     from .treesitter_generic import AnalyseurTreeSitter
     return AnalyseurTreeSitter(fichier, ts_langage=lang)

{phi_complexity-0.13.1 → phi_complexity-0.14.1}/phi_complexity/langs/treesitter_generic.py

@@ -151,6 +151,25 @@ class AnalyseurTreeSitter(AnalyseurBase):
             self.charger()
         racine = self.tree.root_node
         self.resultat.nb_lignes_total = len(self.lignes)
+        # ────────────────────────────────────────────────────────
+        # VERROUILLAGE « zéro tree-sitter silencieux » (2026-10-03) :
+        # un arbre avec nœuds ERROR signifie récupération d'erreur —
+        # des symboles peuvent manquer SANS aucun signal sinon.
+        # On l'annonce en annotation CRITICAL explicite (jamais de
+        # silence) ; on ne tente pas de réparer la grammaire externe.
+        # ────────────────────────────────────────────────────────
+        try:
+            if racine.has_error:
+                self._annoter(
+                    1,
+                    "⚠️ TREE-SITTER DÉGRADÉ : l'arbre syntaxique contient "
+                    "des nœuds d'erreur — des symboles peuvent manquer "
+                    "silencieusement dans cette analyse.",
+                    "CRITICAL",
+                    "SOUVERAINETE",
+                )
+        except Exception:
+            pass  # la garde ne doit jamais casser l'analyse
         if complet:
             self._compter_elements_globaux(racine)
             self._analyser_fonctions(racine)

{phi_complexity-0.13.1 → phi_complexity-0.14.1}/phi_complexity/mission.py

@@ -143,6 +143,14 @@ JUSTIFICATIONS = {
                "croyance montre sa chaîne, pas de boîte noire.",
         "sert": "instrument",
     },
+    "parseur_autonome": {
+        "but": "Parseur Lean 4 proprietaire de phi-complexity (stdlib "
+               "uniquement, zero dependance externe) : lexer + descente "
+               "recursive sur les en-tetes + delimitation exacte des corps. "
+               "Remplace tree-sitter sur tout le chemin Lean depuis "
+               "l'autonomie stricte du 2026-10-03.",
+        "sert": "instrument",
+    },
     "piste_sorry": {
         "but": "Piste d'un sorry à travers Lean 4 : inventaire rigoureux "
                "(commentaires et chaînes exclus), graphe d'imports, chantiers "

{phi_complexity-0.13.1 → phi_complexity-0.14.1}/phi_complexity/modeles.py

@@ -17,6 +17,9 @@ class MetriqueFonction:
     profondeur_max: int   # Imbrication maximale
     distance_fib: float   # Éloignement de la séquence naturelle
     phi_ratio: float      # Rapport complexité/moyenne (idéal: φ)
+    extraction: str = "analyseur"  # "analyseur" ou "robuste_repli"
+    # (durcissement 2026-10-02 : symboles récupérés par l'extracteur
+    # robuste quand tree-sitter les a avalés — métriques = proxy lignes)
 
 
 @dataclass

{phi_complexity-0.13.1 → phi_complexity-0.14.1}/phi_complexity/oracle.py

@@ -1,5 +1,5 @@
 """
-oracle.py — Traces d'oracle pour phi-complexity (v0.12.0, opt-in EFT).
+oracle.py — Traces d'oracle pour phi-complexity (v0.14.1, opt-in EFT).
 
 Un oracle n'est pas un devin : c'est une chaîne de raisonnement EXHIBÉE.
 Chaque mise à jour de croyance enregistre :