Detectors in English, under scripts/; learner tools under scripts/learner/

- data.py (was donnees.py): unused filtrer, heure_image and image sorting removed
- score.py: dead functions (validite, marquer, detectes, score, familles) and the
  validity levels removed; --from/--to
- regression.py: history.csv and --seance/--etape removed
- categories.py: --from/--to/--chunk/--history; process values images/none/check
- benchmark on all stations unchanged (same 132 figures)

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
maximeandClaude Opus 5.5 committed 2026-11-13 12:19:52 +01:00
1 parent 9b3ac0ecfe
commit 969637499f
23 files changed
+1877 -1971

No files matched your search

-29
View File
@@ -1,29 +0,0 @@
"""Pour le critique de /detector-learner : la cadence des mesures du lot, puis chaque événement de la commande du lot avec
ses capteurs (categories.py n'en donne que le nombre) ; avant, le nombre de cibles et de références de la station. Même calcul que categories.py sans --tranche (3 jours d'historique).
Usage : python3 detectors/skills/detector-learner/capteurs.py <dossier> --du AAAA-MM-JJ --au AAAA-MM-JJ
"""
import argparse
import os
import statistics
import sys
from datetime import datetime, timedelta, timezone
sys.path.insert(0, os.path.join(os.path.dirname(os.path.abspath(__file__)), "..", "..", "..", "detectors"))
import categories # noqa: E402
p = argparse.ArgumentParser(usage=__doc__)
p.add_argument("dossier")
p.add_argument("--du", required=True)
p.add_argument("--au", required=True)
a = p.parse_args()
jour = lambda d: datetime.strptime(d[:10], "%Y-%m-%d").replace(tzinfo=timezone.utc) # noqa: E731
debut, fin = jour(a.du), jour(a.au)
mesures = categories.charger(a.dossier)
lot = {s: k for s, ms in mesures.items() if (k := [m for m in ms if debut - timedelta(days=3) <= m["t"] < fin])}
ts = sorted({m["t"] for ms in lot.values() for m in ms if m["t"] >= debut})
pas = [(b - a).total_seconds() / 60 for a, b in zip(ts, ts[1:])]
print(f"cadence : {statistics.median(pas):.0f} min (médiane des pas entre mesures)" if pas else "cadence : pas de mesure")
refs = sum(ms[0]["pattern_type"] == "global_ref" for ms in lot.values())
print(f"capteurs : {len(lot) - refs} cibles, {refs} références")
for v in (v for v in categories.evenements(lot, fin, a.dossier) if v["end"] >= categories.iso(debut)) if lot else []:
print(v["start"], "→", v["end"], f"{v['category']:<20}", "|", v["episodes"][0]["label"], "|", ", ".join(sorted(v["sensors"])) or "tous les capteurs")
-69
View File
@@ -1,69 +0,0 @@
"""Benchmark de /detector-learner (D-116) : les détecteurs face à toutes les étiquettes de l'étiqueteur (labeling/auto/).
Pour chaque station de labeling/auto/ qui a son dossier dans data/, le score par famille et par instant de score.py
(D-112), sur la plage de ses étiquettes : du jour de la première à minuit après la dernière. Puis le total, famille par
famille, qui dit si les détecteurs font globalement mieux d'une séance à l'autre. Le bloc de la station de la séance est
son score ; les autres blocs, la non-régression : une famille qui recule sur une station est un recul, même si le total
monte. Avec --etape, chaque ligne (stations et Total) entre dans l'historique, detectors/detector-learner/historique.csv, avec la
version des détecteurs (score.version()).
Usage : python3 detectors/skills/detector-learner/regression.py [--seance <séance> --etape <étape>] [--stations A,B]
"""
import argparse
import csv
import glob
import json
import os
import sys
from datetime import datetime, timezone
RACINE = os.path.normpath(os.path.join(os.path.dirname(os.path.abspath(__file__)), "..", "..", ".."))
import score # noqa: E402 (à côté)
HISTORIQUE = os.path.join(RACINE, "detectors", "detector-learner", "historique.csv")
def plage(chemin):
"""labeling/auto/<STATION>.jsonl -> (début, fin) iso, en jours entiers UTC, fin exclue."""
with open(chemin, encoding="utf-8") as f:
etiq = [json.loads(l) for l in f if l.strip()]
du = min(e["debut"] for e in etiq)[:10]
# ponytail: la fin du lot n'est pas écrite ; minuit le plus proche de la dernière borne (une borne d'étiquette déborde
# d'une mesure après minuit) ; la fin réelle du lot dans labeling/auto/ si l'écart compte
au = score.iso(score.instant(max(e["fin"] for e in etiq)) + score.timedelta(hours=12))[:10]
return score.iso(score.instant(du)), score.iso(score.instant(au))
if __name__ == "__main__":
p = argparse.ArgumentParser(usage=__doc__)
p.add_argument("--seance", default="")
p.add_argument("--etape")
p.add_argument("--stations", help="A,B : ces stations seules, sans historique (un essai plus court)")
a = p.parse_args()
total, res = {}, {}
for chemin in sorted(glob.glob(os.path.join(RACINE, "labeling", "auto", "*.jsonl"))):
station = os.path.basename(chemin)[:-len(".jsonl")]
if a.stations and station not in a.stations.split(","):
continue
dossier = os.path.join(RACINE, "data", station)
if not os.path.isdir(dossier):
print(f"{station} : pas de data/{station}/, sautée\n")
continue
du, au = plage(chemin)
n, etiq = score.familles_lot(dossier, du, au)
score.afficher(f"{station} : {du} → {au}, {len(etiq)} étiquettes", n)
print()
res[station] = n
for k, v in n.items():
total[k] = [a + b for a, b in zip(total.get(k, [0, 0, 0]), v)]
score.afficher("Total", total)
if a.etape and not a.stations:
res["Total"] = total
os.makedirs(os.path.dirname(HISTORIQUE), exist_ok=True)
neuf = not os.path.exists(HISTORIQUE)
date, ver = datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%MZ"), score.version()
with open(HISTORIQUE, "a", newline="", encoding="utf-8") as f:
w = csv.writer(f)
if neuf:
w.writerow(("date", "seance", "etape", "version", "station", "famille", "etiquetees", "signalees", "les_deux"))
w.writerows((date, a.seance, a.etape, ver, st, k, *v) for st, n in res.items() for k, v in sorted(n.items()))
print(f"\nhistorique : {os.path.relpath(HISTORIQUE, RACINE)} (version {ver})")
-142
View File
@@ -1,142 +0,0 @@
"""Score des détecteurs sur une plage : les détecteurs du journal face aux étiquettes de labeling/auto/<STATION>.jsonl qui
touchent la plage, par famille (labeling/familles.md) et par instant. Une case : une mesure d'un capteur ; elle reçoit, d'un
côté, les familles des étiquettes qui la couvrent, de l'autre, celles des événements des détecteurs (categories.py, la plage
classée avec ses 3 jours d'historique) ; la catégorie d'un événement est sa famille (un détecteur par famille), un saut revenu
resté seul compris (Displacement). Pour chaque famille, et pour les deux niveaux de validité qui ne sont pas « fiable » :
trouvées : cases étiquetées que les détecteurs ont aussi signalées (part des étiquetées) ;
justes : cases signalées qu'une étiquette range aussi dans la famille (part des signalées).
Un trou n'a pas de mesure, donc pas de case. Le score est un fait, pas un verdict : les étiquettes peuvent se tromper aussi.
Aucune étiquette sur la plage : sortie en erreur. Lancé depuis le dépôt de travail, où detectors/ est monté.
Usage : python3 detectors/skills/detector-learner/score.py <dossier de station> --du AAAA-MM-JJ --au AAAA-MM-JJ
"""
import json
import os
import subprocess
import sys
from datetime import timedelta
RACINE = os.path.normpath(os.path.join(os.path.dirname(os.path.abspath(__file__)), "..", "..", ".."))
sys.path.insert(0, os.path.join(RACINE, "detectors"))
import categories # noqa: E402 (il met lui-même donnees.py sur le chemin)
from donnees import charger, instant, iso # noqa: E402
HISTORIQUE = timedelta(days=3) # comme la commande du lot (D-056)
IGNORER = {"visibilite_nulle", "passage", "cible_masquee", "cible_a_probleme", "saut_bref"} # zones grisées (carte, section 4)
# ponytail: la turbulence est toujours « prudence » : l'étiquette ne dit pas si elle est forte (grisée alors dans le
# journal) ; un champ de force dans les étiquettes si cet écart compte
PRUDENCE = {"visibilite_reduite", "turbulence"}
NIVEAUX = ("à ignorer", "prudence")
def validite(cats):
return "à ignorer" if cats & IGNORER else "prudence" if cats & PRUDENCE else None
def cases(mesures, debut, fin):
"""Mesures -> [(capteur, instant iso)] du lot, fin exclue."""
return [(s, t) for s, ms in mesures.items() for m in ms if debut <= (t := iso(m["t"])) < fin]
def marquer(cs, spans):
"""Cases, [(début, fin, capteurs, catégorie)] -> {case: {catégories}} ; fin incluse, capteurs vides : tous."""
out = {c: set() for c in cs}
for d, f, capteurs, cat in spans:
for s, t in cs:
if d <= t <= f and (not capteurs or s in capteurs):
out[(s, t)].add(cat)
return out
def evenements(mesures, debut, fin, dossier=None):
"""Événements des détecteurs qui touchent le lot, classé avec ses jours d'historique (comme la commande du lot)."""
h, b = instant(debut) - HISTORIQUE, instant(fin)
tranche = {s: k for s, ms in mesures.items() if (k := [m for m in ms if h <= m["t"] < b])}
return [v for v in (categories.evenements(tranche, dossier=dossier) if tranche else []) if v["end"] >= debut]
def detectes(mesures, debut, fin):
"""Événements des détecteurs du lot -> spans de marquer."""
return [(v["start"], v["end"], v["sensors"], v["category"]) for v in evenements(mesures, debut, fin)]
def compter(paires):
"""[(clés étiquetées, clés signalées)], une paire par case -> {clé: [étiquetées, signalées, les deux]}."""
n = {}
for a, d in paires:
for k in a | d:
x = n.setdefault(k, [0, 0, 0])
x[0], x[1], x[2] = x[0] + (k in a), x[1] + (k in d), x[2] + (k in a and k in d)
return n
def version():
"""La version des détecteurs : le commit du dépôt detectors, suivi de « + » s'il a des changements non commités."""
def git(*a):
return subprocess.run(["git", "-C", os.path.join(RACINE, "detectors"), *a], capture_output=True, text=True).stdout.strip()
return git("rev-parse", "--short", "HEAD") + ("+" if git("status", "--porcelain", "--", ".") else "")
def score(etiq, det):
"""{case: catégories de l'analyste}, {case: catégories des détecteurs} -> {clé: [étiquetées, signalées, les deux]}."""
return compter([x | {v} if (v := validite(x)) else x for x in (etiq[c], det[c])] for c in etiq)
def familles():
"""{catégorie du journal: famille} : chaque famille est sa propre catégorie (D-119), dans l'ordre de categories.py."""
return {c: c for c in categories.CATEGORIES}
def etiquettes_auto(station, debut, fin):
"""labeling/auto/<STATION>.jsonl -> les étiquettes de l'étiqueteur qui touchent [début, fin)."""
chemin = os.path.join(RACINE, "labeling", "auto", f"{station}.jsonl")
if not os.path.exists(chemin):
return []
with open(chemin, encoding="utf-8") as f:
return [e for e in map(json.loads, filter(str.strip, f)) if e["debut"] < fin and e["fin"] >= debut]
def familles_lot(dossier, debut, fin, etiq=None):
"""Score d'un lot par famille et par instant (D-112) -> ({famille: [étiquetés, signalés, les deux]}, étiquettes).
Un instant : une heure du lot où un capteur au moins a une mesure ; il reçoit les familles des étiquettes qui le
couvrent, bornes exclues (sauf un trou, sans mesure dedans), et celles des événements des détecteurs. etiq : les étiquettes, sinon labeling/auto/."""
# ponytail: par instant et non par capteur, les étiquettes ne disent leurs capteurs que dans le texte ; un champ
# capteurs dans l'étiquette, si cette finesse manque
mesures = charger(dossier)
if etiq is None:
etiq = etiquettes_auto(os.path.basename(os.path.normpath(dossier)), debut, fin)
evts = evenements(mesures, debut, fin, dossier)
instants = sorted({t for _, t in cases(mesures, debut, fin)})
# bornes exclues : elles sont la mesure saine d'avant et d'après (D-111) ; un trou, sans mesure dedans, les garde
vides = {i for i, e in enumerate(etiq) if not any(e["debut"] < t < e["fin"] for t in instants)}
paires = []
for t in instants:
a = {e.get("categorie", "sans famille") for i, e in enumerate(etiq)
if e["debut"] < t < e["fin"] or (i in vides and e["debut"] <= t <= e["fin"])} - {"None"}
d = {v["category"] for v in evts if v["start"] <= t <= v["end"]}
paires.append((a, d))
return compter(paires), etiq
def pct(a, b):
return f"{a}/{b} ({round(100 * a / b)} %)" if b else "—"
def afficher(titre, n):
print(titre)
print(f" {'':<22}{'trouvées':>20}{'justes':>20}")
for k in [*NIVEAUX, *sorted(set(n) - set(NIVEAUX))]:
if k in n:
lab, sig, both = n[k]
print(f" {k:<22}{pct(both, lab):>20}{pct(both, sig):>20}")
if __name__ == "__main__":
if len(sys.argv) == 6 and sys.argv[2::2] == ["--du", "--au"]:
station, du, au = os.path.basename(os.path.normpath(sys.argv[1])), iso(instant(sys.argv[3])), iso(instant(sys.argv[5]))
n, etiq = familles_lot(sys.argv[1], du, au)
if not etiq:
sys.exit(f"Aucune étiquette de {station} sur {du} → {au} dans labeling/auto/{station}.jsonl : "
"analyser la plage d'abord.")
afficher(f"{station} : {du} → {au}, {len(etiq)} étiquettes de labeling/auto/{station}.jsonl, par famille et par instant", n)
else:
sys.exit(__doc__)
+91
View File
@@ -0,0 +1,91 @@
---
name: detector-learner
description: Séance automatique d'amélioration des détecteurs du journal du matin depuis une analyse de la page Data de Diagnostic-app (labeling/auto/analyses/<analyse>/) — detectors-critic, detectors-upgrader, detectors-control ; le but, des détecteurs plus proches des étiquettes de l'analyse sur sa plage, sans sur-apprentissage ; le garde-fou, le benchmark sur toutes les stations et toutes les familles de labeling/auto/. Lancé par le bouton « Optimiser les détecteurs » de l'app (claude -p --plugin-dir detectors), ou par l'utilisateur, /detectors:detector-learner <analyse>.
argument-hint: "<analyse>"
---
# detector-learner : les détecteurs depuis une analyse
Tu es l'orchestrateur. Tu tournes dans le **dépôt de travail** (Diagnostic-app, le dossier courant) : `labeling/` (les étiquettes, la vérité ; les analyses), `data/` (les données des stations), `agent-tools/`. Le dépôt **detectors** y est monté en `detectors/` (un sous-module) : les détecteurs, leur registre des seuils `detectors/seuils-du-journal.md`, les scripts de ce skill (`detectors/skills/detector-learner/`) et les séances (`detectors/detector-learner/`). Deux dépôts git, donc : ce qui touche les détecteurs se commite dans `detectors/` (`git -C detectors …`), l'analyse dans le dépôt de travail.
L'utilisateur a choisi une plage où les détecteurs le satisfont mal ; l'analyste l'a analysée dans la page Data : un rapport (`rapport.md`) et des étiquettes, versées dans `labeling/auto/<STATION>.jsonl`. L'utilisateur l'a relue, et lancer cette séance vaut son accord : il n'y a pas d'autre validation. Le but : des détecteurs **plus proches des étiquettes de l'analyse sur sa plage**, par un petit pas, **sans sur-apprentissage** : ils font un peu mieux là, et le benchmark sur toutes les stations et familles de `labeling/auto/` reste bon. Tu appelles les agents dans l'ordre, tu transmets leurs rendus et tu commites ; en fin de séance, le releveur note leurs difficultés. **Tu ne juges rien toi-même** : tu lis seulement les lignes de verdict. **Tu ne poses aucune question à l'utilisateur** : la séance tourne seule jusqu'au bout.
## 1. Mise en place
- Argument : le nom d'une analyse, un dossier de `labeling/auto/analyses/` (ex. `NORDEND_2026-11-04T2112_2026-11-07T1412`) ; un chemin vers ce dossier vaut son nom. `ANALYSE` = le nom, `A` = `labeling/auto/analyses/<ANALYSE>`. Sans `<A>/demande.json`, ou sans `detectors/.claude-plugin/plugin.json` : dis-le et arrête-toi, sans commit.
- De `<A>/demande.json` : `STATION`, `début`, `fin` (UTC). `DU` = le jour de `début`, `AU` = le lendemain du jour de `fin` (AAAA-MM-JJ) : la plage des commandes, en jours entiers.
- `SEANCE` = `date -u +%Y-%m-%dT%H%MZ` ; dossier de séance `detectors/detector-learner/<SEANCE>_<ANALYSE>/`, ci-dessous `<séance>`.
- **Commits** : dans les deux dépôts, la branche doit être `main` (`git branch --show-current` et `git -C detectors branch --show-current`), sinon dis-le et arrête-toi ; un sous-module détaché (aucune branche) : `git -C detectors checkout main` d'abord, s'il n'a aucun changement. Tu commites toujours par chemin (`git add <chemins> && git commit -m "<message>" -- <chemins>`, ou avec `git -C detectors`, les chemins relatifs à `detectors/`), jamais `git add -A`, `git stash` ni `git checkout` hors de tes chemins : une autre session peut travailler dans ces dépôts. Avant chaque commit, la branche ; si ce n'est plus `main`, ne commite plus rien et passe au bilan. Chaque message finit par une ligne vide puis `Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>`. Tu ne pousses rien.
- **Étape 0, l'analyse dans git** : l'app ne commite pas ; si `git status --porcelain -- <A> labeling/auto/<STATION>.jsonl` montre quelque chose, commite ces deux chemins dans le dépôt de travail (`git add` respecte `.gitignore` : `travail/` reste dehors), message `Detector-learner <ANALYSE>: étiquettes de l'analyse`. Puis note la **base de la séance** : `git -C detectors rev-parse HEAD`.
- `git -C detectors status --porcelain` et `git status --porcelain -- labeling/auto/ labeling/familles.md` (`familles.md` : les familles, une par détecteur, que compte le benchmark) : les fichiers déjà modifiés y restent tels quels, ni commités ni annulés ; liste-les sous « Erreurs » du bilan (les mesures tournent sur eux). Refais ce relevé avant le contrôle et avant le bilan, avec les données repompées (`find -L data/ -name '*.csv' -newer <séance>/benchmark-avant.txt | cut -d/ -f2 | sort -u`) : un fichier changé pendant la séance par une autre session (une étiquette retouchée dans la page Data, par exemple) va sous « Erreurs » ; avant le contrôle, relance alors le benchmark avant à la base de la séance (dans un dossier `mktemp -d` : `git -C detectors archive <base> --prefix=detectors/ | tar -x -C <dossier>`, des liens vers `data/`, `labeling/` et `agent-tools/` du dépôt de travail, puis `python3 <dossier>/detectors/skills/detector-learner/regression.py`) dans `<séance>/benchmark-avant-relance.txt`, et ajoute à la demande du contrôle : `Changé pendant la séance : <chemins ou stations> ; benchmark avant relancé : <séance>/benchmark-avant-relance.txt.`
**Les deux mesures** de la séance, à chaque étape :
- **le benchmark**, la non-régression : `python3 detectors/skills/detector-learner/regression.py --seance <SEANCE>_<ANALYSE> --etape <étape> > <séance>/benchmark-<étape>.txt 2>&1` (environ 1 min 30). Le score par famille et par instant sur chaque station de `labeling/auto/`, puis leur `Total`, versé dans `detectors/detector-learner/historique.csv` ;
- **le score de la plage**, le but : `python3 detectors/skills/detector-learner/score.py data/<STATION> --du <DU> --au <AU> > <séance>/plage-<étape>.txt 2>&1`. Les étiquettes de `labeling/auto/<STATION>.jsonl` qui touchent la plage (celles de l'analyse comprises), la vérité de la séance, face aux détecteurs, par famille. Il sort en erreur si aucune étiquette ne touche la plage : note-le sous « Erreurs » et va au bilan sans toucher aux détecteurs.
**Commandes**, données telles quelles aux agents : le journal, `python3 detectors/categories.py data/<STATION> --du <DU> --au <AU>` ; les capteurs, `python3 detectors/skills/detector-learner/capteurs.py data/<STATION> --du <DU> --au <AU>`. Pour le contrôle seulement, qui regarde toutes les stations, le journal avec `<STATION>`, `<du>` et `<au>` à remplir depuis l'en-tête du bloc de la station dans le benchmark : `python3 detectors/categories.py data/<STATION> --du <du> --au <au>`.
## 2. Dans l'ordre
Chaque agent est appelé par l'outil Agent avec son `subagent_type` (ceux de ce plugin : `detectors:detectors-critic`, `detectors:detectors-upgrader`, `detectors:detectors-control`, `detectors:releveur`) et la demande ci-dessous, rien d'autre, sauf une consigne de l'utilisateur donnée au lancement : ajoute-la telle quelle à la demande des agents (`Consigne de l'utilisateur : …`) et note-la au bilan ; elle passe avant leurs consignes, pas avant leur périmètre de fichiers. Un verdict se lit par `grep '^\*\*Verdict\*\* :' <rendu>` ; ce qui l'accompagne (« Réserves » du contrôle) ne change pas la suite, il va au bilan. Le but : des détecteurs qui font mieux, pas parfaits ; une autre lecture que les étiquettes, cohérente, est admise.
Les commits de séance (le dossier de séance, `detector-learner/historique.csv`, les détecteurs, `seuils-du-journal.md`) se font dans `detectors/` : `git -C detectors add <chemins relatifs> && git -C detectors commit -m "<message>" -- <chemins relatifs>`.
1. **Mesures avant** : étape `avant`, donc `<séance>/benchmark-avant.txt` et `<séance>/plage-avant.txt`.
Commit `detector-learner/<SEANCE>_<ANALYSE>/ detector-learner/historique.csv`, message `Detector-learner <ANALYSE>: benchmark`.
2. **Detectors-critic** : `Analyse : <A>/. Station : <STATION>, plage <début> → <fin> (UTC). Commande du journal : <commande>. Commande des capteurs : <commande des capteurs>. Score de la plage : <séance>/plage-avant.txt. Benchmark : <séance>/benchmark-avant.txt. Écris <séance>/critique.md.`
Commit du dossier de séance, message `Detector-learner <ANALYSE>: critique (<verdict>)`. Verdict `d'accord` : va au bilan.
3. **Detectors-upgrader**, un seul passage :
`Analyse : <A>/. Station : <STATION>. Commande du journal : <commande>. Critique : <séance>/critique.md. Benchmark avant : <séance>/benchmark-avant.txt, à relancer par python3 detectors/skills/detector-learner/regression.py (sans --etape). Score de la plage : python3 detectors/skills/detector-learner/score.py data/<STATION> --du <DU> --au <AU> (avant : <séance>/plage-avant.txt). Dossier de séance : <séance>. Fichiers déjà modifiés au début de la séance : <liste | aucun>. Écris <séance>/modification-1.md.`
L'upgrader commite lui-même, dans `detectors/`, chaque suggestion gardée, avec son benchmark `<séance>/benchmark-1-S<n>.txt`, message `Detector-learner <ANALYSE>: modification 1, S<n>` : le contrôle peut ainsi en faire retirer une seule.
Puis les mesures, étape `modification 1`, dans `<séance>/benchmark-1.txt` et `<séance>/plage-1.txt`.
Commit, dans `detectors/`, des détecteurs (`*.py` à la racine), de `seuils-du-journal.md`, du dossier de séance et de `detector-learner/historique.csv` (sans les fichiers déjà modifiés notés au §1), message `Detector-learner <ANALYSE>: modification 1`. Aucune suggestion gardée (pas de commit `, S<n>` : `git -C detectors log --format=%h --grep ', S[0-9]*$' <base>..HEAD`) : va au bilan.
4. **Detectors-control**, qui ne lit ni la critique ni le détail de la modification :
`Analyse : <ANALYSE>. Modification : <séance>/modification-1.md. Benchmark : <séance>/benchmark-avant.txt → <séance>/benchmark-1.txt, à relancer par python3 detectors/skills/detector-learner/regression.py (sans --etape) ; après chaque suggestion : <séance>/benchmark-1-S*.txt. Score de la plage : <séance>/plage-avant.txt → <séance>/plage-1.txt. Commande du journal : <commande du contrôle>. Base (dans detectors/) : <base de la séance>. Écris <séance>/validation-1.md.`
Commit du dossier de séance, message `Detector-learner <ANALYSE>: control (<verdict>)`.
- `garder` : va au bilan.
- `retirer` : pour chaque suggestion de la ligne `**Retirer** :`, ses commits de la séance (`git -C detectors log --format=%h --grep ', S<n>$' <base de la séance>..HEAD`), du plus récent au plus ancien : `git -C detectors revert --no-edit <commit>`, puis amende son message pour qu'il finisse par la ligne `Co-Authored-By` (`git -C detectors commit --amend -m "Detector-learner <ANALYSE>: S<n> retirée" -m "Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>"`). Un conflit : `git -C detectors revert --abort`, et fais comme pour `annuler`. Puis va au bilan.
- `annuler`, ou tout autre mot : `git -C detectors checkout <base de la séance> -- '*.py' seuils-du-journal.md` (sans les fichiers déjà modifiés notés au §1 ; `skills/` n'est pas touché), commit de ces chemins, message `Detector-learner <ANALYSE>: modification annulée`.
Un rendu absent ou sans verdict lisible : note-le, remets les détecteurs comme pour `annuler` s'ils ont changé, passe au bilan. Ne relance pas un agent plus d'une fois.
## 3. Bilan
Les mesures, étape `fin`, dans `<séance>/benchmark-fin.txt` et `<séance>/plage-fin.txt`.
`<séance>/bilan.md`, que la page Data affiche sous le rapport :
```markdown
# Optimisation : <ANALYSE>
**Résultat** : modification gardée | gardée sans S<n>… | annulée | aucune | erreur
## La plage de l'analyse
<STATION>, <début> → <fin> ; le score de la plage, avant → fin, une ligne par famille (trouvées, justes)
## Toutes les stations
la ligne de chaque famille du `Total`, avant → fin ; puis les autres lignes changées (station, famille), avant → fin
## Ce qui a changé
<par suggestion gardée, une phrase (de « Ce qui a changé » de la modification)> ; la critique (d'accord / n suggestions), le contrôle (verdict)
## À trancher par l'utilisateur
<copiés tels quels : « Limites » de la critique, « À trancher par l'utilisateur » de la modification, « Réserves » du contrôle ; aucune s'il n'y a rien>
## Suggestions non traitées
<« Pas corrigé » de la modification ; aucune>
## Erreurs
<aucune, ou ce qui manquait ; la base de la séance et `git -C detectors log --oneline <base>..HEAD`>
```
Commit, dans `detectors/`, du dossier de séance et de `detector-learner/historique.csv`, message `Detector-learner <ANALYSE>: bilan`. Puis, dans le dépôt de travail, le sous-module à son nouveau commit : `git add detectors && git commit -m "Detector-learner <ANALYSE>: détecteurs" -- detectors`, si `git status --porcelain -- detectors` le montre changé.
## 4. Difficultés
**Releveur** (`detectors:releveur`), une fois, même si tout s'est bien passé : `Processus : /detector-learner (detectors/skills/detector-learner/SKILL.md). Séance : <séance>/ : la section « Difficultés » de chaque rendu, et « Erreurs » du bilan. Difficultés de l'orchestrateur : aucune | <…>.`
Si `git -C detectors status --short ameliorations-processus.md` montre un changement : commit de ce chemin dans `detectors/`, message `Detector-learner <ANALYSE>: process difficulties`.
## 5. Réponse finale
En 4 lignes au plus : la ligne `**Résultat**` du bilan, le score de la plage avant → fin (familles changées), le `Total` avant → fin s'il a changé, le chemin du bilan. Rien n'est poussé : l'utilisateur pousse `detectors` pour que tous aient les détecteurs à jour, ou annule ce qu'il ne garde pas par `git -C detectors revert`.