[DTP-Worker 20260802_030504] Sprint 8 · buffer · Fiscal e-CF : ancrage du CONTRAT DE FORMAT e-NCF dans le COMPOSEUR ncf.py (CODE) + oracle de test

Le bloc « Fiscal · CONTRAT DE FORMAT » ancrait le format DGII
(E + tipoeCF(2) + secuencia(10) = 13 · Ley 32-23) sur ecf_plan.json[e_ncf]
byte-gaté, mais UNIQUEMENT sur 4 surfaces de PROSE (README x3 + fiche
erpnext_backend). Le composeur d'exécution ecflib/ncf.py — qui VALIDE et
COMPOSE réellement l'e-NCF cote VPS — portait 3 copies INDÉPENDANTES du
format (ENCF_RE regex de validation · FORMULE publiée par compose_encf ·
docstring/commentaire), + un oracle de test hardcodé, tous NON gatés.

Silent-green : un rango DGII a 12 chiffres régénère ecf_spec->ecf_plan (les
4 proses suivent) mais laisse ENCF_RE a {2}{10} => is_valid_encf REJETTE un
e-NCF valide (bug runtime) pendant que tests/ reste VERT (oracle == FORMULE
périmée). check_artifacts (pas un out/*.json) et tests/ (teste les fonctions,
pas leur ancrage) sont aveugles.

Gate : extension du bloc e-NCF (surfaces 5->9) réutilisant prefix/tipo/seq/
total + ecf_check déja dérivés (zéro re-dérivation du format · #6). 7 morsures
adversariales dont M6 SILENT-GREEN (artefact seq 10->12, ncf.py inchangé =>
les 5 surfaces mordent, autorité = artefact). 39 tests unittest verts. 6 gates
CI re-verts.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

ci/check_readme_claims.sh

@@ -3655,6 +3655,60 @@ if encf is not None:
             ecf_check("fiche erpnext_backend", ECF_FI, ecf_fi,
                       re.search(r"`([A-Z])\s*\+\s*tipoeCF\((\d+)\)\s*\+\s*"
                                 r"secuencia\((\d+)\)`", ecf_fi), False)
+        # ------------------------------------------------------------------
+        # 5) 6) 7) 8) 9) — le MÊME contrat de format dans le COMPOSEUR ncf.py
+        #     (CODE d'exécution, PAS de la prose) + son ORACLE de test.
+        # `ecflib/ncf.py` porte TROIS copies INDÉPENDANTES du format, AUCUNE
+        # dérivée de l'artefact : la regex de VALIDATION `ENCF_RE` (cœur de
+        # is_valid_encf/parse_encf), la chaîne `FORMULE` publiée par
+        # compose_encf (donc RENVOYÉE au caller VPS/Compupar), et deux
+        # proses-en-code (docstring + commentaire Ley 32-23). En prime,
+        # `tests/test_ecf_dgii.py:246` HARDCODE l'oracle « FORMULE ». Le bloc
+        # e-NCF ci-dessus ne gate QUE la prose (README ×3 + fiche). Or un
+        # rango DGII à 12 chiffres régénère ecf_spec→ecf_plan (donc les 4
+        # proses gatées ci-dessus SUIVENT), MAIS laisse ENCF_RE à `{2}{10}` :
+        # compose_encf zfill à 10 et is_valid_encf REJETTE un e-NCF désormais
+        # valide → BUG d'exécution du composeur fiscal, pendant que la suite
+        # tests/ reste VERTE (son oracle == FORMULE périmée, self-consistante).
+        # « Vert trompeur » que ni check_artifacts (ncf.py n'est pas un
+        # out/*.json) ni tests/ (teste les FONCTIONS, pas leur ancrage) ne
+        # mordent. Même patron que l'oracle/formateur du Publiciste. On ANCRE
+        # ces surfaces CODE au SEUL bloc e_ncf byte-gaté (réutilise
+        # prefix/tipo/seq/total ci-dessus · zéro re-dérivation du format #6).
+        ECF_NCF = f"{D}/fiscal/ecf_dgii/ecflib/ncf.py"
+        ECF_TEST = f"{D}/fiscal/ecf_dgii/tests/test_ecf_dgii.py"
+        ecf_ncf = read_norm(ECF_NCF)
+        if ecf_ncf is None:
+            bad(f"Fiscal · composeur {ECF_NCF} illisible → format e-NCF non ancré")
+        else:
+            # 5) ENCF_RE — la regex de VALIDATION (prefix + 2 segments de chiffres)
+            ecf_check("composeur ncf.py · ENCF_RE (validateur)", ECF_NCF, ecf_ncf,
+                      re.search(r"ENCF_RE\s*=\s*re\.compile\(\s*r?[\"']\^"
+                                r"([A-Z])\(\[0-9\]\{(\d+)\}\)\(\[0-9\]\{(\d+)\}\)\$",
+                                ecf_ncf), False)
+            # 6) FORMULE — la chaîne publiée par compose_encf (renvoyée au VPS)
+            ecf_check("composeur ncf.py · FORMULE (publiée)", ECF_NCF, ecf_ncf,
+                      re.search(r"FORMULE\s*=\s*[\"']([A-Z])\s*\+\s*tipoeCF\((\d+)\)"
+                                r"\s*\+\s*secuencia\((\d+)\)[\"']", ecf_ncf), False)
+            # 7) docstring ncf.py — « "E" + tipoeCF (2 chiffres) + secuencia (10 chiffres) → 13 caracteres »
+            ecf_check("composeur ncf.py · docstring", ECF_NCF, ecf_ncf,
+                      re.search(r'e-NCF\s*=\s*"([A-Z])"\s*\+\s*tipoeCF\s*\((\d+)'
+                                r"\s*chiffres?\)\s*\+\s*secuencia\s*\((\d+)\s*chiffres?\)"
+                                r"\s*\S+\s*(\d+)\s*caracteres?", ecf_ncf), True)
+            # 8) commentaire ncf.py — « E + tipo(2) + secuencia(10) = 13 caracteres »
+            ecf_check("composeur ncf.py · commentaire Ley 32-23", ECF_NCF, ecf_ncf,
+                      re.search(r"Format e-NCF[^:]*:\s*([A-Z])\s*\+\s*tipo\((\d+)\)"
+                                r"\s*\+\s*secuencia\((\d+)\)\s*=\s*(\d+)\s*caracteres?",
+                                ecf_ncf), True)
+        # 9) oracle de test — la RAISON pour laquelle la dérive resterait VERTE
+        ecf_test = read_norm(ECF_TEST)
+        if ecf_test is None:
+            bad(f"Fiscal · oracle {ECF_TEST} illisible → FORMULE de test non ancrée")
+        else:
+            ecf_check("oracle test_ecf_dgii.py · formule", ECF_TEST, ecf_test,
+                      re.search(r"\[[\"']formule[\"']\]\s*,\s*[\"']([A-Z])\s*\+"
+                                r"\s*tipoeCF\((\d+)\)\s*\+\s*secuencia\((\d+)\)[\"']",
+                                ecf_test), False)
 
 # ============================================================================
 # Fiscal · e-CF DGII (2e surface du MÊME README) · la CROSS-COHÉRENCE